libobs: Add global hotkey support
This commit is contained in:
Palana
411
libobs/obs-hotkey-name-map.c
Normal file
411
libobs/obs-hotkey-name-map.c
Normal file
@@ -0,0 +1,411 @@
|
||||
/******************************************************************************
|
||||
Copyright (C) 2014 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 <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include <util/bmem.h>
|
||||
#include <util/c99defs.h>
|
||||
#include <util/darray.h>
|
||||
|
||||
#include "obs-internal.h"
|
||||
|
||||
struct obs_hotkey_name_map_edge;
|
||||
struct obs_hotkey_name_map_node;
|
||||
struct obs_hotkey_name_map;
|
||||
|
||||
typedef struct obs_hotkey_name_map_edge obs_hotkey_name_map_edge_t;
|
||||
typedef struct obs_hotkey_name_map_node obs_hotkey_name_map_node_t;
|
||||
typedef struct obs_hotkey_name_map obs_hotkey_name_map_t;
|
||||
|
||||
struct obs_hotkey_name_map_node {
|
||||
bool is_leaf;
|
||||
union {
|
||||
int val;
|
||||
DARRAY(obs_hotkey_name_map_edge_t) children;
|
||||
};
|
||||
};
|
||||
|
||||
struct obs_hotkey_name_map {
|
||||
obs_hotkey_name_map_node_t root;
|
||||
obs_hotkey_name_map_node_t *leaves;
|
||||
size_t num_leaves;
|
||||
size_t next_leaf;
|
||||
};
|
||||
|
||||
struct obs_hotkey_name_map_edge_prefix {
|
||||
uint8_t prefix_len;
|
||||
char *prefix;
|
||||
};
|
||||
|
||||
#define NAME_MAP_COMPRESS_LENGTH \
|
||||
(sizeof(struct obs_hotkey_name_map_edge_prefix) - sizeof(uint8_t))
|
||||
|
||||
struct obs_hotkey_name_map_edge {
|
||||
union {
|
||||
struct {
|
||||
uint8_t prefix_len;
|
||||
char *prefix;
|
||||
};
|
||||
struct {
|
||||
uint8_t compressed_len;
|
||||
char compressed_prefix[NAME_MAP_COMPRESS_LENGTH];
|
||||
};
|
||||
};
|
||||
struct obs_hotkey_name_map_node *node;
|
||||
};
|
||||
|
||||
|
||||
static inline obs_hotkey_name_map_node_t *new_node(void)
|
||||
{
|
||||
return bzalloc(sizeof(obs_hotkey_name_map_node_t));
|
||||
}
|
||||
|
||||
static inline obs_hotkey_name_map_node_t *new_leaf(void)
|
||||
{
|
||||
obs_hotkey_name_map_t *name_map = obs->hotkeys.name_map;
|
||||
obs_hotkey_name_map_node_t *node =
|
||||
&name_map->leaves[name_map->next_leaf];
|
||||
name_map->next_leaf += 1;
|
||||
|
||||
node->is_leaf = true;
|
||||
return node;
|
||||
}
|
||||
|
||||
static inline char *get_prefix(obs_hotkey_name_map_edge_t *e)
|
||||
{
|
||||
return e->prefix_len >= NAME_MAP_COMPRESS_LENGTH ?
|
||||
e->prefix : e->compressed_prefix;
|
||||
}
|
||||
|
||||
static void set_prefix(obs_hotkey_name_map_edge_t *e, const char *prefix,
|
||||
size_t l)
|
||||
{
|
||||
assert(e->prefix_len == 0);
|
||||
|
||||
e->compressed_len = (uint8_t)l;
|
||||
if (l < NAME_MAP_COMPRESS_LENGTH)
|
||||
strncpy(e->compressed_prefix, prefix, l);
|
||||
else
|
||||
e->prefix = bstrdup_n(prefix, l);
|
||||
}
|
||||
|
||||
static obs_hotkey_name_map_edge_t *add_leaf(obs_hotkey_name_map_node_t *node,
|
||||
const char *key, size_t l, int v)
|
||||
{
|
||||
obs_hotkey_name_map_edge_t *e = da_push_back_new(node->children);
|
||||
|
||||
set_prefix(e, key, l);
|
||||
|
||||
e->node = new_leaf();
|
||||
e->node->val = v;
|
||||
|
||||
return e;
|
||||
}
|
||||
|
||||
static void shrink_prefix(obs_hotkey_name_map_edge_t *e, size_t l)
|
||||
{
|
||||
bool old_comp = e->prefix_len < NAME_MAP_COMPRESS_LENGTH;
|
||||
bool new_comp = l < NAME_MAP_COMPRESS_LENGTH;
|
||||
|
||||
char *str = get_prefix(e);
|
||||
|
||||
e->prefix_len = (uint8_t)l;
|
||||
if (get_prefix(e) != str)
|
||||
strncpy(get_prefix(e), str, l);
|
||||
else
|
||||
str[l] = 0;
|
||||
|
||||
if (!old_comp && new_comp)
|
||||
bfree(str);
|
||||
}
|
||||
|
||||
static void connect(obs_hotkey_name_map_edge_t *e,
|
||||
obs_hotkey_name_map_node_t *n)
|
||||
{
|
||||
e->node = n;
|
||||
}
|
||||
|
||||
static void reduce_edge(obs_hotkey_name_map_edge_t *e, const char *key,
|
||||
size_t l, int v)
|
||||
{
|
||||
const char *str = get_prefix(e), *str_ = key;
|
||||
size_t common_length = 0;
|
||||
while (*str == *str_) {
|
||||
common_length += 1;
|
||||
str += 1;
|
||||
str_ += 1;
|
||||
}
|
||||
|
||||
obs_hotkey_name_map_node_t *new_node_ = new_node();
|
||||
obs_hotkey_name_map_edge_t *tail =
|
||||
da_push_back_new(new_node_->children);
|
||||
|
||||
connect(tail, e->node);
|
||||
set_prefix(tail, str, e->prefix_len - common_length);
|
||||
|
||||
add_leaf(new_node_, str_, l - common_length, v);
|
||||
|
||||
connect(e, new_node_);
|
||||
shrink_prefix(e, common_length);
|
||||
}
|
||||
|
||||
enum obs_hotkey_name_map_edge_compare_result {
|
||||
RES_MATCHES,
|
||||
RES_NO_MATCH,
|
||||
RES_COMMON_PREFIX,
|
||||
RES_PREFIX_MATCHES,
|
||||
};
|
||||
|
||||
static enum obs_hotkey_name_map_edge_compare_result compare_prefix(
|
||||
obs_hotkey_name_map_edge_t *edge, const char *key, size_t l)
|
||||
{
|
||||
uint8_t pref_len = edge->prefix_len;
|
||||
const char *str = get_prefix(edge);
|
||||
size_t i = 0;
|
||||
|
||||
for (; i < l && i < pref_len; i++)
|
||||
if (str[i] != key[i])
|
||||
break;
|
||||
|
||||
|
||||
if (i != 0 && pref_len == i)
|
||||
return l == i ? RES_MATCHES : RES_PREFIX_MATCHES;
|
||||
if (i != 0)
|
||||
return pref_len == i ? RES_PREFIX_MATCHES : RES_COMMON_PREFIX;
|
||||
return RES_NO_MATCH;
|
||||
}
|
||||
|
||||
static void insert(obs_hotkey_name_map_edge_t *edge,
|
||||
obs_hotkey_name_map_node_t *node,
|
||||
const char *key, size_t l, int v)
|
||||
{
|
||||
if (node->is_leaf && l > 0) {
|
||||
obs_hotkey_name_map_node_t *new_node_ = new_node();
|
||||
connect(edge, new_node_);
|
||||
|
||||
obs_hotkey_name_map_edge_t *edge =
|
||||
da_push_back_new(new_node_->children);
|
||||
connect(edge, node);
|
||||
add_leaf(new_node_, key, l, v);
|
||||
return;
|
||||
}
|
||||
|
||||
if (node->is_leaf && l == 0) {
|
||||
node->val = v;
|
||||
return;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < node->children.num; i++) {
|
||||
obs_hotkey_name_map_edge_t *e = &node->children.array[i];
|
||||
|
||||
switch (compare_prefix(e, key, l)) {
|
||||
case RES_NO_MATCH:
|
||||
continue;
|
||||
|
||||
case RES_MATCHES:
|
||||
case RES_PREFIX_MATCHES:
|
||||
insert(e, e->node, key + e->prefix_len,
|
||||
l - e->prefix_len, v);
|
||||
return;
|
||||
|
||||
case RES_COMMON_PREFIX:
|
||||
reduce_edge(e, key, l, v);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
add_leaf(node, key, l, v);
|
||||
}
|
||||
|
||||
static void obs_hotkey_name_map_insert(obs_hotkey_name_map_t *trie,
|
||||
const char *key, int v)
|
||||
{
|
||||
if (!trie || !key)
|
||||
return;
|
||||
|
||||
insert(NULL, &trie->root, key, strlen(key), v);
|
||||
}
|
||||
|
||||
static bool obs_hotkey_name_map_lookup(obs_hotkey_name_map_t *trie,
|
||||
const char *key, int *v)
|
||||
{
|
||||
if (!trie || !key)
|
||||
return false;
|
||||
|
||||
size_t len = strlen(key);
|
||||
obs_hotkey_name_map_node_t *n = &trie->root;
|
||||
|
||||
size_t i = 0;
|
||||
for (; i < n->children.num;) {
|
||||
obs_hotkey_name_map_edge_t *e = &n->children.array[i];
|
||||
|
||||
switch (compare_prefix(e, key, len)) {
|
||||
case RES_NO_MATCH:
|
||||
i++;
|
||||
continue;
|
||||
|
||||
case RES_COMMON_PREFIX:
|
||||
return false;
|
||||
|
||||
case RES_PREFIX_MATCHES:
|
||||
key += e->prefix_len;
|
||||
len -= e->prefix_len;
|
||||
n = e->node;
|
||||
i = 0;
|
||||
continue;
|
||||
|
||||
case RES_MATCHES:
|
||||
n = e->node;
|
||||
if (!n->is_leaf) {
|
||||
for (size_t j = 0; j < n->children.num; j++) {
|
||||
if (n->children.array[j].prefix_len)
|
||||
continue;
|
||||
|
||||
if (v) *v =
|
||||
n->children.array[j].node->val;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
if (v) *v = n->val;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static void show_node(obs_hotkey_name_map_node_t *node, int in)
|
||||
{
|
||||
if (node->is_leaf) {
|
||||
printf(": % 3d\n", node->val);
|
||||
return;
|
||||
}
|
||||
|
||||
printf("\n");
|
||||
for (int i = 0; i < in; i += 2)
|
||||
printf("| ");
|
||||
printf("%zu:\n", node->children.num);
|
||||
|
||||
for (size_t i = 0; i < node->children.num; i++) {
|
||||
for (int i = 0; i < in; i += 2)
|
||||
printf("| ");
|
||||
printf("\\ ");
|
||||
|
||||
obs_hotkey_name_map_edge_t *e = &node->children.array[i];
|
||||
printf("%s", get_prefix(e));
|
||||
show_node(e->node, in+2);
|
||||
}
|
||||
}
|
||||
|
||||
void trie_print_size(obs_hotkey_name_map_t *trie)
|
||||
{
|
||||
show_node(&trie->root, 0);
|
||||
}
|
||||
|
||||
static const char* obs_key_names[] = {
|
||||
#define OBS_HOTKEY(x) #x,
|
||||
#include "obs-hotkeys.h"
|
||||
#undef OBS_HOTKEY
|
||||
};
|
||||
|
||||
const char* obs_key_to_name(obs_key_t key)
|
||||
{
|
||||
if (key >= OBS_KEY_LAST_VALUE) {
|
||||
blog(LOG_ERROR, "obs-hotkey.c: queried unknown key "
|
||||
"with code %d", (int)key);
|
||||
return "";
|
||||
}
|
||||
|
||||
return obs_key_names[key];
|
||||
}
|
||||
|
||||
static obs_key_t obs_key_from_name_fallback(const char *name)
|
||||
{
|
||||
#define OBS_HOTKEY(x) if (strcmp(#x, name) == 0) return x;
|
||||
#include "obs-hotkeys.h"
|
||||
#undef OBS_HOTKEY
|
||||
return OBS_KEY_NONE;
|
||||
}
|
||||
|
||||
static void init_name_map(void)
|
||||
{
|
||||
obs->hotkeys.name_map = bzalloc(sizeof(struct obs_hotkey_name_map));
|
||||
obs_hotkey_name_map_t *name_map = obs->hotkeys.name_map;
|
||||
|
||||
#define OBS_HOTKEY(x) name_map->num_leaves += 1;
|
||||
#include "obs-hotkeys.h"
|
||||
#undef OBS_HOTKEY
|
||||
|
||||
size_t size = sizeof(obs_hotkey_name_map_node_t) * name_map->num_leaves;
|
||||
name_map->leaves = bzalloc(size);
|
||||
|
||||
#define OBS_HOTKEY(x) obs_hotkey_name_map_insert(name_map, #x, x);
|
||||
#include "obs-hotkeys.h"
|
||||
#undef OBS_HOTKEY
|
||||
}
|
||||
|
||||
obs_key_t obs_key_from_name(const char *name)
|
||||
{
|
||||
if (!obs)
|
||||
return obs_key_from_name_fallback(name);
|
||||
|
||||
if (pthread_once(&obs->hotkeys.name_map_init_token, init_name_map))
|
||||
return obs_key_from_name_fallback(name);
|
||||
|
||||
int v = 0;
|
||||
if (obs_hotkey_name_map_lookup(obs->hotkeys.name_map, name, &v))
|
||||
return v;
|
||||
|
||||
return OBS_KEY_NONE;
|
||||
}
|
||||
|
||||
static void free_node(obs_hotkey_name_map_node_t *node, bool release);
|
||||
|
||||
static void free_edge(obs_hotkey_name_map_edge_t *edge)
|
||||
{
|
||||
free_node(edge->node, true);
|
||||
|
||||
if (edge->prefix_len < NAME_MAP_COMPRESS_LENGTH)
|
||||
return;
|
||||
|
||||
bfree(get_prefix(edge));
|
||||
}
|
||||
|
||||
static void free_node(obs_hotkey_name_map_node_t *node, bool release)
|
||||
{
|
||||
if (!node->is_leaf) {
|
||||
for (size_t i = 0; i < node->children.num; i++)
|
||||
free_edge(&node->children.array[i]);
|
||||
|
||||
da_free(node->children);
|
||||
}
|
||||
|
||||
if (release && !node->is_leaf) bfree(node);
|
||||
}
|
||||
|
||||
void obs_hotkey_name_map_free(void)
|
||||
{
|
||||
if (!obs || !obs->hotkeys.name_map)
|
||||
return;
|
||||
|
||||
free_node(&obs->hotkeys.name_map->root, false);
|
||||
bfree(obs->hotkeys.name_map->leaves);
|
||||
bfree(obs->hotkeys.name_map);
|
||||
}
|
||||
Reference in New Issue
Block a user