jp9000/obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libobs: Use calldata with stack for simple signals

Browse Source 
Makes signals use stack memory rather than allocate memory each time.
Most likely a completely insignificant and pointless optimization.
This commit is contained in:
jp9000 2016-01-18 20:01:58 -08:00
parent 91ebb5c5e0
commit 6f98bd9fed
5 changed files with 65 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libobs/obs-internal.h
View File

@ -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);

6
libobs/obs-output-delay.c
View File

@ -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)

12
libobs/obs-output.c
View File

@ -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,

33
libobs/obs-scene.c
View File

@ -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);

66
libobs/obs-source.c
View File

@ -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)