(API Change) Unsquish obs_data_* names

Changed:                 To:
-----------------------------------------------
obs_data_getjson         obs_data_get_json
obs_data_getstring       obs_data_get_string
obs_data_getint          obs_data_get_int
obs_data_getdouble       obs_data_get_double
obs_data_getbool         obs_data_get_bool
obs_data_getobj          obs_data_get_obj
obs_data_getarray        obs_data_get_array
obs_data_setstring       obs_data_set_string
obs_data_setint          obs_data_set_int
obs_data_setdouble       obs_data_set_double
obs_data_setbool         obs_data_set_bool
obs_data_setobj          obs_data_set_obj
obs_data_setarray        obs_data_set_array
obs_data_item_getstring  obs_data_item_get_string
obs_data_item_getint     obs_data_item_get_int
obs_data_item_getdouble  obs_data_item_get_double
obs_data_item_getbool    obs_data_item_get_bool
obs_data_item_getobj     obs_data_item_get_obj
obs_data_item_getarray   obs_data_item_get_array
obs_data_item_setstring  obs_data_item_set_string
obs_data_item_setint     obs_data_item_set_int
obs_data_item_setdouble  obs_data_item_set_double
obs_data_item_setbool    obs_data_item_set_bool
obs_data_item_setobj     obs_data_item_set_obj
obs_data_item_setarray   obs_data_item_set_array

libobs/obs-data.c

@@ -478,7 +478,7 @@ static inline void obs_data_add_json_object(obs_data_t data, const char *key,
 	obs_data_t sub_obj = obs_data_create();
 
 	obs_data_add_json_object_data(sub_obj, jobj);
-	obs_data_setobj(data, key, sub_obj);
+	obs_data_set_obj(data, key, sub_obj);
 	obs_data_release(sub_obj);
 }
 
@@ -501,7 +501,7 @@ static void obs_data_add_json_array(obs_data_t data, const char *key,
 		obs_data_release(item);
 	}
 
-	obs_data_setarray(data, key, array);
+	obs_data_set_array(data, key, array);
 	obs_data_array_release(array);
 }
 
@@ -513,15 +513,15 @@ static void obs_data_add_json_item(obs_data_t data, const char *key,
 	else if (json_is_array(json))
 		obs_data_add_json_array(data, key, json);
 	else if (json_is_string(json))
-		obs_data_setstring(data, key, json_string_value(json));
+		obs_data_set_string(data, key, json_string_value(json));
 	else if (json_is_integer(json))
-		obs_data_setint(data, key, json_integer_value(json));
+		obs_data_set_int(data, key, json_integer_value(json));
 	else if (json_is_real(json))
-		obs_data_setdouble(data, key, json_real_value(json));
+		obs_data_set_double(data, key, json_real_value(json));
 	else if (json_is_true(json))
-		obs_data_setbool(data, key, true);
+		obs_data_set_bool(data, key, true);
 	else if (json_is_false(json))
-		obs_data_setbool(data, key, false);
+		obs_data_set_bool(data, key, false);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -529,7 +529,7 @@ static void obs_data_add_json_item(obs_data_t data, const char *key,
 static inline void set_json_string(json_t *json, const char *name,
 		obs_data_item_t item)
 {
-	const char *val = obs_data_item_getstring(item);
+	const char *val = obs_data_item_get_string(item);
 	json_object_set_new(json, name, json_string(val));
 }
 
@@ -539,10 +539,10 @@ static inline void set_json_number(json_t *json, const char *name,
 	enum obs_data_number_type type = obs_data_item_numtype(item);
 
 	if (type == OBS_DATA_NUM_INT) {
-		long long val = obs_data_item_getint(item);
+		long long val = obs_data_item_get_int(item);
 		json_object_set_new(json, name, json_integer(val));
 	} else {
-		double val = obs_data_item_getdouble(item);
+		double val = obs_data_item_get_double(item);
 		json_object_set_new(json, name, json_real(val));
 	}
 }
@@ -550,7 +550,7 @@ static inline void set_json_number(json_t *json, const char *name,
 static inline void set_json_bool(json_t *json, const char *name,
 		obs_data_item_t item)
 {
-	bool val = obs_data_item_getbool(item);
+	bool val = obs_data_item_get_bool(item);
 	json_object_set_new(json, name, val ? json_true() : json_false());
 }
 
@@ -559,7 +559,7 @@ static json_t *obs_data_to_json(obs_data_t data);
 static inline void set_json_obj(json_t *json, const char *name,
 		obs_data_item_t item)
 {
-	obs_data_t obj = obs_data_item_getobj(item);
+	obs_data_t obj = obs_data_item_get_obj(item);
 	json_object_set_new(json, name, obs_data_to_json(obj));
 	obs_data_release(obj);
 }
@@ -568,7 +568,7 @@ static inline void set_json_array(json_t *json, const char *name,
 		obs_data_item_t item)
 {
 	json_t           *jarray = json_array();
-	obs_data_array_t array   = obs_data_item_getarray(item);
+	obs_data_array_t array   = obs_data_item_get_array(item);
 	size_t           count   = obs_data_array_count(array);
 
 	for (size_t idx = 0; idx < count; idx++) {
@@ -667,7 +667,7 @@ void obs_data_release(obs_data_t data)
 		obs_data_destroy(data);
 }
 
-const char *obs_data_getjson(obs_data_t data)
+const char *obs_data_get_json(obs_data_t data)
 {
 	if (!data) return NULL;
 
@@ -863,32 +863,32 @@ static inline void obs_set_array(obs_data_t data, obs_data_item_t *item,
 	set_item_(data, item, name, &array, sizeof(obs_data_t), OBS_DATA_ARRAY);
 }
 
-void obs_data_setstring(obs_data_t data, const char *name, const char *val)
+void obs_data_set_string(obs_data_t data, const char *name, const char *val)
 {
 	obs_set_string(data, NULL, name, val, set_item);
 }
 
-void obs_data_setint(obs_data_t data, const char *name, long long val)
+void obs_data_set_int(obs_data_t data, const char *name, long long val)
 {
 	obs_set_int(data, NULL, name, val, set_item);
 }
 
-void obs_data_setdouble(obs_data_t data, const char *name, double val)
+void obs_data_set_double(obs_data_t data, const char *name, double val)
 {
 	obs_set_double(data, NULL, name, val, set_item);
 }
 
-void obs_data_setbool(obs_data_t data, const char *name, bool val)
+void obs_data_set_bool(obs_data_t data, const char *name, bool val)
 {
 	obs_set_bool(data, NULL, name, val, set_item);
 }
 
-void obs_data_setobj(obs_data_t data, const char *name, obs_data_t obj)
+void obs_data_set_obj(obs_data_t data, const char *name, obs_data_t obj)
 {
 	obs_set_obj(data, NULL, name, obj, set_item);
 }
 
-void obs_data_setarray(obs_data_t data, const char *name,
+void obs_data_set_array(obs_data_t data, const char *name,
 		obs_data_array_t array)
 {
 	obs_set_array(data, NULL, name, array, set_item);
@@ -955,34 +955,34 @@ void obs_data_set_autoselect_array(obs_data_t data, const char *name,
 	obs_set_array(data, NULL, name, arr, set_item_auto);
 }
 
-const char *obs_data_getstring(obs_data_t data, const char *name)
+const char *obs_data_get_string(obs_data_t data, const char *name)
 {
-	return obs_data_item_getstring(get_item(data, name));
+	return obs_data_item_get_string(get_item(data, name));
 }
 
-long long obs_data_getint(obs_data_t data, const char *name)
+long long obs_data_get_int(obs_data_t data, const char *name)
 {
-	return obs_data_item_getint(get_item(data, name));
+	return obs_data_item_get_int(get_item(data, name));
 }
 
-double obs_data_getdouble(obs_data_t data, const char *name)
+double obs_data_get_double(obs_data_t data, const char *name)
 {
-	return obs_data_item_getdouble(get_item(data, name));
+	return obs_data_item_get_double(get_item(data, name));
 }
 
-bool obs_data_getbool(obs_data_t data, const char *name)
+bool obs_data_get_bool(obs_data_t data, const char *name)
 {
-	return obs_data_item_getbool(get_item(data, name));
+	return obs_data_item_get_bool(get_item(data, name));
 }
 
-obs_data_t obs_data_getobj(obs_data_t data, const char *name)
+obs_data_t obs_data_get_obj(obs_data_t data, const char *name)
 {
-	return obs_data_item_getobj(get_item(data, name));
+	return obs_data_item_get_obj(get_item(data, name));
 }
 
-obs_data_array_t obs_data_getarray(obs_data_t data, const char *name)
+obs_data_array_t obs_data_get_array(obs_data_t data, const char *name)
 {
-	return obs_data_item_getarray(get_item(data, name));
+	return obs_data_item_get_array(get_item(data, name));
 }
 
 const char *obs_data_get_default_string(obs_data_t data, const char *name)
@@ -1294,32 +1294,32 @@ enum obs_data_number_type obs_data_item_numtype(obs_data_item_t item)
 	return num->type;
 }
 
-void obs_data_item_setstring(obs_data_item_t *item, const char *val)
+void obs_data_item_set_string(obs_data_item_t *item, const char *val)
 {
 	obs_set_string(NULL, item, NULL, val, set_item);
 }
 
-void obs_data_item_setint(obs_data_item_t *item, long long val)
+void obs_data_item_set_int(obs_data_item_t *item, long long val)
 {
 	obs_set_int(NULL, item, NULL, val, set_item);
 }
 
-void obs_data_item_setdouble(obs_data_item_t *item, double val)
+void obs_data_item_set_double(obs_data_item_t *item, double val)
 {
 	obs_set_double(NULL, item, NULL, val, set_item);
 }
 
-void obs_data_item_setbool(obs_data_item_t *item, bool val)
+void obs_data_item_set_bool(obs_data_item_t *item, bool val)
 {
 	obs_set_bool(NULL, item, NULL, val, set_item);
 }
 
-void obs_data_item_setobj(obs_data_item_t *item, obs_data_t val)
+void obs_data_item_set_obj(obs_data_item_t *item, obs_data_t val)
 {
 	obs_set_obj(NULL, item, NULL, val, set_item);
 }
 
-void obs_data_item_setarray(obs_data_item_t *item, obs_data_array_t val)
+void obs_data_item_set_array(obs_data_item_t *item, obs_data_array_t val)
 {
 	obs_set_array(NULL, item, NULL, val, set_item);
 }
@@ -1471,32 +1471,32 @@ static inline obs_data_array_t data_item_get_array(obs_data_item_t item,
 	return array;
 }
 
-const char *obs_data_item_getstring(obs_data_item_t item)
+const char *obs_data_item_get_string(obs_data_item_t item)
 {
 	return data_item_get_string(item, get_item_data);
 }
 
-long long obs_data_item_getint(obs_data_item_t item)
+long long obs_data_item_get_int(obs_data_item_t item)
 {
 	return data_item_get_int(item, get_item_data);
 }
 
-double obs_data_item_getdouble(obs_data_item_t item)
+double obs_data_item_get_double(obs_data_item_t item)
 {
 	return data_item_get_double(item, get_item_data);
 }
 
-bool obs_data_item_getbool(obs_data_item_t item)
+bool obs_data_item_get_bool(obs_data_item_t item)
 {
 	return data_item_get_bool(item, get_item_data);
 }
 
-obs_data_t obs_data_item_getobj(obs_data_item_t item)
+obs_data_t obs_data_item_get_obj(obs_data_item_t item)
 {
 	return data_item_get_obj(item, get_item_obj);
 }
 
-obs_data_array_t obs_data_item_getarray(obs_data_item_t item)
+obs_data_array_t obs_data_item_get_array(obs_data_item_t item)
 {
 	return data_item_get_array(item, get_item_array);
 }
@@ -1570,8 +1570,8 @@ static inline void set_vec2(obs_data_t data, const char *name,
 		const struct vec2 *val, set_obj_t set_obj)
 {
 	obs_data_t obj = obs_data_create();
-	obs_data_setdouble(obj, "x", val->x);
-	obs_data_setdouble(obj, "y", val->y);
+	obs_data_set_double(obj, "x", val->x);
+	obs_data_set_double(obj, "y", val->y);
 	set_obj(data, name, obj);
 	obs_data_release(obj);
 }
@@ -1580,9 +1580,9 @@ static inline void set_vec3(obs_data_t data, const char *name,
 		const struct vec3 *val, set_obj_t set_obj)
 {
 	obs_data_t obj = obs_data_create();
-	obs_data_setdouble(obj, "x", val->x);
-	obs_data_setdouble(obj, "y", val->y);
-	obs_data_setdouble(obj, "z", val->z);
+	obs_data_set_double(obj, "x", val->x);
+	obs_data_set_double(obj, "y", val->y);
+	obs_data_set_double(obj, "z", val->z);
 	set_obj(data, name, obj);
 	obs_data_release(obj);
 }
@@ -1591,10 +1591,10 @@ static inline void set_vec4(obs_data_t data, const char *name,
 		const struct vec4 *val, set_obj_t set_obj)
 {
 	obs_data_t obj = obs_data_create();
-	obs_data_setdouble(obj, "x", val->x);
-	obs_data_setdouble(obj, "y", val->y);
-	obs_data_setdouble(obj, "z", val->z);
-	obs_data_setdouble(obj, "w", val->w);
+	obs_data_set_double(obj, "x", val->x);
+	obs_data_set_double(obj, "y", val->y);
+	obs_data_set_double(obj, "z", val->z);
+	obs_data_set_double(obj, "w", val->w);
 	set_obj(data, name, obj);
 	obs_data_release(obj);
 }
@@ -1603,10 +1603,10 @@ static inline void set_quat(obs_data_t data, const char *name,
 		const struct quat *val, set_obj_t set_obj)
 {
 	obs_data_t obj = obs_data_create();
-	obs_data_setdouble(obj, "x", val->x);
-	obs_data_setdouble(obj, "y", val->y);
-	obs_data_setdouble(obj, "z", val->z);
-	obs_data_setdouble(obj, "w", val->w);
+	obs_data_set_double(obj, "x", val->x);
+	obs_data_set_double(obj, "y", val->y);
+	obs_data_set_double(obj, "z", val->z);
+	obs_data_set_double(obj, "w", val->w);
 	set_obj(data, name, obj);
 	obs_data_release(obj);
 }
@@ -1614,25 +1614,25 @@ static inline void set_quat(obs_data_t data, const char *name,
 void obs_data_set_vec2(obs_data_t data, const char *name,
 		const struct vec2 *val)
 {
-	set_vec2(data, name, val, obs_data_setobj);
+	set_vec2(data, name, val, obs_data_set_obj);
 }
 
 void obs_data_set_vec3(obs_data_t data, const char *name,
 		const struct vec3 *val)
 {
-	set_vec3(data, name, val, obs_data_setobj);
+	set_vec3(data, name, val, obs_data_set_obj);
 }
 
 void obs_data_set_vec4(obs_data_t data, const char *name,
 		const struct vec4 *val)
 {
-	set_vec4(data, name, val, obs_data_setobj);
+	set_vec4(data, name, val, obs_data_set_obj);
 }
 
 void obs_data_set_quat(obs_data_t data, const char *name,
 		const struct quat *val)
 {
-	set_quat(data, name, val, obs_data_setobj);
+	set_quat(data, name, val, obs_data_set_obj);
 }
 
 void obs_data_set_default_vec2(obs_data_t data, const char *name,
@@ -1687,8 +1687,8 @@ static inline void get_vec2(obs_data_t obj, struct vec2 *val)
 {
 	if (!obj) return;
 
-	val->x = (float)obs_data_getdouble(obj, "x");
-	val->y = (float)obs_data_getdouble(obj, "y");
+	val->x = (float)obs_data_get_double(obj, "x");
+	val->y = (float)obs_data_get_double(obj, "y");
 	obs_data_release(obj);
 }
 
@@ -1696,9 +1696,9 @@ static inline void get_vec3(obs_data_t obj, struct vec3 *val)
 {
 	if (!obj) return;
 
-	val->x = (float)obs_data_getdouble(obj, "x");
-	val->y = (float)obs_data_getdouble(obj, "y");
-	val->z = (float)obs_data_getdouble(obj, "z");
+	val->x = (float)obs_data_get_double(obj, "x");
+	val->y = (float)obs_data_get_double(obj, "y");
+	val->z = (float)obs_data_get_double(obj, "z");
 	obs_data_release(obj);
 }
 
@@ -1706,10 +1706,10 @@ static inline void get_vec4(obs_data_t obj, struct vec4 *val)
 {
 	if (!obj) return;
 
-	val->x = (float)obs_data_getdouble(obj, "x");
-	val->y = (float)obs_data_getdouble(obj, "y");
-	val->z = (float)obs_data_getdouble(obj, "z");
-	val->w = (float)obs_data_getdouble(obj, "w");
+	val->x = (float)obs_data_get_double(obj, "x");
+	val->y = (float)obs_data_get_double(obj, "y");
+	val->z = (float)obs_data_get_double(obj, "z");
+	val->w = (float)obs_data_get_double(obj, "w");
 	obs_data_release(obj);
 }
 
@@ -1717,31 +1717,31 @@ static inline void get_quat(obs_data_t obj, struct quat *val)
 {
 	if (!obj) return;
 
-	val->x = (float)obs_data_getdouble(obj, "x");
-	val->y = (float)obs_data_getdouble(obj, "y");
-	val->z = (float)obs_data_getdouble(obj, "z");
-	val->w = (float)obs_data_getdouble(obj, "w");
+	val->x = (float)obs_data_get_double(obj, "x");
+	val->y = (float)obs_data_get_double(obj, "y");
+	val->z = (float)obs_data_get_double(obj, "z");
+	val->w = (float)obs_data_get_double(obj, "w");
 	obs_data_release(obj);
 }
 
 void obs_data_get_vec2(obs_data_t data, const char *name, struct vec2 *val)
 {
-	get_vec2(obs_data_getobj(data, name), val);
+	get_vec2(obs_data_get_obj(data, name), val);
 }
 
 void obs_data_get_vec3(obs_data_t data, const char *name, struct vec3 *val)
 {
-	get_vec3(obs_data_getobj(data, name), val);
+	get_vec3(obs_data_get_obj(data, name), val);
 }
 
 void obs_data_get_vec4(obs_data_t data, const char *name, struct vec4 *val)
 {
-	get_vec4(obs_data_getobj(data, name), val);
+	get_vec4(obs_data_get_obj(data, name), val);
 }
 
 void obs_data_get_quat(obs_data_t data, const char *name, struct quat *val)
 {
-	get_quat(obs_data_getobj(data, name), val);
+	get_quat(obs_data_get_obj(data, name), val);
 }
 
 void obs_data_get_default_vec2(obs_data_t data, const char *name,

libobs/obs-data.h

@@ -65,21 +65,21 @@ EXPORT obs_data_t obs_data_create_from_json(const char *json_string);
 EXPORT void obs_data_addref(obs_data_t data);
 EXPORT void obs_data_release(obs_data_t data);
 
-EXPORT const char *obs_data_getjson(obs_data_t data);
+EXPORT const char *obs_data_get_json(obs_data_t data);
 
 EXPORT void obs_data_apply(obs_data_t target, obs_data_t apply_data);
 
 EXPORT void obs_data_erase(obs_data_t data, const char *name);
 
 /* Set functions */
-EXPORT void obs_data_setstring(obs_data_t data, const char *name,
+EXPORT void obs_data_set_string(obs_data_t data, const char *name,
 		const char *val);
-EXPORT void obs_data_setint(obs_data_t data, const char *name,
+EXPORT void obs_data_set_int(obs_data_t data, const char *name,
 		long long val);
-EXPORT void obs_data_setdouble(obs_data_t data, const char *name, double val);
-EXPORT void obs_data_setbool(obs_data_t data, const char *name, bool val);
-EXPORT void obs_data_setobj(obs_data_t data, const char *name, obs_data_t obj);
-EXPORT void obs_data_setarray(obs_data_t data, const char *name,
+EXPORT void obs_data_set_double(obs_data_t data, const char *name, double val);
+EXPORT void obs_data_set_bool(obs_data_t data, const char *name, bool val);
+EXPORT void obs_data_set_obj(obs_data_t data, const char *name, obs_data_t obj);
+EXPORT void obs_data_set_array(obs_data_t data, const char *name,
 		obs_data_array_t array);
 
 /*
@@ -115,12 +115,12 @@ EXPORT void obs_data_set_autoselect_obj(obs_data_t data, const char *name,
 /*
  * Get functions
  */
-EXPORT const char *obs_data_getstring(obs_data_t data, const char *name);
-EXPORT long long obs_data_getint(obs_data_t data, const char *name);
-EXPORT double obs_data_getdouble(obs_data_t data, const char *name);
-EXPORT bool obs_data_getbool(obs_data_t data, const char *name);
-EXPORT obs_data_t obs_data_getobj(obs_data_t data, const char *name);
-EXPORT obs_data_array_t obs_data_getarray(obs_data_t data, const char *name);
+EXPORT const char *obs_data_get_string(obs_data_t data, const char *name);
+EXPORT long long obs_data_get_int(obs_data_t data, const char *name);
+EXPORT double obs_data_get_double(obs_data_t data, const char *name);
+EXPORT bool obs_data_get_bool(obs_data_t data, const char *name);
+EXPORT obs_data_t obs_data_get_obj(obs_data_t data, const char *name);
+EXPORT obs_data_array_t obs_data_get_array(obs_data_t data, const char *name);
 
 EXPORT const char *obs_data_get_default_string(obs_data_t data,
 		const char *name);
@@ -189,12 +189,13 @@ EXPORT enum obs_data_type obs_data_item_gettype(obs_data_item_t item);
 EXPORT enum obs_data_number_type obs_data_item_numtype(obs_data_item_t item);
 
 /* Item set functions */
-EXPORT void obs_data_item_setstring(obs_data_item_t *item, const char *val);
-EXPORT void obs_data_item_setint(obs_data_item_t *item, long long val);
-EXPORT void obs_data_item_setdouble(obs_data_item_t *item, double val);
-EXPORT void obs_data_item_setbool(obs_data_item_t *item, bool val);
-EXPORT void obs_data_item_setobj(obs_data_item_t *item, obs_data_t val);
-EXPORT void obs_data_item_setarray(obs_data_item_t *item, obs_data_array_t val);
+EXPORT void obs_data_item_set_string(obs_data_item_t *item, const char *val);
+EXPORT void obs_data_item_set_int(obs_data_item_t *item, long long val);
+EXPORT void obs_data_item_set_double(obs_data_item_t *item, double val);
+EXPORT void obs_data_item_set_bool(obs_data_item_t *item, bool val);
+EXPORT void obs_data_item_set_obj(obs_data_item_t *item, obs_data_t val);
+EXPORT void obs_data_item_set_array(obs_data_item_t *item,
+		obs_data_array_t val);
 
 EXPORT void obs_data_item_set_default_string(obs_data_item_t *item,
 		const char *val);
@@ -219,12 +220,12 @@ EXPORT void obs_data_item_set_autoselect_array(obs_data_item_t *item,
 		obs_data_array_t val);
 
 /* Item get functions */
-EXPORT const char *obs_data_item_getstring(obs_data_item_t item);
-EXPORT long long obs_data_item_getint(obs_data_item_t item);
-EXPORT double obs_data_item_getdouble(obs_data_item_t item);
-EXPORT bool obs_data_item_getbool(obs_data_item_t item);
-EXPORT obs_data_t obs_data_item_getobj(obs_data_item_t item);
-EXPORT obs_data_array_t obs_data_item_getarray(obs_data_item_t item);
+EXPORT const char *obs_data_item_get_string(obs_data_item_t item);
+EXPORT long long obs_data_item_get_int(obs_data_item_t item);
+EXPORT double obs_data_item_get_double(obs_data_item_t item);
+EXPORT bool obs_data_item_get_bool(obs_data_item_t item);
+EXPORT obs_data_t obs_data_item_get_obj(obs_data_item_t item);
+EXPORT obs_data_array_t obs_data_item_get_array(obs_data_item_t item);
 
 EXPORT const char *obs_data_item_get_default_string(obs_data_item_t item);
 EXPORT long long obs_data_item_get_default_int(obs_data_item_t item);

libobs/obs-scene.c

@@ -333,7 +333,7 @@ static void scene_video_render(void *data, effect_t effect)
 
 static void scene_load_item(struct obs_scene *scene, obs_data_t item_data)
 {
-	const char            *name = obs_data_getstring(item_data, "name");
+	const char            *name = obs_data_get_string(item_data, "name");
 	obs_source_t          source = obs_get_source_by_name(name);
 	struct obs_scene_item *item;
 
@@ -348,16 +348,17 @@ static void scene_load_item(struct obs_scene *scene, obs_data_t item_data)
 	obs_data_set_default_int(item_data, "align",
 			OBS_ALIGN_TOP | OBS_ALIGN_LEFT);
 
-	item->rot     = (float)obs_data_getdouble(item_data, "rot");
-	item->align   = (uint32_t)obs_data_getint(item_data, "align");
-	item->visible = obs_data_getbool(item_data, "visible");
+	item->rot     = (float)obs_data_get_double(item_data, "rot");
+	item->align   = (uint32_t)obs_data_get_int(item_data, "align");
+	item->visible = obs_data_get_bool(item_data, "visible");
 	obs_data_get_vec2(item_data, "pos",    &item->pos);
 	obs_data_get_vec2(item_data, "scale",  &item->scale);
 
 	item->bounds_type =
-		(enum obs_bounds_type)obs_data_getint(item_data, "bounds_type");
+		(enum obs_bounds_type)obs_data_get_int(item_data,
+				"bounds_type");
 	item->bounds_align =
-		(uint32_t)obs_data_getint(item_data, "bounds_align");
+		(uint32_t)obs_data_get_int(item_data, "bounds_align");
 	obs_data_get_vec2(item_data, "bounds", &item->bounds);
 
 	obs_source_release(source);
@@ -367,7 +368,7 @@ static void scene_load_item(struct obs_scene *scene, obs_data_t item_data)
 
 static void scene_load(void *scene, obs_data_t settings)
 {
-	obs_data_array_t items = obs_data_getarray(settings, "items");
+	obs_data_array_t items = obs_data_get_array(settings, "items");
 	size_t           count, i;
 
 	remove_all_items(scene);
@@ -390,14 +391,14 @@ static void scene_save_item(obs_data_array_t array, struct obs_scene_item *item)
 	obs_data_t item_data = obs_data_create();
 	const char *name     = obs_source_get_name(item->source);
 
-	obs_data_setstring(item_data, "name",         name);
-	obs_data_setbool  (item_data, "visible",      item->visible);
-	obs_data_setdouble(item_data, "rot",          item->rot);
+	obs_data_set_string(item_data, "name",         name);
+	obs_data_set_bool  (item_data, "visible",      item->visible);
+	obs_data_set_double(item_data, "rot",          item->rot);
 	obs_data_set_vec2 (item_data, "pos",          &item->pos);
 	obs_data_set_vec2 (item_data, "scale",        &item->scale);
-	obs_data_setint   (item_data, "align",        (int)item->align);
-	obs_data_setint   (item_data, "bounds_type",  (int)item->bounds_type);
-	obs_data_setint   (item_data, "bounds_align", (int)item->bounds_align);
+	obs_data_set_int   (item_data, "align",        (int)item->align);
+	obs_data_set_int   (item_data, "bounds_type",  (int)item->bounds_type);
+	obs_data_set_int   (item_data, "bounds_align", (int)item->bounds_align);
 	obs_data_set_vec2 (item_data, "bounds",       &item->bounds);
 
 	obs_data_array_push_back(array, item_data);
@@ -420,7 +421,7 @@ static void scene_save(void *data, obs_data_t settings)
 
 	pthread_mutex_unlock(&scene->mutex);
 
-	obs_data_setarray(settings, "items", array);
+	obs_data_set_array(settings, "items", array);
 	obs_data_array_release(array);
 }
 

libobs/obs.c

@@ -1161,15 +1161,15 @@ float obs_get_present_volume(void)
 obs_source_t obs_load_source(obs_data_t source_data)
 {
 	obs_source_t source;
-	const char   *name    = obs_data_getstring(source_data, "name");
-	const char   *id      = obs_data_getstring(source_data, "id");
-	obs_data_t   settings = obs_data_getobj(source_data, "settings");
+	const char   *name    = obs_data_get_string(source_data, "name");
+	const char   *id      = obs_data_get_string(source_data, "id");
+	obs_data_t   settings = obs_data_get_obj(source_data, "settings");
 	double       volume;
 
 	source = obs_source_create(OBS_SOURCE_TYPE_INPUT, id, name, settings);
 
 	obs_data_set_default_double(source_data, "volume", 1.0);
-	volume = obs_data_getdouble(source_data, "volume");
+	volume = obs_data_get_double(source_data, "volume");
 	obs_source_set_volume(source, (float)volume);
 
 	obs_data_release(settings);
@@ -1215,10 +1215,10 @@ obs_data_t obs_save_source(obs_source_t source)
 
 	obs_source_save(source);
 
-	obs_data_setstring(source_data, "name",     name);
-	obs_data_setstring(source_data, "id",       id);
-	obs_data_setobj   (source_data, "settings", settings);
-	obs_data_setdouble(source_data, "volume",   volume);
+	obs_data_set_string(source_data, "name",     name);
+	obs_data_set_string(source_data, "id",       id);
+	obs_data_set_obj   (source_data, "settings", settings);
+	obs_data_set_double(source_data, "volume",   volume);
 
 	obs_data_release(settings);
 

obs/properties-view.cpp

@@ -103,7 +103,7 @@ QWidget *OBSPropertiesView::AddCheckbox(obs_property_t prop)
 {
 	const char *name = obs_property_name(prop);
 	const char *desc = obs_property_description(prop);
-	bool       val   = obs_data_getbool(settings, name);
+	bool       val   = obs_data_get_bool(settings, name);
 
 	QCheckBox *checkbox = new QCheckBox(QT_UTF8(desc));
 	checkbox->setCheckState(val ? Qt::Checked : Qt::Unchecked);
@@ -113,7 +113,7 @@ QWidget *OBSPropertiesView::AddCheckbox(obs_property_t prop)
 QWidget *OBSPropertiesView::AddText(obs_property_t prop)
 {
 	const char    *name = obs_property_name(prop);
-	const char    *val  = obs_data_getstring(settings, name);
+	const char    *val  = obs_data_get_string(settings, name);
 	obs_text_type type  = obs_proprety_text_type(prop);
 
 	if (type == OBS_TEXT_MULTILINE) {
@@ -135,7 +135,7 @@ void OBSPropertiesView::AddPath(obs_property_t prop, QFormLayout *layout,
 		QLabel **label)
 {
 	const char  *name      = obs_property_name(prop);
-	const char  *val       = obs_data_getstring(settings, name);
+	const char  *val       = obs_data_get_string(settings, name);
 	QLayout     *subLayout = new QHBoxLayout();
 	QLineEdit   *edit      = new QLineEdit();
 	QPushButton *button    = new QPushButton(QTStr("Browse"));
@@ -157,7 +157,7 @@ void OBSPropertiesView::AddPath(obs_property_t prop, QFormLayout *layout,
 QWidget *OBSPropertiesView::AddInt(obs_property_t prop)
 {
 	const char *name = obs_property_name(prop);
-	int        val   = (int)obs_data_getint(settings, name);
+	int        val   = (int)obs_data_get_int(settings, name);
 	QSpinBox   *spin = new QSpinBox();
 
 	spin->setMinimum(obs_property_int_min(prop));
@@ -171,7 +171,7 @@ QWidget *OBSPropertiesView::AddInt(obs_property_t prop)
 QWidget *OBSPropertiesView::AddFloat(obs_property_t prop)
 {
 	const char     *name = obs_property_name(prop);
-	double         val   = obs_data_getdouble(settings, name);
+	double         val   = obs_data_get_double(settings, name);
 	QDoubleSpinBox *spin = new QDoubleSpinBox();
 
 	spin->setMinimum(obs_property_float_min(prop));
@@ -239,8 +239,8 @@ static string from_obs_data(obs_data_t data, const char *name,
 static string from_obs_data(obs_data_t data, const char *name,
 		obs_combo_format format)
 {
-	return from_obs_data<obs_data_getint, obs_data_getdouble,
-	       obs_data_getstring>(data, name, format);
+	return from_obs_data<obs_data_get_int, obs_data_get_double,
+	       obs_data_get_string>(data, name, format);
 }
 
 static string from_obs_data_autoselect(obs_data_t data, const char *name,
@@ -328,7 +328,7 @@ void OBSPropertiesView::AddColor(obs_property_t prop, QFormLayout *layout,
 	QPushButton *button     = new QPushButton;
 	QLabel      *colorLabel = new QLabel;
 	const char  *name       = obs_property_name(prop);
-	long long   val         = obs_data_getint(settings, name);
+	long long   val         = obs_data_get_int(settings, name);
 	QColor      color       = color_from_int(val);
 
 	button->setText(QTStr("Basic.PropertiesWindow.SelectColor"));
@@ -424,20 +424,20 @@ void OBSPropertiesView::AddProperty(obs_property_t property,
 void WidgetInfo::BoolChanged(const char *setting)
 {
 	QCheckBox *checkbox = static_cast<QCheckBox*>(widget);
-	obs_data_setbool(view->settings, setting,
+	obs_data_set_bool(view->settings, setting,
 			checkbox->checkState() == Qt::Checked);
 }
 
 void WidgetInfo::IntChanged(const char *setting)
 {
 	QSpinBox *spin = static_cast<QSpinBox*>(widget);
-	obs_data_setint(view->settings, setting, spin->value());
+	obs_data_set_int(view->settings, setting, spin->value());
 }
 
 void WidgetInfo::FloatChanged(const char *setting)
 {
 	QDoubleSpinBox *spin = static_cast<QDoubleSpinBox*>(widget);
-	obs_data_setdouble(view->settings, setting, spin->value());
+	obs_data_set_double(view->settings, setting, spin->value());
 }
 
 void WidgetInfo::TextChanged(const char *setting)
@@ -446,13 +446,13 @@ void WidgetInfo::TextChanged(const char *setting)
 
 	if (type == OBS_TEXT_MULTILINE) {
 		QPlainTextEdit *edit = static_cast<QPlainTextEdit*>(widget);
-		obs_data_setstring(view->settings, setting,
+		obs_data_set_string(view->settings, setting,
 				QT_TO_UTF8(edit->toPlainText()));
 		return;
 	}
 
 	QLineEdit *edit = static_cast<QLineEdit*>(widget);
-	obs_data_setstring(view->settings, setting, QT_TO_UTF8(edit->text()));
+	obs_data_set_string(view->settings, setting, QT_TO_UTF8(edit->text()));
 }
 
 bool WidgetInfo::PathChanged(const char *setting)
@@ -478,7 +478,7 @@ bool WidgetInfo::PathChanged(const char *setting)
 
 	QLineEdit *edit = static_cast<QLineEdit*>(widget);
 	edit->setText(path);
-	obs_data_setstring(view->settings, setting, QT_TO_UTF8(path));
+	obs_data_set_string(view->settings, setting, QT_TO_UTF8(path));
 	return true;
 }
 
@@ -503,15 +503,15 @@ void WidgetInfo::ListChanged(const char *setting)
 	case OBS_COMBO_FORMAT_INVALID:
 		return;
 	case OBS_COMBO_FORMAT_INT:
-		obs_data_setint(view->settings, setting,
+		obs_data_set_int(view->settings, setting,
 				data.value<long long>());
 		break;
 	case OBS_COMBO_FORMAT_FLOAT:
-		obs_data_setdouble(view->settings, setting,
+		obs_data_set_double(view->settings, setting,
 				data.value<double>());
 		break;
 	case OBS_COMBO_FORMAT_STRING:
-		obs_data_setstring(view->settings, setting,
+		obs_data_set_string(view->settings, setting,
 				QT_TO_UTF8(data.toString()));
 		break;
 	}
@@ -520,7 +520,7 @@ void WidgetInfo::ListChanged(const char *setting)
 bool WidgetInfo::ColorChanged(const char *setting)
 {
 	const char *desc = obs_property_description(property);
-	long long  val   = obs_data_getint(view->settings, setting);
+	long long  val   = obs_data_get_int(view->settings, setting);
 	QColor     color = color_from_int(val);
 
 	QColorDialog::ColorDialogOptions options =
@@ -543,7 +543,7 @@ bool WidgetInfo::ColorChanged(const char *setting)
 	label->setText(color.name(QColor::HexArgb));
 	label->setPalette(QPalette(color));
 
-	obs_data_setint(view->settings, setting, color_to_int(color));
+	obs_data_set_int(view->settings, setting, color_to_int(color));
 
 	return true;
 }

obs/window-basic-main.cpp

@@ -125,7 +125,7 @@ static void SaveAudioDevice(const char *name, int channel, obs_data_t parent)
 
 	obs_data_t data = obs_save_source(source);
 
-	obs_data_setobj(parent, name, data);
+	obs_data_set_obj(parent, name, data);
 
 	obs_data_release(data);
 	obs_source_release(source);
@@ -144,8 +144,8 @@ static obs_data_t GenerateSaveData()
 	SaveAudioDevice(AUX_AUDIO_2,     4, saveData);
 	SaveAudioDevice(AUX_AUDIO_3,     5, saveData);
 
-	obs_data_setstring(saveData, "current_scene", sceneName);
-	obs_data_setarray(saveData, "sources", sourcesArray);
+	obs_data_set_string(saveData, "current_scene", sceneName);
+	obs_data_set_array(saveData, "sources", sourcesArray);
 	obs_data_array_release(sourcesArray);
 	obs_source_release(currentScene);
 
@@ -167,7 +167,7 @@ void OBSBasic::ClearVolumeControls()
 void OBSBasic::Save(const char *file)
 {
 	obs_data_t saveData  = GenerateSaveData();
-	const char *jsonData = obs_data_getjson(saveData);
+	const char *jsonData = obs_data_get_json(saveData);
 
 	/* TODO maybe a message box here? */
 	if (!os_quick_write_utf8_file(file, jsonData, strlen(jsonData), false))
@@ -178,7 +178,7 @@ void OBSBasic::Save(const char *file)
 
 static void LoadAudioDevice(const char *name, int channel, obs_data_t parent)
 {
-	obs_data_t data = obs_data_getobj(parent, name);
+	obs_data_t data = obs_data_get_obj(parent, name);
 	if (!data)
 		return;
 
@@ -227,8 +227,9 @@ void OBSBasic::Load(const char *file)
 	}
 
 	obs_data_t       data       = obs_data_create_from_json(jsonData);
-	obs_data_array_t sources    = obs_data_getarray(data, "sources");
-	const char       *sceneName = obs_data_getstring(data, "current_scene");
+	obs_data_array_t sources    = obs_data_get_array(data, "sources");
+	const char       *sceneName = obs_data_get_string(data,
+			"current_scene");
 	obs_source_t     curScene;
 
 	LoadAudioDevice(DESKTOP_AUDIO_1, 1, data);
@@ -302,10 +303,10 @@ void OBSBasic::SaveService()
 	obs_data_t data     = obs_data_create();
 	obs_data_t settings = obs_service_get_settings(service);
 
-	obs_data_setstring(data, "type", obs_service_gettype(service));
-	obs_data_setobj(data, "settings", settings);
+	obs_data_set_string(data, "type", obs_service_gettype(service));
+	obs_data_set_obj(data, "settings", settings);
 
-	const char *json = obs_data_getjson(data);
+	const char *json = obs_data_get_json(data);
 
 	os_quick_write_utf8_file(serviceJsonPath, json, strlen(json), false);
 
@@ -328,9 +329,9 @@ bool OBSBasic::LoadService()
 	obs_data_t data = obs_data_create_from_json(jsonText);
 
 	obs_data_set_default_string(data, "type", "rtmp_common");
-	type = obs_data_getstring(data, "type");
+	type = obs_data_get_string(data, "type");
 
-	obs_data_t settings = obs_data_getobj(data, "settings");
+	obs_data_t settings = obs_data_get_obj(data, "settings");
 
 	service = obs_service_create(type, "default_service", settings);
 
@@ -915,14 +916,15 @@ void OBSBasic::updateFileFinished()
 		return;
 
 	obs_data_t returnData   = obs_data_create_from_json(jsonReply);
-	obs_data_t versionData  = obs_data_getobj(returnData, VERSION_ENTRY);
-	const char *description = obs_data_getstring(returnData, "description");
-	const char *download    = obs_data_getstring(versionData, "download");
+	obs_data_t versionData  = obs_data_get_obj(returnData, VERSION_ENTRY);
+	const char *description = obs_data_get_string(returnData,
+			"description");
+	const char *download    = obs_data_get_string(versionData, "download");
 
 	if (returnData && versionData && description && download) {
-		long major   = obs_data_getint(versionData, "major");
-		long minor   = obs_data_getint(versionData, "minor");
-		long patch   = obs_data_getint(versionData, "patch");
+		long major   = obs_data_get_int(versionData, "major");
+		long minor   = obs_data_get_int(versionData, "minor");
+		long patch   = obs_data_get_int(versionData, "patch");
 		long version = MAKE_SEMANTIC_VERSION(major, minor, patch);
 
 		blog(LOG_INFO, "Update check: latest version is: %ld.%ld.%ld",
@@ -1298,7 +1300,7 @@ void OBSBasic::ResetAudioDevice(const char *sourceId, const char *deviceName,
 	source = obs_get_output_source(channel);
 	if (source) {
 		settings = obs_source_get_settings(source);
-		const char *curId = obs_data_getstring(settings, "device_id");
+		const char *curId = obs_data_get_string(settings, "device_id");
 
 		same = (strcmp(curId, deviceId) == 0);
 
@@ -1311,7 +1313,7 @@ void OBSBasic::ResetAudioDevice(const char *sourceId, const char *deviceName,
 
 	if (!same && strcmp(deviceId, "disabled") != 0) {
 		obs_data_t settings = obs_data_create();
-		obs_data_setstring(settings, "device_id", deviceId);
+		obs_data_set_string(settings, "device_id", deviceId);
 		source = obs_source_create(OBS_SOURCE_TYPE_INPUT,
 				sourceId, deviceDesc, settings);
 		obs_data_release(settings);
@@ -1809,7 +1811,7 @@ void OBSBasic::logUploadFinished()
 		return;
 
 	obs_data_t returnData = obs_data_create_from_json(jsonReply);
-	QString logURL = obs_data_getstring(returnData, "html_url");
+	QString logURL = obs_data_get_string(returnData, "html_url");
 	obs_data_release(returnData);
 
 	OBSLogReply logDialog(this, logURL);
@@ -1928,11 +1930,11 @@ void OBSBasic::SetupEncoders()
 		int audioBitrate = config_get_uint(basicConfig, "SimpleOutput",
 				"ABitrate");
 
-		obs_data_setint(x264Settings, "bitrate", videoBitrate);
-		obs_data_setint(x264Settings, "buffer_size", videoBitrate);
-		obs_data_setbool(x264Settings, "cbr", true);
+		obs_data_set_int(x264Settings, "bitrate", videoBitrate);
+		obs_data_set_int(x264Settings, "buffer_size", videoBitrate);
+		obs_data_set_bool(x264Settings, "cbr", true);
 
-		obs_data_setint(aacSettings, "bitrate", audioBitrate);
+		obs_data_set_int(aacSettings, "bitrate", audioBitrate);
 
 		obs_encoder_update(x264, x264Settings);
 		obs_encoder_update(aac,  aacSettings);
@@ -2015,7 +2017,7 @@ void OBSBasic::on_recordButton_clicked()
 		obs_output_set_audio_encoder(fileOutput, aac);
 
 		obs_data_t settings = obs_data_create();
-		obs_data_setstring(settings, "path", strPath.c_str());
+		obs_data_set_string(settings, "path", strPath.c_str());
 
 		obs_output_update(fileOutput, settings);
 

plugins/image-source/image-source.c

@@ -20,7 +20,7 @@ static const char *image_source_get_name(void)
 static void image_source_update(void *data, obs_data_t settings)
 {
 	struct image_source *context = data;
-	const char *file = obs_data_getstring(settings, "file");
+	const char *file = obs_data_get_string(settings, "file");
 
 	obs_enter_graphics();
 

plugins/linux-pulseaudio/pulse-input.c

@@ -405,7 +405,7 @@ static void pulse_update(void *vptr, obs_data_t settings)
 	bool restart = false;
 	const char *new_device;
 
-	new_device = obs_data_getstring(settings, "device_id");
+	new_device = obs_data_get_string(settings, "device_id");
 	if (!data->device || strcmp(data->device, new_device) != 0) {
 		if (data->device)
 			bfree(data->device);

plugins/linux-v4l2/v4l2-input.c

@@ -445,7 +445,7 @@ static void v4l2_device_list(obs_property_t prop, obs_data_t settings)
 					(char *) video_cap.card,
 					device.array);
 			if (first) {
-				obs_data_setstring(settings,
+				obs_data_set_string(settings,
 					"device_id", device.array);
 				first = false;
 			}
@@ -603,7 +603,7 @@ static bool device_selected(obs_properties_t props, obs_property_t p,
 		obs_data_t settings)
 {
 	UNUSED_PARAMETER(p);
-	int dev = v4l2_open(obs_data_getstring(settings, "device_id"),
+	int dev = v4l2_open(obs_data_get_string(settings, "device_id"),
 			O_RDWR | O_NONBLOCK);
 	if (dev == -1)
 		return false;
@@ -622,13 +622,13 @@ static bool format_selected(obs_properties_t props, obs_property_t p,
 		obs_data_t settings)
 {
 	UNUSED_PARAMETER(p);
-	int dev = v4l2_open(obs_data_getstring(settings, "device_id"),
+	int dev = v4l2_open(obs_data_get_string(settings, "device_id"),
 			O_RDWR | O_NONBLOCK);
 	if (dev == -1)
 		return false;
 
 	obs_property_t prop = obs_properties_get(props, "resolution");
-	v4l2_resolution_list(dev, obs_data_getint(settings, "pixelformat"),
+	v4l2_resolution_list(dev, obs_data_get_int(settings, "pixelformat"),
 			prop);
 	obs_property_modified(prop, settings);
 	v4l2_close(dev);
@@ -643,15 +643,15 @@ static bool resolution_selected(obs_properties_t props, obs_property_t p,
 {
 	UNUSED_PARAMETER(p);
 	int width, height;
-	int dev = v4l2_open(obs_data_getstring(settings, "device_id"),
+	int dev = v4l2_open(obs_data_get_string(settings, "device_id"),
 			O_RDWR | O_NONBLOCK);
 	if (dev == -1)
 		return false;
 
 	obs_property_t prop = obs_properties_get(props, "framerate");
-	unpack_tuple(&width, &height, obs_data_getint(settings,
+	unpack_tuple(&width, &height, obs_data_get_int(settings,
 				"resolution"));
-	v4l2_framerate_list(dev, obs_data_getint(settings, "pixelformat"),
+	v4l2_framerate_list(dev, obs_data_get_int(settings, "pixelformat"),
 			width, height, prop);
 	obs_property_modified(prop, settings);
 	v4l2_close(dev);
@@ -801,10 +801,10 @@ static void v4l2_update(void *vptr, obs_data_t settings)
 	bool restart = false;
 	const char *new_device;
 
-	new_device = obs_data_getstring(settings, "device_id");
+	new_device = obs_data_get_string(settings, "device_id");
 	if (strlen(new_device) == 0) {
 		v4l2_device_list(NULL, settings);
-		new_device = obs_data_getstring(settings, "device_id");
+		new_device = obs_data_get_string(settings, "device_id");
 	}
 
 	if (!data->set_device || strcmp(data->set_device, new_device) != 0) {
@@ -814,18 +814,18 @@ static void v4l2_update(void *vptr, obs_data_t settings)
 		restart = true;
 	}
 
-	if (data->set_pixfmt != obs_data_getint(settings, "pixelformat")) {
-		data->set_pixfmt = obs_data_getint(settings, "pixelformat");
+	if (data->set_pixfmt != obs_data_get_int(settings, "pixelformat")) {
+		data->set_pixfmt = obs_data_get_int(settings, "pixelformat");
 		restart = true;
 	}
 
-	if (data->set_res != obs_data_getint(settings, "resolution")) {
-		data->set_res = obs_data_getint(settings, "resolution");
+	if (data->set_res != obs_data_get_int(settings, "resolution")) {
+		data->set_res = obs_data_get_int(settings, "resolution");
 		restart = true;
 	}
 
-	if (data->set_fps != obs_data_getint(settings, "framerate")) {
-		data->set_fps = obs_data_getint(settings, "framerate");
+	if (data->set_fps != obs_data_get_int(settings, "framerate")) {
+		data->set_fps = obs_data_get_int(settings, "framerate");
 		restart = true;
 	}
 

plugins/linux-xcomposite/xcompcap-main.cpp

@@ -245,17 +245,17 @@ void XCompcapMain::updateSettings(obs_data_t settings)
 	xcc_cleanup(p);
 
 	if (settings) {
-		const char *windowName = obs_data_getstring(settings,
+		const char *windowName = obs_data_get_string(settings,
 				"capture_window");
 
 		p->win = getWindowFromString(windowName);
 
-		p->cut_top = obs_data_getint(settings, "cut_top");
-		p->cut_left = obs_data_getint(settings, "cut_left");
-		p->cut_right = obs_data_getint(settings, "cut_right");
-		p->cut_bot = obs_data_getint(settings, "cut_bot");
-		p->lockX = obs_data_getbool(settings, "lock_x");
-		p->swapRedBlue = obs_data_getbool(settings, "swap_redblue");
+		p->cut_top = obs_data_get_int(settings, "cut_top");
+		p->cut_left = obs_data_get_int(settings, "cut_left");
+		p->cut_right = obs_data_get_int(settings, "cut_right");
+		p->cut_bot = obs_data_get_int(settings, "cut_bot");
+		p->lockX = obs_data_get_bool(settings, "lock_x");
+		p->swapRedBlue = obs_data_get_bool(settings, "swap_redblue");
 	} else {
 		p->win = prevWin;
 	}

plugins/linux-xshm/xshm-input.c

@@ -70,7 +70,7 @@ static int_fast32_t xshm_update_geometry(struct xshm_data *data,
 {
 	int_fast32_t old_width = data->width;
 	int_fast32_t old_height = data->height;
-	int_fast32_t screen = obs_data_getint(settings, "screen");
+	int_fast32_t screen = obs_data_get_int(settings, "screen");
 
 	if (data->use_xinerama) {
 		if (xinerama_screen_geo(data->dpy, screen,
@@ -120,7 +120,7 @@ static void xshm_update(void *vptr, obs_data_t settings)
 {
 	XSHM_DATA(vptr);
 
-	data->show_cursor = obs_data_getbool(settings, "show_cursor");
+	data->show_cursor = obs_data_get_bool(settings, "show_cursor");
 
 	if (data->xshm)
 		xshm_detach(data->xshm);

plugins/mac-avcapture/av-capture.m

@@ -283,7 +283,7 @@ static void av_capture_destroy(void *data)
 
 static NSString *get_string(obs_data_t data, char const *name)
 {
-	return @(obs_data_getstring(data, name));
+	return @(obs_data_get_string(data, name));
 }
 
 static bool init_session(struct av_capture *capture)
@@ -410,12 +410,12 @@ static void capture_device(struct av_capture *capture, AVCaptureDevice *dev,
 	capture->device = dev;
 
 	const char *name = capture->device.localizedName.UTF8String;
-	obs_data_setstring(settings, "device_name", name);
-	obs_data_setstring(settings, "device",
+	obs_data_set_string(settings, "device_name", name);
+	obs_data_set_string(settings, "device",
 			capture->device.uniqueID.UTF8String);
 	AVLOG(LOG_INFO, "Selected device '%s'", name);
 
-	if (obs_data_getbool(settings, "use_preset")) {
+	if (obs_data_get_bool(settings, "use_preset")) {
 		NSString *preset = get_string(settings, "preset");
 		if (![dev supportsAVCaptureSessionPreset:preset]) {
 			AVLOG(LOG_ERROR, "Preset %s not available",

plugins/mac-capture/mac-audio.c

@@ -682,7 +682,7 @@ static void *coreaudio_create(obs_data_t settings, obs_source_t source,
 		return NULL;
 	}
 
-	ca->device_uid = bstrdup(obs_data_getstring(settings, "device_id"));
+	ca->device_uid = bstrdup(obs_data_get_string(settings, "device_id"));
 	ca->source     = source;
 	ca->input      = input;
 

plugins/mac-capture/mac-display-capture.m

@@ -190,7 +190,7 @@ static void *display_capture_create(obs_data_t settings,
 
 	obs_leave_graphics();
 
-	dc->display = obs_data_getint(settings, "display");
+	dc->display = obs_data_get_int(settings, "display");
 	pthread_mutex_init(&dc->mutex, NULL);
 
 	if (!init_display_stream(dc))
@@ -284,8 +284,8 @@ static void display_capture_defaults(obs_data_t settings)
 static void display_capture_update(void *data, obs_data_t settings)
 {
 	struct display_capture *dc = data;
-	unsigned display = obs_data_getint(settings, "display");
-	bool show_cursor = obs_data_getbool(settings, "show_cursor");
+	unsigned display = obs_data_get_int(settings, "display");
+	bool show_cursor = obs_data_get_bool(settings, "show_cursor");
 	if (dc->display == display && dc->hide_cursor != show_cursor)
 		return;
 

plugins/obs-ffmpeg/obs-ffmpeg-aac.c

@@ -124,7 +124,7 @@ static void init_sizes(struct aac_encoder *enc, audio_t audio)
 static void *aac_create(obs_data_t settings, obs_encoder_t encoder)
 {
 	struct aac_encoder *enc;
-	int                bitrate = (int)obs_data_getint(settings, "bitrate");
+	int                bitrate = (int)obs_data_get_int(settings, "bitrate");
 	audio_t            audio   = obs_encoder_audio(encoder);
 
 	if (!bitrate) {

plugins/obs-ffmpeg/obs-ffmpeg-output.c

@@ -714,9 +714,9 @@ static bool try_connect(struct ffmpeg_output *output)
 	int ret;
 
 	settings = obs_output_get_settings(output->output);
-	filename_test = obs_data_getstring(settings, "filename");
-	video_bitrate = (int)obs_data_getint(settings, "video_bitrate");
-	audio_bitrate = (int)obs_data_getint(settings, "audio_bitrate");
+	filename_test = obs_data_get_string(settings, "filename");
+	video_bitrate = (int)obs_data_get_int(settings, "video_bitrate");
+	audio_bitrate = (int)obs_data_get_int(settings, "audio_bitrate");
 	obs_data_release(settings);
 
 	if (!filename_test || !*filename_test)

plugins/obs-libfdk/obs-libfdk.c

@@ -92,8 +92,8 @@ static void *libfdk_create(obs_data_t settings, obs_encoder_t encoder)
 {
 	bool hasFdkHandle = false;
 	libfdk_encoder_t *enc = 0;
-	int bitrate = (int)obs_data_getint(settings, "bitrate") * 1000;
-	int afterburner = obs_data_getbool(settings, "afterburner") ? 1 : 0;
+	int bitrate = (int)obs_data_get_int(settings, "bitrate") * 1000;
+	int afterburner = obs_data_get_bool(settings, "afterburner") ? 1 : 0;
 	audio_t audio = obs_encoder_audio(encoder);
 	int mode = 0;
 	AACENC_ERROR err;

plugins/obs-outputs/flv-mux.c

@@ -34,7 +34,7 @@
 static inline double encoder_bitrate(obs_encoder_t encoder)
 {
 	obs_data_t settings = obs_encoder_get_settings(encoder);
-	double bitrate = obs_data_getdouble(settings, "bitrate");
+	double bitrate = obs_data_get_double(settings, "bitrate");
 
 	obs_data_release(settings);
 	return bitrate;

plugins/obs-outputs/flv-output.c

@@ -155,7 +155,7 @@ static bool flv_output_start(void *data)
 
 	/* get path */
 	settings = obs_output_get_settings(stream->output);
-	path = obs_data_getstring(settings, "path");
+	path = obs_data_get_string(settings, "path");
 	dstr_copy(&stream->path, path);
 	obs_data_release(settings);
 

plugins/obs-outputs/rtmp-stream.c

@@ -434,7 +434,7 @@ static bool rtmp_stream_start(void *data)
 	dstr_copy(&stream->username, obs_service_get_username(service));
 	dstr_copy(&stream->password, obs_service_get_password(service));
 	stream->drop_threshold_usec =
-		(int64_t)obs_data_getint(settings, OPT_DROP_THRESHOLD) * 1000;
+		(int64_t)obs_data_get_int(settings, OPT_DROP_THRESHOLD) * 1000;
 	obs_data_release(settings);
 
 	return pthread_create(&stream->connect_thread, NULL, connect_thread,

plugins/obs-x264/obs-x264.c

@@ -237,11 +237,11 @@ static void update_params(struct obs_x264 *obsx264, obs_data_t settings,
 	video_t video = obs_encoder_video(obsx264->encoder);
 	const struct video_output_info *voi = video_output_getinfo(video);
 
-	int bitrate      = (int)obs_data_getint(settings, "bitrate");
-	int buffer_size  = (int)obs_data_getint(settings, "buffer_size");
-	int keyint_sec   = (int)obs_data_getint(settings, "keyint_sec");
-	int crf          = (int)obs_data_getint(settings, "crf");
-	bool cbr         = obs_data_getbool(settings, "cbr");
+	int bitrate      = (int)obs_data_get_int(settings, "bitrate");
+	int buffer_size  = (int)obs_data_get_int(settings, "buffer_size");
+	int keyint_sec   = (int)obs_data_get_int(settings, "keyint_sec");
+	int crf          = (int)obs_data_get_int(settings, "crf");
+	bool cbr         = obs_data_get_bool(settings, "cbr");
 
 	if (keyint_sec)
 		obsx264->params.i_keyint_max =
@@ -299,10 +299,10 @@ static void update_params(struct obs_x264 *obsx264, obs_data_t settings,
 
 static bool update_settings(struct obs_x264 *obsx264, obs_data_t settings)
 {
-	char *preset     = bstrdup(obs_data_getstring(settings, "preset"));
-	char *profile    = bstrdup(obs_data_getstring(settings, "profile"));
-	char *tune       = bstrdup(obs_data_getstring(settings, "tune"));
-	const char *opts = obs_data_getstring(settings, "x264opts");
+	char *preset     = bstrdup(obs_data_get_string(settings, "preset"));
+	char *profile    = bstrdup(obs_data_get_string(settings, "profile"));
+	char *tune       = bstrdup(obs_data_get_string(settings, "tune"));
+	const char *opts = obs_data_get_string(settings, "x264opts");
 
 	char **paramlist;
 	bool success = true;

plugins/rtmp-services/rtmp-common.c

@@ -21,9 +21,9 @@ static void rtmp_common_update(void *data, obs_data_t settings)
 	bfree(service->server);
 	bfree(service->key);
 
-	service->service = bstrdup(obs_data_getstring(settings, "service"));
-	service->server  = bstrdup(obs_data_getstring(settings, "server"));
-	service->key     = bstrdup(obs_data_getstring(settings, "key"));
+	service->service = bstrdup(obs_data_get_string(settings, "service"));
+	service->server  = bstrdup(obs_data_get_string(settings, "server"));
+	service->key     = bstrdup(obs_data_get_string(settings, "key"));
 }
 
 static void rtmp_common_destroy(void *data)
@@ -180,7 +180,7 @@ static inline json_t *find_service(json_t *root, const char *name)
 static bool service_selected(obs_properties_t props, obs_property_t p,
 		obs_data_t settings)
 {
-	const char *name = obs_data_getstring(settings, "service");
+	const char *name = obs_data_get_string(settings, "service");
 	json_t *root     = obs_properties_get_param(props);
 	json_t *service;
 
@@ -231,27 +231,27 @@ static void apply_video_encoder_settings(obs_encoder_t encoder,
 	json_t *item = json_object_get(recommended, "keyint");
 	if (item && json_is_integer(item)) {
 		int keyint = (int)json_integer_value(item);
-		obs_data_setint(settings, "keyint_sec", keyint);
+		obs_data_set_int(settings, "keyint_sec", keyint);
 	}
 
 	item = json_object_get(recommended, "cbr");
 	if (item && json_is_boolean(item)) {
 		bool cbr = json_is_true(item);
-		obs_data_setbool(settings, "cbr", cbr);
+		obs_data_set_bool(settings, "cbr", cbr);
 	}
 
 	item = json_object_get(recommended, "profile");
 	if (item && json_is_string(item)) {
 		const char *profile = json_string_value(item);
-		obs_data_setbool(settings, "profile", profile);
+		obs_data_set_bool(settings, "profile", profile);
 	}
 
 	item = json_object_get(recommended, "max video bitrate");
 	if (item && json_is_integer(item)) {
 		int max_bitrate = (int)json_integer_value(item);
-		if (obs_data_getint(settings, "bitrate") > max_bitrate) {
-			obs_data_setint(settings, "bitrate", max_bitrate);
-			obs_data_setint(settings, "buffer_size", max_bitrate);
+		if (obs_data_get_int(settings, "bitrate") > max_bitrate) {
+			obs_data_set_int(settings, "bitrate", max_bitrate);
+			obs_data_set_int(settings, "buffer_size", max_bitrate);
 		}
 	}
 
@@ -267,8 +267,8 @@ static void apply_audio_encoder_settings(obs_encoder_t encoder,
 	json_t *item = json_object_get(recommended, "max audio bitrate");
 	if (item && json_is_integer(item)) {
 		int max_bitrate = (int)json_integer_value(item);
-		if (obs_data_getint(settings, "bitrate") > max_bitrate)
-			obs_data_setint(settings, "bitrate", max_bitrate);
+		if (obs_data_get_int(settings, "bitrate") > max_bitrate)
+			obs_data_set_int(settings, "bitrate", max_bitrate);
 	}
 
 	obs_encoder_update(encoder, settings);

plugins/rtmp-services/rtmp-custom.c

@@ -16,8 +16,8 @@ static void rtmp_custom_update(void *data, obs_data_t settings)
 	bfree(service->server);
 	bfree(service->key);
 
-	service->server = bstrdup(obs_data_getstring(settings, "server"));
-	service->key    = bstrdup(obs_data_getstring(settings, "key"));
+	service->server = bstrdup(obs_data_get_string(settings, "server"));
+	service->key    = bstrdup(obs_data_get_string(settings, "key"));
 }
 
 static void rtmp_custom_destroy(void *data)

plugins/win-capture/monitor-capture.c

@@ -58,7 +58,7 @@ static void update_monitor(struct monitor_capture *capture,
 	struct monitor_info monitor = {0};
 	uint32_t width, height;
 
-	monitor.desired_id = (int)obs_data_getint(settings, "monitor");
+	monitor.desired_id = (int)obs_data_get_int(settings, "monitor");
 	EnumDisplayMonitors(NULL, NULL, enum_monitor, (LPARAM)&monitor);
 
 	capture->monitor = monitor.id;
@@ -74,8 +74,8 @@ static void update_monitor(struct monitor_capture *capture,
 static inline void update_settings(struct monitor_capture *capture,
 		obs_data_t settings)
 {
-	capture->capture_cursor = obs_data_getbool(settings, "capture_cursor");
-	capture->compatibility  = obs_data_getbool(settings, "compatibility");
+	capture->capture_cursor = obs_data_get_bool(settings, "capture_cursor");
+	capture->compatibility  = obs_data_get_bool(settings, "compatibility");
 
 	dc_capture_free(&capture->data);
 	update_monitor(capture, settings);

plugins/win-capture/window-capture.c

@@ -56,8 +56,8 @@ char *decode_str(const char *src)
 
 static void update_settings(struct window_capture *wc, obs_data_t s)
 {
-	const char *window     = obs_data_getstring(s, "window");
-	int        priority    = (int)obs_data_getint(s, "priority");
+	const char *window     = obs_data_get_string(s, "window");
+	int        priority    = (int)obs_data_get_int(s, "priority");
 
 	bfree(wc->title);
 	bfree(wc->class);
@@ -79,8 +79,8 @@ static void update_settings(struct window_capture *wc, obs_data_t s)
 	}
 
 	wc->priority      = (enum window_priority)priority;
-	wc->cursor        = obs_data_getbool(s, "cursor");
-	wc->use_wildcards = obs_data_getbool(s, "use_wildcards");
+	wc->cursor        = obs_data_get_bool(s, "cursor");
+	wc->use_wildcards = obs_data_get_bool(s, "use_wildcards");
 }
 
 static bool get_exe_name(struct dstr *name, HWND window)

plugins/win-dshow/win-dshow.cpp

@@ -353,11 +353,11 @@ static bool DetermineResolution(int &cx, int &cy, obs_data_t settings,
 			ResolutionAvailable(dev, cx, cy))
 		return true;
 
-	res = obs_data_getstring(settings, RESOLUTION);
+	res = obs_data_get_string(settings, RESOLUTION);
 	if (ConvertRes(cx, cy, res) && ResolutionAvailable(dev, cx, cy))
 		return true;
 
-	res = obs_data_getstring(settings, LAST_RESOLUTION);
+	res = obs_data_get_string(settings, LAST_RESOLUTION);
 	if (ConvertRes(cx, cy, res) && ResolutionAvailable(dev, cx, cy))
 		return true;
 
@@ -368,7 +368,7 @@ static long long GetOBSFPS();
 
 void DShowInput::Update(obs_data_t settings)
 {
-	string video_device_id = obs_data_getstring(settings, VIDEO_DEVICE_ID);
+	string video_device_id = obs_data_get_string(settings, VIDEO_DEVICE_ID);
 
 	if (!comInitialized) {
 		CoInitialize(nullptr);
@@ -388,24 +388,24 @@ void DShowInput::Update(obs_data_t settings)
 	if (!data.GetDevice(dev, video_device_id.c_str()))
 		return;
 
-	int resType = (int)obs_data_getint(settings, RES_TYPE);
+	int resType = (int)obs_data_get_int(settings, RES_TYPE);
 	int cx = 0, cy = 0;
 	long long interval = 0;
 	VideoFormat format = VideoFormat::Any;
 
 	if (resType == ResType_Custom) {
-		string resolution = obs_data_getstring(settings, RESOLUTION);
+		string resolution = obs_data_get_string(settings, RESOLUTION);
 		if (!ResolutionValid(resolution, cx, cy))
 			return;
 
 		interval = obs_data_has_autoselect(settings, FRAME_INTERVAL) ?
 			obs_data_get_autoselect_int(settings, FRAME_INTERVAL) :
-			obs_data_getint(settings, FRAME_INTERVAL);
+			obs_data_get_int(settings, FRAME_INTERVAL);
 
 		if (interval == FPS_MATCHING)
 			interval = GetOBSFPS();
 
-		format = (VideoFormat)obs_data_getint(settings, VIDEO_FORMAT);
+		format = (VideoFormat)obs_data_get_int(settings, VIDEO_FORMAT);
 
 		long long best_interval = numeric_limits<long long>::max();
 		bool video_format_match = false;
@@ -606,7 +606,7 @@ static bool SetResolution(obs_properties_t props, obs_data_t settings,
 			settings);
 
 	if (!autoselect)
-		obs_data_setstring(settings, LAST_RESOLUTION, res.c_str());
+		obs_data_set_string(settings, LAST_RESOLUTION, res.c_str());
 	return true;
 }
 
@@ -619,9 +619,9 @@ static bool DeviceResolutionChanged(obs_properties_t props, obs_property_t p,
 	const char *id;
 	VideoDevice device;
 
-	id       = obs_data_getstring(settings, VIDEO_DEVICE_ID);
-	string res = obs_data_getstring(settings, RESOLUTION);
-	string last_res = obs_data_getstring(settings, LAST_RESOLUTION);
+	id       = obs_data_get_string(settings, VIDEO_DEVICE_ID);
+	string res = obs_data_get_string(settings, RESOLUTION);
+	string last_res = obs_data_get_string(settings, LAST_RESOLUTION);
 
 	if (!data->GetDevice(device, id))
 		return false;
@@ -717,8 +717,8 @@ static bool DeviceSelectionChanged(obs_properties_t props, obs_property_t p,
 	PropertiesData *data = (PropertiesData*)obs_properties_get_param(props);
 	VideoDevice device;
 
-	string id     = obs_data_getstring(settings, VIDEO_DEVICE_ID);
-	string old_id = obs_data_getstring(settings, LAST_VIDEO_DEV_ID);
+	string id     = obs_data_get_string(settings, VIDEO_DEVICE_ID);
+	string old_id = obs_data_get_string(settings, LAST_VIDEO_DEV_ID);
 
 	bool device_list_updated = UpdateDeviceList(p, id);
 
@@ -747,7 +747,7 @@ static bool DeviceSelectionChanged(obs_properties_t props, obs_property_t p,
 	if (!id.size() || !old_id.size() || id != old_id) {
 		p = obs_properties_get(props, RES_TYPE);
 		ResTypeChanged(props, p, settings);
-		obs_data_setstring(settings, LAST_VIDEO_DEV_ID, id.c_str());
+		obs_data_set_string(settings, LAST_VIDEO_DEV_ID, id.c_str());
 	}
 
 	return true;
@@ -824,7 +824,7 @@ static void PropertiesDataDestroy(void *data)
 static bool ResTypeChanged(obs_properties_t props, obs_property_t p,
 		obs_data_t settings)
 {
-	int  val     = (int)obs_data_getint(settings, RES_TYPE);
+	int  val     = (int)obs_data_get_int(settings, RES_TYPE);
 	bool enabled = (val != ResType_Preferred);
 
 	p = obs_properties_get(props, RESOLUTION);
@@ -1002,10 +1002,10 @@ static bool UpdateFPS(long long interval, obs_property_t list)
 static bool DeviceIntervalChanged(obs_properties_t props, obs_property_t p,
 		obs_data_t settings)
 {
-	long long val = obs_data_getint(settings, FRAME_INTERVAL);
+	long long val = obs_data_get_int(settings, FRAME_INTERVAL);
 
 	PropertiesData *data = (PropertiesData*)obs_properties_get_param(props);
-	const char *id = obs_data_getstring(settings, VIDEO_DEVICE_ID);
+	const char *id = obs_data_get_string(settings, VIDEO_DEVICE_ID);
 	VideoDevice device;
 
 	if (!data->GetDevice(device, id))
@@ -1018,14 +1018,14 @@ static bool DeviceIntervalChanged(obs_properties_t props, obs_property_t p,
 		return true;
 	}
 
-	int resType = (int)obs_data_getint(settings, RES_TYPE);
+	int resType = (int)obs_data_get_int(settings, RES_TYPE);
 	if (resType != ResType_Custom)
 		return true;
 
 	if (val == FPS_MATCHING)
 		val = GetOBSFPS();
 
-	VideoFormat format = (VideoFormat)obs_data_getint(settings,
+	VideoFormat format = (VideoFormat)obs_data_get_int(settings,
 							VIDEO_FORMAT);
 
 	bool video_format_matches = false;
@@ -1094,11 +1094,11 @@ static bool VideoFormatChanged(obs_properties_t props, obs_property_t p,
 		obs_data_t settings)
 {
 	PropertiesData *data = (PropertiesData*)obs_properties_get_param(props);
-	const char *id = obs_data_getstring(settings, VIDEO_DEVICE_ID);
+	const char *id = obs_data_get_string(settings, VIDEO_DEVICE_ID);
 	VideoDevice device;
 
 	VideoFormat curFormat =
-		(VideoFormat)obs_data_getint(settings, VIDEO_FORMAT);
+		(VideoFormat)obs_data_get_int(settings, VIDEO_FORMAT);
 
 	if (!data->GetDevice(device, id))
 		return UpdateVideoFormats(curFormat, p);
@@ -1110,7 +1110,7 @@ static bool VideoFormatChanged(obs_properties_t props, obs_property_t p,
 		return true;
 	}
 
-	long long interval = obs_data_getint(settings, FRAME_INTERVAL);
+	long long interval = obs_data_get_int(settings, FRAME_INTERVAL);
 
 	UpdateVideoFormats(device, curFormat, cx, cy, interval, props);
 	UpdateFPS(device, curFormat, interval, cx, cy, props);

plugins/win-wasapi/win-wasapi.cpp

@@ -124,14 +124,14 @@ inline WASAPISource::~WASAPISource()
 
 void WASAPISource::UpdateSettings(obs_data_t settings)
 {
-	device_id       = obs_data_getstring(settings, OPT_DEVICE_ID);
-	useDeviceTiming = obs_data_getbool(settings, OPT_USE_DEVICE_TIMING);
+	device_id       = obs_data_get_string(settings, OPT_DEVICE_ID);
+	useDeviceTiming = obs_data_get_bool(settings, OPT_USE_DEVICE_TIMING);
 	isDefaultDevice = _strcmpi(device_id.c_str(), "default") == 0;
 }
 
 void WASAPISource::Update(obs_data_t settings)
 {
-	string newDevice = obs_data_getstring(settings, OPT_DEVICE_ID);
+	string newDevice = obs_data_get_string(settings, OPT_DEVICE_ID);
 	bool restart = newDevice.compare(device_id) != 0;
 
 	if (restart)