obs-studio/libobs/obs-hotkey.c

1531 lines
36 KiB
C
Raw Blame History

This file contains invisible Unicode characters!

This file contains invisible Unicode characters that may be processed differently from what appears below. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to reveal hidden characters.

/******************************************************************************
Copyright (C) 2014-2015 by Ruwen Hahn <palana@stunned.de>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
#include <inttypes.h>
#include "obs-internal.h"
static inline bool lock(void)
{
if (!obs)
return false;
pthread_mutex_lock(&obs->hotkeys.mutex);
return true;
}
static inline void unlock(void)
{
pthread_mutex_unlock(&obs->hotkeys.mutex);
}
obs_hotkey_id obs_hotkey_get_id(const obs_hotkey_t *key)
{
return key->id;
}
const char *obs_hotkey_get_name(const obs_hotkey_t *key)
{
return key->name;
}
const char *obs_hotkey_get_description(const obs_hotkey_t *key)
{
return key->description;
}
obs_hotkey_registerer_t obs_hotkey_get_registerer_type(const obs_hotkey_t *key)
{
return key->registerer_type;
}
void *obs_hotkey_get_registerer(const obs_hotkey_t *key)
{
return key->registerer;
}
obs_hotkey_id obs_hotkey_get_pair_partner_id(const obs_hotkey_t *key)
{
return key->pair_partner_id;
}
obs_key_combination_t obs_hotkey_binding_get_key_combination(
obs_hotkey_binding_t *binding)
{
return binding->key;
}
obs_hotkey_id obs_hotkey_binding_get_hotkey_id(obs_hotkey_binding_t *binding)
{
return binding->hotkey_id;
}
obs_hotkey_t *obs_hotkey_binding_get_hotkey(obs_hotkey_binding_t *binding)
{
return binding->hotkey;
}
static void hotkey_signal(const char *signal, obs_hotkey_t *hotkey)
{
calldata_t data;
calldata_init(&data);
calldata_set_ptr(&data, "key", hotkey);
signal_handler_signal(obs->hotkeys.signals, signal, &data);
calldata_free(&data);
}
static inline void fixup_pointers(void);
static inline void load_bindings(obs_hotkey_t *hotkey, obs_data_array_t *data);
static inline void context_add_hotkey(struct obs_context_data *context,
obs_hotkey_id id)
{
da_push_back(context->hotkeys, &id);
}
static inline obs_hotkey_id obs_hotkey_register_internal(
obs_hotkey_registerer_t type, void *registerer,
struct obs_context_data *context,
const char *name, const char *description,
obs_hotkey_func func, void *data)
{
if ((obs->hotkeys.next_id + 1) == OBS_INVALID_HOTKEY_ID)
blog(LOG_WARNING, "obs-hotkey: Available hotkey ids exhausted");
obs_hotkey_t *base_addr = obs->hotkeys.hotkeys.array;
obs_hotkey_id result = obs->hotkeys.next_id++;
obs_hotkey_t *hotkey = da_push_back_new(obs->hotkeys.hotkeys);
hotkey->id = result;
hotkey->name = bstrdup(name);
hotkey->description = bstrdup(description);
hotkey->func = func;
hotkey->data = data;
hotkey->registerer_type = type;
hotkey->registerer = registerer;
hotkey->pair_partner_id = OBS_INVALID_HOTKEY_PAIR_ID;
if (context) {
obs_data_array_t *data =
obs_data_get_array(context->hotkey_data, name);
load_bindings(hotkey, data);
obs_data_array_release(data);
context_add_hotkey(context, result);
}
if (base_addr != obs->hotkeys.hotkeys.array)
fixup_pointers();
hotkey_signal("hotkey_register", hotkey);
return result;
}
obs_hotkey_id obs_hotkey_register_frontend(const char *name,
const char *description, obs_hotkey_func func, void *data)
{
if (!lock())
return OBS_INVALID_HOTKEY_ID;
obs_hotkey_id id = obs_hotkey_register_internal(
OBS_HOTKEY_REGISTERER_FRONTEND, NULL, NULL,
name, description, func, data);
unlock();
return id;
}
obs_hotkey_id obs_hotkey_register_encoder(obs_encoder_t *encoder,
const char *name, const char *description,
obs_hotkey_func func, void *data)
{
if (!encoder || !lock())
return OBS_INVALID_HOTKEY_ID;
obs_hotkey_id id = obs_hotkey_register_internal(
OBS_HOTKEY_REGISTERER_ENCODER,
obs_encoder_get_weak_encoder(encoder),
&encoder->context, name, description,
func, data);
unlock();
return id;
}
obs_hotkey_id obs_hotkey_register_output(obs_output_t *output,
const char *name, const char *description,
obs_hotkey_func func, void *data)
{
if (!output || !lock())
return OBS_INVALID_HOTKEY_ID;
obs_hotkey_id id = obs_hotkey_register_internal(
OBS_HOTKEY_REGISTERER_OUTPUT,
obs_output_get_weak_output(output),
&output->context, name, description,
func, data);
unlock();
return id;
}
obs_hotkey_id obs_hotkey_register_service(obs_service_t *service,
const char *name, const char *description,
obs_hotkey_func func, void *data)
{
if (!service || !lock())
return OBS_INVALID_HOTKEY_ID;
obs_hotkey_id id = obs_hotkey_register_internal(
OBS_HOTKEY_REGISTERER_SERVICE,
obs_service_get_weak_service(service),
&service->context, name, description,
func, data);
unlock();
return id;
}
obs_hotkey_id obs_hotkey_register_source(obs_source_t *source, const char *name,
const char *description, obs_hotkey_func func, void *data)
{
if (!source || !lock())
return OBS_INVALID_HOTKEY_ID;
obs_hotkey_id id = obs_hotkey_register_internal(
OBS_HOTKEY_REGISTERER_SOURCE,
obs_source_get_weak_source(source),
&source->context, name, description,
func, data);
unlock();
return id;
}
static inline void fixup_pair_pointers(void);
static obs_hotkey_pair_t *create_hotkey_pair(struct obs_context_data *context,
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
void *data0, void *data1)
{
if ((obs->hotkeys.next_pair_id + 1) == OBS_INVALID_HOTKEY_PAIR_ID)
blog(LOG_WARNING, "obs-hotkey: Available hotkey pair ids "
"exhausted");
obs_hotkey_pair_t *base_addr = obs->hotkeys.hotkey_pairs.array;
obs_hotkey_pair_t *pair =
da_push_back_new(obs->hotkeys.hotkey_pairs);
pair->pair_id = obs->hotkeys.next_pair_id++;
pair->func[0] = func0;
pair->func[1] = func1;
pair->id[0] = OBS_INVALID_HOTKEY_ID;
pair->id[1] = OBS_INVALID_HOTKEY_ID;
pair->data[0] = data0;
pair->data[1] = data1;
if (context)
da_push_back(context->hotkey_pairs, &pair->pair_id);
if (base_addr != obs->hotkeys.hotkey_pairs.array)
fixup_pair_pointers();
return pair;
}
static void obs_hotkey_pair_first_func(void *data,
obs_hotkey_id id, obs_hotkey_t *hotkey, bool pressed)
{
UNUSED_PARAMETER(id);
obs_hotkey_pair_t *pair = data;
if (pair->pressed1)
return;
if (pair->pressed0 && !pressed)
pair->pressed0 = false;
else if (pair->func[0](pair->data[0], pair->pair_id, hotkey, pressed))
pair->pressed0 = pressed;
}
static void obs_hotkey_pair_second_func(void *data,
obs_hotkey_id id, obs_hotkey_t *hotkey, bool pressed)
{
UNUSED_PARAMETER(id);
obs_hotkey_pair_t *pair = data;
if (pair->pressed0)
return;
if (pair->pressed1 && !pressed)
pair->pressed1 = false;
else if (pair->func[1](pair->data[0], pair->pair_id, hotkey, pressed))
pair->pressed1 = pressed;
}
static inline bool find_id(obs_hotkey_id id, size_t *idx);
static obs_hotkey_pair_id register_hotkey_pair_internal(
obs_hotkey_registerer_t type, void *registerer,
void *(*weak_ref)(void*),
struct obs_context_data *context,
const char *name0, const char *description0,
const char *name1, const char *description1,
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
void *data0, void *data1)
{
if (!lock())
return OBS_INVALID_HOTKEY_PAIR_ID;
obs_hotkey_pair_t *pair = create_hotkey_pair(context,
func0, func1, data0, data1);
pair->id[0] = obs_hotkey_register_internal(
type, weak_ref(registerer), context,
name0, description0,
obs_hotkey_pair_first_func, pair);
pair->id[1] = obs_hotkey_register_internal(
type, weak_ref(registerer), context,
name1, description1,
obs_hotkey_pair_second_func, pair);
size_t idx;
if (find_id(pair->id[0], &idx))
obs->hotkeys.hotkeys.array[idx].pair_partner_id = pair->id[1];
if (find_id(pair->id[1], &idx))
obs->hotkeys.hotkeys.array[idx].pair_partner_id = pair->id[0];
obs_hotkey_pair_id id = pair->pair_id;
unlock();
return id;
}
static inline void *obs_id_(void *id_)
{
return id_;
}
obs_hotkey_pair_id obs_hotkey_pair_register_frontend(
const char *name0, const char *description0,
const char *name1, const char *description1,
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
void *data0, void *data1)
{
return register_hotkey_pair_internal(
OBS_HOTKEY_REGISTERER_FRONTEND, NULL, obs_id_, NULL,
name0, description0, name1, description1,
func0, func1, data0, data1);
}
static inline void *weak_encoder_ref(void *ref)
{
return obs_encoder_get_weak_encoder(ref);
}
obs_hotkey_pair_id obs_hotkey_pair_register_encoder(obs_encoder_t *encoder,
const char *name0, const char *description0,
const char *name1, const char *description1,
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
void *data0, void *data1)
{
if (!encoder) return OBS_INVALID_HOTKEY_PAIR_ID;
return register_hotkey_pair_internal(
OBS_HOTKEY_REGISTERER_ENCODER, encoder,
weak_encoder_ref,
&encoder->context,
name0, description0, name1, description1,
func0, func1, data0, data1);
}
static inline void *weak_output_ref(void *ref)
{
return obs_output_get_weak_output(ref);
}
obs_hotkey_pair_id obs_hotkey_pair_register_output(obs_output_t *output,
const char *name0, const char *description0,
const char *name1, const char *description1,
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
void *data0, void *data1)
{
if (!output) return OBS_INVALID_HOTKEY_PAIR_ID;
return register_hotkey_pair_internal(
OBS_HOTKEY_REGISTERER_OUTPUT, output,
weak_output_ref,
&output->context,
name0, description0, name1, description1,
func0, func1, data0, data1);
}
static inline void *weak_service_ref(void *ref)
{
return obs_service_get_weak_service(ref);
}
obs_hotkey_pair_id obs_hotkey_pair_register_service(obs_service_t *service,
const char *name0, const char *description0,
const char *name1, const char *description1,
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
void *data0, void *data1)
{
if (!service) return OBS_INVALID_HOTKEY_PAIR_ID;
return register_hotkey_pair_internal(
OBS_HOTKEY_REGISTERER_SERVICE, service,
weak_service_ref,
&service->context,
name0, description0, name1, description1,
func0, func1, data0, data1);
}
static inline void *weak_source_ref(void *ref)
{
return obs_source_get_weak_source(ref);
}
obs_hotkey_pair_id obs_hotkey_pair_register_source(obs_source_t *source,
const char *name0, const char *description0,
const char *name1, const char *description1,
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
void *data0, void *data1)
{
if (!source) return OBS_INVALID_HOTKEY_PAIR_ID;
return register_hotkey_pair_internal(
OBS_HOTKEY_REGISTERER_SOURCE, source,
weak_source_ref,
&source->context,
name0, description0, name1, description1,
func0, func1, data0, data1);
}
typedef bool (*obs_hotkey_internal_enum_func)(void *data,
size_t idx, obs_hotkey_t *hotkey);
static inline void enum_hotkeys(obs_hotkey_internal_enum_func func, void *data)
{
const size_t num = obs->hotkeys.hotkeys.num;
obs_hotkey_t *array = obs->hotkeys.hotkeys.array;
for (size_t i = 0; i < num; i++) {
if (!func(data, i, &array[i]))
break;
}
}
typedef bool (*obs_hotkey_pair_internal_enum_func)(size_t idx,
obs_hotkey_pair_t *pair, void *data);
static inline void enum_hotkey_pairs(obs_hotkey_pair_internal_enum_func func,
void *data)
{
const size_t num = obs->hotkeys.hotkey_pairs.num;
obs_hotkey_pair_t *array = obs->hotkeys.hotkey_pairs.array;
for (size_t i = 0; i < num; i++) {
if (!func(i, &array[i], data))
break;
}
}
typedef bool (*obs_hotkey_binding_internal_enum_func)(void *data,
size_t idx, obs_hotkey_binding_t *binding);
static inline void enum_bindings(obs_hotkey_binding_internal_enum_func func,
void *data)
{
const size_t num = obs->hotkeys.bindings.num;
obs_hotkey_binding_t *array = obs->hotkeys.bindings.array;
for (size_t i = 0; i < num; i++) {
if (!func(data, i, &array[i]))
break;
}
}
struct obs_hotkey_internal_find_forward {
obs_hotkey_id id;
bool found;
size_t idx;
};
static inline bool find_id_helper(void *data, size_t idx, obs_hotkey_t *hotkey)
{
struct obs_hotkey_internal_find_forward *find = data;
if (hotkey->id != find->id)
return true;
find->idx = idx;
find->found = true;
return false;
}
static inline bool find_id(obs_hotkey_id id, size_t *idx)
{
struct obs_hotkey_internal_find_forward find = {id, false, 0};
enum_hotkeys(find_id_helper, &find);
*idx = find.idx;
return find.found;
}
static inline bool pointer_fixup_func(void *data,
size_t idx, obs_hotkey_binding_t *binding)
{
UNUSED_PARAMETER(idx);
UNUSED_PARAMETER(data);
size_t idx_;
if (!find_id(binding->hotkey_id, &idx_)) {
bcrash("obs-hotkey: Could not find hotkey id '%" PRIuMAX "' "
"for binding '%s' (modifiers 0x%x)",
(uintmax_t)binding->hotkey_id,
obs_key_to_name(binding->key.key),
binding->key.modifiers);
binding->hotkey = NULL;
return true;
}
binding->hotkey = &obs->hotkeys.hotkeys.array[idx_];
return true;
}
static inline void fixup_pointers(void)
{
enum_bindings(pointer_fixup_func, NULL);
}
struct obs_hotkey_internal_find_pair_forward {
obs_hotkey_pair_id id;
bool found;
size_t idx;
};
static inline bool find_pair_id_helper(size_t idx, obs_hotkey_pair_t *pair,
void *data)
{
struct obs_hotkey_internal_find_pair_forward *find = data;
if (pair->pair_id != find->id)
return true;
find->idx = idx;
find->found = true;
return false;
}
static inline bool find_pair_id(obs_hotkey_pair_id id, size_t *idx)
{
struct obs_hotkey_internal_find_pair_forward find = {id, false, 0};
enum_hotkey_pairs(find_pair_id_helper, &find);
*idx = find.idx;
return find.found;
}
static inline bool pair_pointer_fixup_func(size_t idx,
obs_hotkey_pair_t *pair, void *data)
{
UNUSED_PARAMETER(idx);
UNUSED_PARAMETER(data);
if (find_id(pair->id[0], &idx))
obs->hotkeys.hotkeys.array[idx].data = pair;
if (find_id(pair->id[1], &idx))
obs->hotkeys.hotkeys.array[idx].data = pair;
return true;
}
static inline void fixup_pair_pointers(void)
{
enum_hotkey_pairs(pair_pointer_fixup_func, NULL);
}
static inline void enum_context_hotkeys(struct obs_context_data *context,
obs_hotkey_internal_enum_func func, void *data)
{
const size_t num = context->hotkeys.num;
const obs_hotkey_id *array = context->hotkeys.array;
obs_hotkey_t *hotkey_array = obs->hotkeys.hotkeys.array;
for (size_t i = 0; i < num; i++) {
size_t idx;
if (!find_id(array[i], &idx))
continue;
if (!func(data, idx, &hotkey_array[idx]))
break;
}
}
static inline void load_modifier(uint32_t *modifiers, obs_data_t *data,
const char *name, uint32_t flag)
{
if (obs_data_get_bool(data, name))
*modifiers |= flag;
}
static inline void create_binding(obs_hotkey_t *hotkey,
obs_key_combination_t combo)
{
obs_hotkey_binding_t *binding = da_push_back_new(obs->hotkeys.bindings);
if (!binding)
return;
binding->key = combo;
binding->hotkey_id = hotkey->id;
binding->hotkey = hotkey;
}
static inline void load_binding(obs_hotkey_t *hotkey, obs_data_t *data)
{
if (!hotkey || !data)
return;
obs_key_combination_t combo = {0};
uint32_t *modifiers = &combo.modifiers;
load_modifier(modifiers, data, "shift", INTERACT_SHIFT_KEY);
load_modifier(modifiers, data, "control", INTERACT_CONTROL_KEY);
load_modifier(modifiers, data, "alt", INTERACT_ALT_KEY);
load_modifier(modifiers, data, "command", INTERACT_COMMAND_KEY);
combo.key = obs_key_from_name(obs_data_get_string(data, "key"));
if (!modifiers && (combo.key == OBS_KEY_NONE ||
combo.key >= OBS_KEY_LAST_VALUE))
return;
create_binding(hotkey, combo);
}
static inline void load_bindings(obs_hotkey_t *hotkey, obs_data_array_t *data)
{
const size_t count = obs_data_array_count(data);
for (size_t i = 0; i < count; i++) {
obs_data_t *item = obs_data_array_item(data, i);
load_binding(hotkey, item);
obs_data_release(item);
}
hotkey_signal("hotkey_bindings_changed", hotkey);
}
static inline void remove_bindings(obs_hotkey_id id);
void obs_hotkey_load_bindings(obs_hotkey_id id,
obs_key_combination_t *combinations, size_t num)
{
size_t idx;
if (!lock())
return;
if (find_id(id, &idx)) {
obs_hotkey_t *hotkey = &obs->hotkeys.hotkeys.array[idx];
remove_bindings(id);
for (size_t i = 0; i < num; i++)
create_binding(hotkey, combinations[i]);
hotkey_signal("hotkey_bindings_changed", hotkey);
}
unlock();
}
void obs_hotkey_load(obs_hotkey_id id, obs_data_array_t *data)
{
size_t idx;
if (!lock())
return;
if (find_id(id, &idx)) {
remove_bindings(id);
load_bindings(&obs->hotkeys.hotkeys.array[idx], data);
}
unlock();
}
static inline bool enum_load_bindings(void *data,
size_t idx, obs_hotkey_t *hotkey)
{
UNUSED_PARAMETER(idx);
obs_data_array_t *hotkey_data = obs_data_get_array(data, hotkey->name);
if (!hotkey_data)
return true;
load_bindings(hotkey, hotkey_data);
obs_data_array_release(hotkey_data);
return true;
}
void obs_hotkeys_load_encoder(obs_encoder_t *encoder, obs_data_t *hotkeys)
{
if (!encoder || !hotkeys)
return;
if (!lock())
return;
enum_context_hotkeys(&encoder->context, enum_load_bindings, hotkeys);
unlock();
}
void obs_hotkeys_load_output(obs_output_t *output, obs_data_t *hotkeys)
{
if (!output || !hotkeys)
return;
if (!lock())
return;
enum_context_hotkeys(&output->context, enum_load_bindings, hotkeys);
unlock();
}
void obs_hotkeys_load_service(obs_service_t *service, obs_data_t *hotkeys)
{
if (!service || !hotkeys)
return;
if (!lock())
return;
enum_context_hotkeys(&service->context, enum_load_bindings, hotkeys);
unlock();
}
void obs_hotkeys_load_source(obs_source_t *source, obs_data_t *hotkeys)
{
if (!source || !hotkeys)
return;
if (!lock())
return;
enum_context_hotkeys(&source->context, enum_load_bindings, hotkeys);
unlock();
}
void obs_hotkey_pair_load(obs_hotkey_pair_id id, obs_data_array_t *data0,
obs_data_array_t *data1)
{
if ((!data0 && !data1) || !lock())
return;
size_t idx;
if (!find_pair_id(id, &idx))
goto unlock;
obs_hotkey_pair_t *pair = &obs->hotkeys.hotkey_pairs.array[idx];
if (find_id(pair->id[0], &idx)) {
remove_bindings(pair->id[0]);
load_bindings(&obs->hotkeys.hotkeys.array[idx], data0);
}
if (find_id(pair->id[1], &idx)) {
remove_bindings(pair->id[1]);
load_bindings(&obs->hotkeys.hotkeys.array[idx], data1);
}
unlock:
unlock();
}
static inline void save_modifier(uint32_t modifiers, obs_data_t *data,
const char *name, uint32_t flag)
{
if ((modifiers & flag) == flag)
obs_data_set_bool(data, name, true);
}
struct save_bindings_helper_t {
obs_data_array_t *array;
obs_hotkey_t *hotkey;
};
static inline bool save_bindings_helper(void *data,
size_t idx, obs_hotkey_binding_t *binding)
{
UNUSED_PARAMETER(idx);
struct save_bindings_helper_t *h = data;
if (h->hotkey->id != binding->hotkey_id)
return true;
obs_data_t *hotkey = obs_data_create();
uint32_t modifiers = binding->key.modifiers;
save_modifier(modifiers, hotkey, "shift", INTERACT_SHIFT_KEY);
save_modifier(modifiers, hotkey, "control", INTERACT_CONTROL_KEY);
save_modifier(modifiers, hotkey, "alt", INTERACT_ALT_KEY);
save_modifier(modifiers, hotkey, "command", INTERACT_COMMAND_KEY);
obs_data_set_string(hotkey, "key", obs_key_to_name(binding->key.key));
obs_data_array_push_back(h->array, hotkey);
obs_data_release(hotkey);
return true;
}
static inline obs_data_array_t *save_hotkey(obs_hotkey_t *hotkey)
{
obs_data_array_t *data = obs_data_array_create();
struct save_bindings_helper_t arg = {data, hotkey};
enum_bindings(save_bindings_helper, &arg);
return data;
}
obs_data_array_t *obs_hotkey_save(obs_hotkey_id id)
{
size_t idx;
obs_data_array_t *result = NULL;
if (!lock())
return result;
if (find_id(id, &idx))
result = save_hotkey(&obs->hotkeys.hotkeys.array[idx]);
unlock();
return result;
}
static inline bool enum_save_hotkey(void *data,
size_t idx, obs_hotkey_t *hotkey)
{
UNUSED_PARAMETER(idx);
obs_data_array_t *hotkey_data = save_hotkey(hotkey);
obs_data_set_array(data, hotkey->name, hotkey_data);
obs_data_array_release(hotkey_data);
return true;
}
static inline obs_data_t *save_context_hotkeys(struct obs_context_data *context)
{
if (!context->hotkeys.num)
return NULL;
obs_data_t *result = obs_data_create();
enum_context_hotkeys(context, enum_save_hotkey, result);
return result;
}
obs_data_t *obs_hotkeys_save_encoder(obs_encoder_t *encoder)
{
obs_data_t *result = NULL;
if (!lock())
return result;
result = save_context_hotkeys(&encoder->context);
unlock();
return result;
}
obs_data_t *obs_hotkeys_save_output(obs_output_t *output)
{
obs_data_t *result = NULL;
if (!lock())
return result;
result = save_context_hotkeys(&output->context);
unlock();
return result;
}
obs_data_t *obs_hotkeys_save_service(obs_service_t *service)
{
obs_data_t *result = NULL;
if (!lock())
return result;
result = save_context_hotkeys(&service->context);
unlock();
return result;
}
obs_data_t *obs_hotkeys_save_source(obs_source_t *source)
{
obs_data_t *result = NULL;
if (!lock())
return result;
result = save_context_hotkeys(&source->context);
unlock();
return result;
}
struct binding_find_data {
obs_hotkey_id id;
size_t *idx;
bool found;
};
static inline bool binding_finder(void *data,
size_t idx, obs_hotkey_binding_t *binding)
{
struct binding_find_data *find = data;
if (binding->hotkey_id != find->id)
return true;
*find->idx = idx;
find->found = true;
return false;
}
static inline bool find_binding(obs_hotkey_id id, size_t *idx)
{
struct binding_find_data data = {id, idx, false};
enum_bindings(binding_finder, &data);
return data.found;
}
static inline void release_pressed_binding(obs_hotkey_binding_t *binding);
static inline void remove_bindings(obs_hotkey_id id)
{
size_t idx;
while (find_binding(id, &idx)) {
obs_hotkey_binding_t *binding =
&obs->hotkeys.bindings.array[idx];
if (binding->pressed)
release_pressed_binding(binding);
da_erase(obs->hotkeys.bindings, idx);
}
}
static void release_registerer(obs_hotkey_t *hotkey)
{
switch (hotkey->registerer_type) {
case OBS_HOTKEY_REGISTERER_FRONTEND:
break;
case OBS_HOTKEY_REGISTERER_ENCODER:
obs_weak_encoder_release(hotkey->registerer);
break;
case OBS_HOTKEY_REGISTERER_OUTPUT:
obs_weak_output_release(hotkey->registerer);
break;
case OBS_HOTKEY_REGISTERER_SERVICE:
obs_weak_service_release(hotkey->registerer);
break;
case OBS_HOTKEY_REGISTERER_SOURCE:
obs_weak_source_release(hotkey->registerer);
break;
}
hotkey->registerer = NULL;
}
static inline bool unregister_hotkey(obs_hotkey_id id)
{
if (id >= obs->hotkeys.next_id)
return false;
size_t idx;
if (!find_id(id, &idx))
return false;
obs_hotkey_t *hotkey = &obs->hotkeys.hotkeys.array[idx];
hotkey_signal("hotkey_unregister", hotkey);
release_registerer(hotkey);
bfree(hotkey->name);
bfree(hotkey->description);
if (hotkey->registerer_type == OBS_HOTKEY_REGISTERER_SOURCE)
obs_weak_source_release(hotkey->registerer);
da_erase(obs->hotkeys.hotkeys, idx);
remove_bindings(id);
return obs->hotkeys.hotkeys.num >= idx;
}
static inline bool unregister_hotkey_pair(obs_hotkey_pair_id id)
{
if (id >= obs->hotkeys.next_pair_id)
return false;
size_t idx;
if (!find_pair_id(id, &idx))
return false;
obs_hotkey_pair_t *pair = &obs->hotkeys.hotkey_pairs.array[idx];
bool need_fixup = unregister_hotkey(pair->id[0]);
need_fixup = unregister_hotkey(pair->id[1]) || need_fixup;
if (need_fixup)
fixup_pointers();
da_erase(obs->hotkeys.hotkey_pairs, idx);
return obs->hotkeys.hotkey_pairs.num >= idx;
}
void obs_hotkey_unregister(obs_hotkey_id id)
{
if (!lock())
return;
if (unregister_hotkey(id))
fixup_pointers();
unlock();
}
void obs_hotkey_pair_unregister(obs_hotkey_pair_id id)
{
if (!lock())
return;
if (unregister_hotkey_pair(id))
fixup_pair_pointers();
unlock();
}
static void context_release_hotkeys(struct obs_context_data *context)
{
if (!context->hotkeys.num)
goto cleanup;
bool need_fixup = false;
for (size_t i = 0; i < context->hotkeys.num; i++)
need_fixup = unregister_hotkey(context->hotkeys.array[i]) ||
need_fixup;
if (need_fixup)
fixup_pointers();
cleanup:
da_free(context->hotkeys);
}
static void context_release_hotkey_pairs(struct obs_context_data *context)
{
if (!context->hotkey_pairs.num)
goto cleanup;
bool need_fixup = false;
for (size_t i = 0; i < context->hotkey_pairs.num; i++)
need_fixup =
unregister_hotkey_pair(context->hotkey_pairs.array[i])
|| need_fixup;
if (need_fixup)
fixup_pair_pointers();
cleanup:
da_free(context->hotkey_pairs);
}
void obs_hotkeys_context_release(struct obs_context_data *context)
{
if (!lock())
return;
context_release_hotkeys(context);
context_release_hotkey_pairs(context);
obs_data_release(context->hotkey_data);
unlock();
}
void obs_hotkeys_free(void)
{
const size_t num = obs->hotkeys.hotkeys.num;
obs_hotkey_t *hotkeys = obs->hotkeys.hotkeys.array;
for (size_t i = 0; i < num; i++) {
bfree(hotkeys[i].name);
bfree(hotkeys[i].description);
release_registerer(&hotkeys[i]);
}
da_free(obs->hotkeys.bindings);
da_free(obs->hotkeys.hotkeys);
da_free(obs->hotkeys.hotkey_pairs);
for (size_t i = 0; i < OBS_KEY_LAST_VALUE; i++) {
if (obs->hotkeys.translations[i]) {
bfree(obs->hotkeys.translations[i]);
obs->hotkeys.translations[i] = NULL;
}
}
}
struct obs_hotkey_internal_enum_forward {
obs_hotkey_enum_func func;
void *data;
};
static inline bool enum_hotkey(void *data, size_t idx, obs_hotkey_t *hotkey)
{
UNUSED_PARAMETER(idx);
struct obs_hotkey_internal_enum_forward *forward = data;
return forward->func(forward->data, hotkey->id, hotkey);
}
void obs_enum_hotkeys(obs_hotkey_enum_func func, void *data)
{
struct obs_hotkey_internal_enum_forward forwarder = {func, data};
if (!lock())
return;
enum_hotkeys(enum_hotkey, &forwarder);
unlock();
}
void obs_enum_hotkey_bindings(obs_hotkey_binding_enum_func func, void *data)
{
if (!lock())
return;
enum_bindings(func, data);
unlock();
}
static inline bool modifiers_match(obs_hotkey_binding_t *binding,
uint32_t modifiers_, bool strict_modifiers)
{
uint32_t modifiers = binding->key.modifiers;
return !modifiers ||
(!strict_modifiers && (modifiers & modifiers_) == modifiers) ||
(strict_modifiers && modifiers == modifiers_);
}
static inline bool is_pressed(obs_key_t key)
{
return obs_hotkeys_platform_is_pressed(obs->hotkeys.platform_context,
key);
}
static inline void press_released_binding(obs_hotkey_binding_t *binding)
{
binding->pressed = true;
obs_hotkey_t *hotkey = binding->hotkey;
if (hotkey->pressed++)
return;
if (!obs->hotkeys.reroute_hotkeys)
hotkey->func(hotkey->data, hotkey->id, hotkey, true);
else if (obs->hotkeys.router_func)
obs->hotkeys.router_func(obs->hotkeys.router_func_data,
hotkey->id, true);
}
static inline void release_pressed_binding(obs_hotkey_binding_t *binding)
{
binding->pressed = false;
obs_hotkey_t *hotkey = binding->hotkey;
if (--hotkey->pressed)
return;
if (!obs->hotkeys.reroute_hotkeys)
hotkey->func(hotkey->data, hotkey->id, hotkey, false);
else if (obs->hotkeys.router_func)
obs->hotkeys.router_func(obs->hotkeys.router_func_data,
hotkey->id, false);
}
static inline void handle_binding(obs_hotkey_binding_t *binding,
uint32_t modifiers, bool no_press, bool strict_modifiers,
bool *pressed)
{
bool modifiers_match_ = modifiers_match(binding, modifiers,
strict_modifiers);
bool modifiers_only = binding->key.key == OBS_KEY_NONE;
if (!binding->key.modifiers)
binding->modifiers_match = true;
if (modifiers_only)
pressed = &modifiers_only;
if (!binding->key.modifiers && modifiers_only)
goto reset;
if ((!binding->modifiers_match && !modifiers_only) || !modifiers_match_)
goto reset;
if ((pressed && !*pressed) ||
(!pressed && !is_pressed(binding->key.key)))
goto reset;
if (binding->pressed || no_press)
return;
press_released_binding(binding);
return;
reset:
binding->modifiers_match = modifiers_match_;
if (!binding->pressed)
return;
release_pressed_binding(binding);
}
struct obs_hotkey_internal_inject {
obs_key_combination_t hotkey;
bool pressed : 1;
bool strict_modifiers : 1;
};
static inline bool inject_hotkey(void *data,
size_t idx, obs_hotkey_binding_t *binding)
{
UNUSED_PARAMETER(idx);
struct obs_hotkey_internal_inject *event = data;
if (modifiers_match(binding, event->hotkey.modifiers,
event->strict_modifiers)) {
bool pressed = binding->key.key == event->hotkey.key &&
event->pressed;
handle_binding(binding, event->hotkey.modifiers, false,
event->strict_modifiers, &pressed);
}
return true;
}
void obs_hotkey_inject_event(obs_key_combination_t hotkey, bool pressed)
{
if (!lock())
return;
struct obs_hotkey_internal_inject event = {
{hotkey.modifiers, hotkey.key},
pressed, obs->hotkeys.strict_modifiers,
};
enum_bindings(inject_hotkey, &event);
unlock();
}
void obs_hotkey_enable_background_press(bool enable)
{
if (!lock())
return;
obs->hotkeys.thread_disable_press = !enable;
unlock();
}
void obs_hotkey_enable_strict_modifiers(bool enable)
{
if (!lock())
return;
obs->hotkeys.strict_modifiers = enable;
unlock();
}
struct obs_query_hotkeys_helper {
uint32_t modifiers;
bool no_press : 1;
bool strict_modifiers : 1;
};
static inline bool query_hotkey(void *data,
size_t idx, obs_hotkey_binding_t *binding)
{
UNUSED_PARAMETER(idx);
struct obs_query_hotkeys_helper *param =
(struct obs_query_hotkeys_helper*)data;
handle_binding(binding, param->modifiers, param->no_press,
param->strict_modifiers, NULL);
return true;
}
static inline void query_hotkeys()
{
uint32_t modifiers = 0;
if (is_pressed(OBS_KEY_SHIFT))
modifiers |= INTERACT_SHIFT_KEY;
if (is_pressed(OBS_KEY_CONTROL))
modifiers |= INTERACT_CONTROL_KEY;
if (is_pressed(OBS_KEY_ALT))
modifiers |= INTERACT_ALT_KEY;
if (is_pressed(OBS_KEY_META))
modifiers |= INTERACT_COMMAND_KEY;
struct obs_query_hotkeys_helper param = {
modifiers,
obs->hotkeys.thread_disable_press,
obs->hotkeys.strict_modifiers,
};
enum_bindings(query_hotkey, &param);
}
void *obs_hotkey_thread(void *arg)
{
UNUSED_PARAMETER(arg);
const char *hotkey_thread_name =
profile_store_name(obs_get_profiler_name_store(),
"obs_hotkey_thread(%g ms)", 25.);
profile_register_root(hotkey_thread_name, (uint64_t)25000000);
while (os_event_timedwait(obs->hotkeys.stop_event, 25) == ETIMEDOUT) {
if (!lock())
continue;
profile_start(hotkey_thread_name);
query_hotkeys();
profile_end(hotkey_thread_name);
unlock();
profile_reenable_thread();
}
return NULL;
}
void obs_hotkey_trigger_routed_callback(obs_hotkey_id id, bool pressed)
{
if (!lock())
return;
if (!obs->hotkeys.reroute_hotkeys)
goto unlock;
size_t idx;
if (!find_id(id, &idx))
goto unlock;
obs_hotkey_t *hotkey = &obs->hotkeys.hotkeys.array[idx];
hotkey->func(hotkey->data, id, hotkey, pressed);
unlock:
unlock();
}
void obs_hotkey_set_callback_routing_func(obs_hotkey_callback_router_func func,
void *data)
{
if (!lock())
return;
obs->hotkeys.router_func = func;
obs->hotkeys.router_func_data = data;
unlock();
}
void obs_hotkey_enable_callback_rerouting(bool enable)
{
if (!lock())
return;
obs->hotkeys.reroute_hotkeys = enable;
unlock();
}
static void obs_set_key_translation(obs_key_t key, const char *translation)
{
bfree(obs->hotkeys.translations[key]);
obs->hotkeys.translations[key] = NULL;
if (translation)
obs->hotkeys.translations[key] = bstrdup(translation);
}
void obs_hotkeys_set_translations_s(
struct obs_hotkeys_translations *translations, size_t size)
{
#define ADD_TRANSLATION(key_name, var_name) \
if (t.var_name) \
obs_set_key_translation(key_name, t.var_name);
struct obs_hotkeys_translations t = {0};
struct dstr numpad = {0};
struct dstr mouse = {0};
struct dstr button = {0};
if (!translations) {
return;
}
memcpy(&t, translations, (size < sizeof(t)) ? size : sizeof(t));
ADD_TRANSLATION(OBS_KEY_INSERT, insert);
ADD_TRANSLATION(OBS_KEY_DELETE, del);
ADD_TRANSLATION(OBS_KEY_HOME, home);
ADD_TRANSLATION(OBS_KEY_END, end);
ADD_TRANSLATION(OBS_KEY_PAGEUP, page_up);
ADD_TRANSLATION(OBS_KEY_PAGEDOWN, page_down);
ADD_TRANSLATION(OBS_KEY_NUMLOCK, num_lock);
ADD_TRANSLATION(OBS_KEY_SCROLLLOCK, scroll_lock);
ADD_TRANSLATION(OBS_KEY_CAPSLOCK, caps_lock);
ADD_TRANSLATION(OBS_KEY_BACKSPACE, backspace);
ADD_TRANSLATION(OBS_KEY_TAB, tab);
ADD_TRANSLATION(OBS_KEY_PRINT, print);
ADD_TRANSLATION(OBS_KEY_PAUSE, pause);
ADD_TRANSLATION(OBS_KEY_SHIFT, shift);
ADD_TRANSLATION(OBS_KEY_ALT, alt);
ADD_TRANSLATION(OBS_KEY_CONTROL, control);
ADD_TRANSLATION(OBS_KEY_META, meta);
ADD_TRANSLATION(OBS_KEY_MENU, menu);
ADD_TRANSLATION(OBS_KEY_SPACE, space);
#ifdef __APPLE__
const char *numpad_str = t.apple_keypad_num;
ADD_TRANSLATION(OBS_KEY_NUMSLASH, apple_keypad_divide);
ADD_TRANSLATION(OBS_KEY_NUMASTERISK, apple_keypad_multiply);
ADD_TRANSLATION(OBS_KEY_NUMMINUS, apple_keypad_minus);
ADD_TRANSLATION(OBS_KEY_NUMPLUS, apple_keypad_plus);
ADD_TRANSLATION(OBS_KEY_NUMPERIOD, apple_keypad_decimal);
ADD_TRANSLATION(OBS_KEY_NUMEQUAL, apple_keypad_equal);
#else
const char *numpad_str = t.numpad_num;
ADD_TRANSLATION(OBS_KEY_NUMSLASH, numpad_divide);
ADD_TRANSLATION(OBS_KEY_NUMASTERISK, numpad_multiply);
ADD_TRANSLATION(OBS_KEY_NUMMINUS, numpad_minus);
ADD_TRANSLATION(OBS_KEY_NUMPLUS, numpad_plus);
ADD_TRANSLATION(OBS_KEY_NUMPERIOD, numpad_decimal);
#endif
if (numpad_str) {
dstr_copy(&numpad, numpad_str);
dstr_depad(&numpad);
if (dstr_find(&numpad, "%1") == NULL) {
dstr_cat(&numpad, " %1");
}
#define ADD_NUMPAD_NUM(idx) \
dstr_copy_dstr(&button, &numpad); \
dstr_replace(&button, "%1", #idx); \
obs_set_key_translation(OBS_KEY_NUM ## idx, button.array)
ADD_NUMPAD_NUM(0);
ADD_NUMPAD_NUM(1);
ADD_NUMPAD_NUM(2);
ADD_NUMPAD_NUM(3);
ADD_NUMPAD_NUM(4);
ADD_NUMPAD_NUM(5);
ADD_NUMPAD_NUM(6);
ADD_NUMPAD_NUM(7);
ADD_NUMPAD_NUM(8);
ADD_NUMPAD_NUM(9);
}
if (t.mouse_num) {
dstr_copy(&mouse, t.mouse_num);
dstr_depad(&mouse);
if (dstr_find(&mouse, "%1") == NULL) {
dstr_cat(&mouse, " %1");
}
#define ADD_MOUSE_NUM(idx) \
dstr_copy_dstr(&button, &mouse); \
dstr_replace(&button, "%1", #idx); \
obs_set_key_translation(OBS_KEY_MOUSE ## idx, button.array)
ADD_MOUSE_NUM(1);
ADD_MOUSE_NUM(2);
ADD_MOUSE_NUM(3);
ADD_MOUSE_NUM(4);
ADD_MOUSE_NUM(5);
ADD_MOUSE_NUM(6);
ADD_MOUSE_NUM(7);
ADD_MOUSE_NUM(8);
ADD_MOUSE_NUM(9);
ADD_MOUSE_NUM(10);
ADD_MOUSE_NUM(11);
ADD_MOUSE_NUM(12);
ADD_MOUSE_NUM(13);
ADD_MOUSE_NUM(14);
ADD_MOUSE_NUM(15);
ADD_MOUSE_NUM(16);
ADD_MOUSE_NUM(17);
ADD_MOUSE_NUM(18);
ADD_MOUSE_NUM(19);
ADD_MOUSE_NUM(20);
ADD_MOUSE_NUM(21);
ADD_MOUSE_NUM(22);
ADD_MOUSE_NUM(23);
ADD_MOUSE_NUM(24);
ADD_MOUSE_NUM(25);
ADD_MOUSE_NUM(26);
ADD_MOUSE_NUM(27);
ADD_MOUSE_NUM(28);
ADD_MOUSE_NUM(29);
}
dstr_free(&numpad);
dstr_free(&mouse);
dstr_free(&button);
}
const char *obs_get_hotkey_translation(obs_key_t key, const char *def)
{
if (key == OBS_KEY_NONE) {
return NULL;
}
return obs->hotkeys.translations[key] ?
obs->hotkeys.translations[key] : def;
}
void obs_hotkey_update_atomic(obs_hotkey_atomic_update_func func, void *data)
{
if (!lock()) return;
func(data);
unlock();
}
void obs_hotkeys_set_audio_hotkeys_translations(
const char *mute, const char *unmute,
const char *push_to_mute, const char *push_to_talk)
{
#define SET_T(n) bfree(obs->hotkeys.n); obs->hotkeys.n = bstrdup(n)
SET_T(mute);
SET_T(unmute);
SET_T(push_to_mute);
SET_T(push_to_talk);
#undef SET_T
}
void obs_hotkeys_set_sceneitem_hotkeys_translations(
const char *show, const char *hide)
{
#define SET_T(n) bfree(obs->hotkeys.sceneitem_##n); \
obs->hotkeys.sceneitem_##n = bstrdup(n)
SET_T(show);
SET_T(hide);
#undef SET_T
}