libobs: Use calldata with stack for simple signals

Makes signals use stack memory rather than allocate memory each time.
Most likely a completely insignificant and pointless optimization.

libobs/obs-internal.h

@@ -660,15 +660,15 @@ static inline void obs_source_dosignal(struct obs_source *source,
 		const char *signal_obs, const char *signal_source)
 {
 	struct calldata data;
+	uint8_t stack[128];
 
-	calldata_init(&data);
+	calldata_init_fixed(&data, stack, sizeof(stack));
 	calldata_set_ptr(&data, "source", source);
 	if (signal_obs && !source->context.private)
 		signal_handler_signal(obs->signals, signal_obs, &data);
 	if (signal_source)
 		signal_handler_signal(source->context.signals, signal_source,
 				&data);
-	calldata_free(&data);
 }
 
 extern void obs_source_activate(obs_source_t *source, enum view_type type);

libobs/obs-output-delay.c

@@ -113,11 +113,13 @@ void process_delay(void *data, struct encoder_packet *packet)
 
 void obs_output_signal_delay(obs_output_t *output, const char *signal)
 {
-	struct calldata params = {0};
+	struct calldata params;
+	uint8_t stack[128];
+
+	calldata_init_fixed(&params, stack, sizeof(stack));
 	calldata_set_ptr(&params, "output", output);
 	calldata_set_int(&params, "sec", output->active_delay_ns / 1000000000);
 	signal_handler_signal(output->context.signals, signal, &params);
-	calldata_free(&params);
 }
 
 bool obs_output_delay_start(obs_output_t *output)

libobs/obs-output.c

@@ -1274,12 +1274,14 @@ static inline void signal_start(struct obs_output *output)
 
 static inline void signal_reconnect(struct obs_output *output)
 {
-	struct calldata params = {0};
+	struct calldata params;
+	uint8_t stack[128];
+
+	calldata_init_fixed(&params, stack, sizeof(stack));
 	calldata_set_int(&params, "timeout_sec",
 			output->reconnect_retry_cur_sec);
 	calldata_set_ptr(&params, "output", output);
 	signal_handler_signal(output->context.signals, "reconnect", &params);
-	calldata_free(&params);
 }
 
 static inline void signal_reconnect_success(struct obs_output *output)
@@ -1289,11 +1291,13 @@ static inline void signal_reconnect_success(struct obs_output *output)
 
 static inline void signal_stop(struct obs_output *output, int code)
 {
-	struct calldata params = {0};
+	struct calldata params;
+	uint8_t stack[128];
+
+	calldata_init_fixed(&params, stack, sizeof(stack));
 	calldata_set_int(&params, "code", code);
 	calldata_set_ptr(&params, "output", output);
 	signal_handler_signal(output->context.signals, "stop", &params);
-	calldata_free(&params);
 }
 
 static inline void convert_flags(const struct obs_output *output,

libobs/obs-scene.c

@@ -44,13 +44,15 @@ static const char *obs_scene_signals[] = {
 
 static inline void signal_item_remove(struct obs_scene_item *item)
 {
-	struct calldata params = {0};
+	struct calldata params;
+	uint8_t stack[128];
+
+	calldata_init_fixed(&params, stack, sizeof(stack));
 	calldata_set_ptr(&params, "scene", item->parent);
 	calldata_set_ptr(&params, "item", item);
 
 	signal_handler_signal(item->parent->source->context.signals,
 			"item_remove", &params);
-	calldata_free(&params);
 }
 
 static const char *scene_getname(void *unused)
@@ -288,7 +290,8 @@ static void update_item_transform(struct obs_scene_item *item)
 	struct vec2     base_origin;
 	struct vec2     origin;
 	struct vec2     scale         = item->scale;
-	struct calldata params        = {0};
+	struct calldata params;
+	uint8_t         stack[128];
 
 	vec2_zero(&base_origin);
 	vec2_zero(&origin);
@@ -340,11 +343,11 @@ static void update_item_transform(struct obs_scene_item *item)
 	item->last_width  = width;
 	item->last_height = height;
 
+	calldata_init_fixed(&params, stack, sizeof(stack));
 	calldata_set_ptr(&params, "scene", item->parent);
 	calldata_set_ptr(&params, "item", item);
 	signal_handler_signal(item->parent->source->context.signals,
 			"item_transform", &params);
-	calldata_free(&params);
 }
 
 static inline bool source_size_changed(struct obs_scene_item *item)
@@ -1039,7 +1042,8 @@ obs_sceneitem_t *obs_scene_add(obs_scene_t *scene, obs_source_t *source)
 {
 	struct obs_scene_item *last;
 	struct obs_scene_item *item;
-	struct calldata params = {0};
+	struct calldata params;
+	uint8_t stack[128];
 	pthread_mutex_t mutex;
 
 	struct item_action action = {
@@ -1106,11 +1110,11 @@ obs_sceneitem_t *obs_scene_add(obs_scene_t *scene, obs_source_t *source)
 	if (!scene->source->context.private)
 		init_hotkeys(scene, item, obs_source_get_name(source));
 
+	calldata_init_fixed(&params, stack, sizeof(stack));
 	calldata_set_ptr(&params, "scene", scene);
 	calldata_set_ptr(&params, "item", item);
 	signal_handler_signal(scene->source->context.signals, "item_add",
 			&params);
-	calldata_free(&params);
 
 	return item;
 }
@@ -1187,7 +1191,8 @@ obs_source_t *obs_sceneitem_get_source(const obs_sceneitem_t *item)
 
 void obs_sceneitem_select(obs_sceneitem_t *item, bool select)
 {
-	struct calldata params = {0};
+	struct calldata params;
+	uint8_t stack[128];
 	const char *command = select ? "item_select" : "item_deselect";
 
 	if (!item || item->selected == select)
@@ -1195,12 +1200,11 @@ void obs_sceneitem_select(obs_sceneitem_t *item, bool select)
 
 	item->selected = select;
 
+	calldata_init_fixed(&params, stack, sizeof(stack));
 	calldata_set_ptr(&params, "scene", item->parent);
 	calldata_set_ptr(&params, "item",  item);
 	signal_handler_signal(item->parent->source->context.signals,
 			command, &params);
-
-	calldata_free(&params);
 }
 
 bool obs_sceneitem_selected(const obs_sceneitem_t *item)
@@ -1243,16 +1247,16 @@ void obs_sceneitem_set_alignment(obs_sceneitem_t *item, uint32_t alignment)
 static inline void signal_reorder(struct obs_scene_item *item)
 {
 	const char *command = NULL;
-	struct calldata params = {0};
+	struct calldata params;
+	uint8_t stack[128];
 
 	command = "reorder";
 
+	calldata_init_fixed(&params, stack, sizeof(stack));
 	calldata_set_ptr(&params, "scene", item->parent);
 
 	signal_handler_signal(item->parent->source->context.signals,
 			command, &params);
-
-	calldata_free(&params);
 }
 
 void obs_sceneitem_set_order(obs_sceneitem_t *item,
@@ -1444,7 +1448,8 @@ bool obs_sceneitem_visible(const obs_sceneitem_t *item)
 
 bool obs_sceneitem_set_visible(obs_sceneitem_t *item, bool visible)
 {
-	struct calldata cd = {0};
+	struct calldata cd;
+	uint8_t stack[256];
 	struct item_action action = {
 		.visible = visible,
 		.timestamp = os_gettime_ns()
@@ -1471,13 +1476,13 @@ bool obs_sceneitem_set_visible(obs_sceneitem_t *item, bool visible)
 
 	item->user_visible = visible;
 
+	calldata_init_fixed(&cd, stack, sizeof(stack));
 	calldata_set_ptr(&cd, "scene", item->parent);
 	calldata_set_ptr(&cd, "item", item);
 	calldata_set_bool(&cd, "visible", visible);
 
 	signal_handler_signal(item->parent->source->context.signals,
 			"item_visible", &cd);
-	calldata_free(&cd);
 
 	if (source_has_audio(item->source)) {
 		pthread_mutex_lock(&item->actions_mutex);

libobs/obs-source.c

@@ -714,18 +714,10 @@ void obs_source_update(obs_source_t *source, obs_data_t *settings)
 
 void obs_source_update_properties(obs_source_t *source)
 {
-	calldata_t calldata;
-
 	if (!obs_source_valid(source, "obs_source_update_properties"))
 		return;
 
-	calldata_init(&calldata);
-	calldata_set_ptr(&calldata, "source", source);
-
-	signal_handler_signal(obs_source_get_signal_handler(source),
-			"update_properties", &calldata);
-
-	calldata_free(&calldata);
+	obs_source_dosignal(source, NULL, "update_properties");
 }
 
 void obs_source_send_mouse_click(obs_source_t *source,
@@ -1805,7 +1797,8 @@ obs_source_t *obs_filter_get_target(const obs_source_t *filter)
 
 void obs_source_filter_add(obs_source_t *source, obs_source_t *filter)
 {
-	struct calldata cd = {0};
+	struct calldata cd;
+	uint8_t stack[128];
 
 	if (!obs_source_valid(source, "obs_source_filter_add"))
 		return;
@@ -1831,18 +1824,18 @@ void obs_source_filter_add(obs_source_t *source, obs_source_t *filter)
 
 	pthread_mutex_unlock(&source->filter_mutex);
 
+	calldata_init_fixed(&cd, stack, sizeof(stack));
 	calldata_set_ptr(&cd, "source", source);
 	calldata_set_ptr(&cd, "filter", filter);
 
 	signal_handler_signal(source->context.signals, "filter_add", &cd);
-
-	calldata_free(&cd);
 }
 
 static bool obs_source_filter_remove_refless(obs_source_t *source,
 		obs_source_t *filter)
 {
-	struct calldata cd = {0};
+	struct calldata cd;
+	uint8_t stack[128];
 	size_t idx;
 
 	pthread_mutex_lock(&source->filter_mutex);
@@ -1862,13 +1855,12 @@ static bool obs_source_filter_remove_refless(obs_source_t *source,
 
 	pthread_mutex_unlock(&source->filter_mutex);
 
+	calldata_init_fixed(&cd, stack, sizeof(stack));
 	calldata_set_ptr(&cd, "source", source);
 	calldata_set_ptr(&cd, "filter", filter);
 
 	signal_handler_signal(source->context.signals, "filter_remove", &cd);
 
-	calldata_free(&cd);
-
 	if (filter->info.filter_remove)
 		filter->info.filter_remove(filter->context.data,
 				filter->filter_parent);
@@ -2788,7 +2780,10 @@ void obs_source_set_volume(obs_source_t *source, float volume)
 			.vol       = volume
 		};
 
-		struct calldata data = {0};
+		struct calldata data;
+		uint8_t stack[128];
+
+		calldata_init_fixed(&data, stack, sizeof(stack));
 		calldata_set_ptr(&data, "source", source);
 		calldata_set_float(&data, "volume", volume);
 
@@ -2798,7 +2793,6 @@ void obs_source_set_volume(obs_source_t *source, float volume)
 					&data);
 
 		volume = (float)calldata_float(&data, "volume");
-		calldata_free(&data);
 
 		pthread_mutex_lock(&source->audio_actions_mutex);
 		da_push_back(source->audio_actions, &action);
@@ -2817,8 +2811,10 @@ float obs_source_get_volume(const obs_source_t *source)
 void obs_source_set_sync_offset(obs_source_t *source, int64_t offset)
 {
 	if (obs_source_valid(source, "obs_source_set_sync_offset")) {
-		struct calldata data = {0};
+		struct calldata data;
+		uint8_t stack[128];
 
+		calldata_init_fixed(&data, stack, sizeof(stack));
 		calldata_set_ptr(&data, "source", source);
 		calldata_set_int(&data, "offset", offset);
 
@@ -2826,7 +2822,6 @@ void obs_source_set_sync_offset(obs_source_t *source, int64_t offset)
 				&data);
 
 		source->sync_offset = calldata_int(&data, "offset");
-		calldata_free(&data);
 	}
 }
 
@@ -2996,14 +2991,14 @@ bool obs_source_showing(const obs_source_t *source)
 
 static inline void signal_flags_updated(obs_source_t *source)
 {
-	struct calldata data = {0};
+	struct calldata data;
+	uint8_t stack[128];
 
+	calldata_init_fixed(&data, stack, sizeof(stack));
 	calldata_set_ptr(&data, "source", source);
 	calldata_set_int(&data, "flags", source->flags);
 
 	signal_handler_signal(source->context.signals, "update_flags", &data);
-
-	calldata_free(&data);
 }
 
 void obs_source_set_flags(obs_source_t *source, uint32_t flags)
@@ -3033,7 +3028,8 @@ uint32_t obs_source_get_flags(const obs_source_t *source)
 
 void obs_source_set_audio_mixers(obs_source_t *source, uint32_t mixers)
 {
-	struct calldata data = {0};
+	struct calldata data;
+	uint8_t stack[128];
 
 	if (!obs_source_valid(source, "obs_source_set_audio_mixers"))
 		return;
@@ -3043,13 +3039,13 @@ void obs_source_set_audio_mixers(obs_source_t *source, uint32_t mixers)
 	if (source->audio_mixers == mixers)
 		return;
 
+	calldata_init_fixed(&data, stack, sizeof(stack));
 	calldata_set_ptr(&data, "source", source);
 	calldata_set_int(&data, "mixers", mixers);
 
 	signal_handler_signal(source->context.signals, "audio_mixers", &data);
 
 	mixers = (uint32_t)calldata_int(&data, "mixers");
-	calldata_free(&data);
 
 	source->audio_mixers = mixers;
 }
@@ -3195,19 +3191,19 @@ bool obs_source_enabled(const obs_source_t *source)
 
 void obs_source_set_enabled(obs_source_t *source, bool enabled)
 {
-	struct calldata data = {0};
+	struct calldata data;
+	uint8_t stack[128];
 
 	if (!obs_source_valid(source, "obs_source_set_enabled"))
 		return;
 
 	source->enabled = enabled;
 
+	calldata_init_fixed(&data, stack, sizeof(stack));
 	calldata_set_ptr(&data, "source", source);
 	calldata_set_bool(&data, "enabled", enabled);
 
 	signal_handler_signal(source->context.signals, "enable", &data);
-
-	calldata_free(&data);
 }
 
 bool obs_source_muted(const obs_source_t *source)
@@ -3218,7 +3214,8 @@ bool obs_source_muted(const obs_source_t *source)
 
 void obs_source_set_muted(obs_source_t *source, bool muted)
 {
-	struct calldata data = {0};
+	struct calldata data;
+	uint8_t stack[128];
 	struct audio_action action = {
 		.timestamp = os_gettime_ns(),
 		.type      = AUDIO_ACTION_MUTE,
@@ -3230,13 +3227,12 @@ void obs_source_set_muted(obs_source_t *source, bool muted)
 
 	source->user_muted = muted;
 
+	calldata_init_fixed(&data, stack, sizeof(stack));
 	calldata_set_ptr(&data, "source", source);
 	calldata_set_bool(&data, "muted", muted);
 
 	signal_handler_signal(source->context.signals, "mute", &data);
 
-	calldata_free(&data);
-
 	pthread_mutex_lock(&source->audio_actions_mutex);
 	da_push_back(source->audio_actions, &action);
 	pthread_mutex_unlock(&source->audio_actions_mutex);
@@ -3245,25 +3241,27 @@ void obs_source_set_muted(obs_source_t *source, bool muted)
 static void source_signal_push_to_changed(obs_source_t *source,
 		const char *signal, bool enabled)
 {
-	struct calldata data = {0};
+	struct calldata data;
+	uint8_t stack[128];
 
+	calldata_init_fixed(&data, stack, sizeof(stack));
 	calldata_set_ptr (&data, "source",  source);
 	calldata_set_bool(&data, "enabled", enabled);
 
 	signal_handler_signal(source->context.signals, signal, &data);
-	calldata_free(&data);
 }
 
 static void source_signal_push_to_delay(obs_source_t *source,
 		const char *signal, uint64_t delay)
 {
-	struct calldata data = {0};
+	struct calldata data;
+	uint8_t stack[128];
 
+	calldata_init_fixed(&data, stack, sizeof(stack));
 	calldata_set_ptr (&data, "source", source);
 	calldata_set_bool(&data, "delay",  delay);
 
 	signal_handler_signal(source->context.signals, signal, &data);
-	calldata_free(&data);
 }
 
 bool obs_source_push_to_mute_enabled(obs_source_t *source)