lagertonne/yolobs-studio
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

New upstream version 24.0.1+dfsg1

Browse source
This commit is contained in:
Sebastian Ramacher 2019-09-22 23:19:10 +02:00
parent b14f9eae6d
commit 5a730d6ec3
842 changed files with 42245 additions and 33385 deletions
Download patch file Download diff file Expand all files Collapse all files

31
libobs/callback/calldata.c
View file

@ -65,8 +65,7 @@ static inline const char *cd_serialize_string(uint8_t **pos)
return (size != 0) ? str : NULL;
}
static bool cd_getparam(const calldata_t *data, const char *name,
uint8_t **pos)
static bool cd_getparam(const calldata_t *data, const char *name, uint8_t **pos)
{
size_t name_size;
@ -97,7 +96,7 @@ static bool cd_getparam(const calldata_t *data, const char *name,
static inline void cd_copy_string(uint8_t **pos, const char *str, size_t len)
{
if (!len)
len = strlen(str)+1;
len = strlen(str) + 1;
memcpy(*pos, &len, sizeof(size_t));
*pos += sizeof(size_t);
@ -117,20 +116,20 @@ static inline void cd_copy_data(uint8_t **pos, const void *in, size_t size)
}
static inline void cd_set_first_param(calldata_t *data, const char *name,
const void *in, size_t size)
const void *in, size_t size)
{
uint8_t *pos;
size_t capacity;
size_t name_len = strlen(name)+1;
size_t name_len = strlen(name) + 1;
capacity = sizeof(size_t)*3 + name_len + size;
capacity = sizeof(size_t) * 3 + name_len + size;
data->size = capacity;
if (capacity < 128)
capacity = 128;
data->capacity = capacity;
data->stack = bmalloc(capacity);
data->stack = bmalloc(capacity);
pos = data->stack;
cd_copy_string(&pos, name, name_len);
@ -139,7 +138,7 @@ static inline void cd_set_first_param(calldata_t *data, const char *name,
}
static inline bool cd_ensure_capacity(calldata_t *data, uint8_t **pos,
size_t new_size)
size_t new_size)
{
size_t offset;
size_t new_capacity;
@ -157,7 +156,7 @@ static inline bool cd_ensure_capacity(calldata_t *data, uint8_t **pos,
if (new_capacity < new_size)
new_capacity = new_size;
data->stack = brealloc(data->stack, new_capacity);
data->stack = brealloc(data->stack, new_capacity);
data->capacity = new_capacity;
*pos = data->stack + offset;
@ -167,7 +166,7 @@ static inline bool cd_ensure_capacity(calldata_t *data, uint8_t **pos,
/* ------------------------------------------------------------------------- */
bool calldata_get_data(const calldata_t *data, const char *name, void *out,
size_t size)
size_t size)
{
uint8_t *pos;
size_t data_size;
@ -187,7 +186,7 @@ bool calldata_get_data(const calldata_t *data, const char *name, void *out,
}
void calldata_set_data(calldata_t *data, const char *name, const void *in,
size_t size)
size_t size)
{
uint8_t *pos = NULL;
@ -209,22 +208,22 @@ void calldata_set_data(calldata_t *data, const char *name, const void *in,
if (!cd_ensure_capacity(data, &pos, bytes + offset))
return;
memmove(pos+offset, pos, bytes - (pos - data->stack));
memmove(pos + offset, pos, bytes - (pos - data->stack));
data->size += offset;
} else if (cur_size > size) {
size_t offset = cur_size - size;
size_t bytes = data->size - offset;
memmove(pos, pos+offset, bytes - (pos - data->stack));
memmove(pos, pos + offset, bytes - (pos - data->stack));
data->size -= offset;
}
cd_copy_data(&pos, in, size);
} else {
size_t name_len = strlen(name)+1;
size_t offset = name_len + size + sizeof(size_t)*2;
size_t name_len = strlen(name) + 1;
size_t offset = name_len + size + sizeof(size_t) * 2;
if (!cd_ensure_capacity(data, &pos, data->size + offset))
return;
data->size += offset;
@ -236,7 +235,7 @@ void calldata_set_data(calldata_t *data, const char *name, const void *in,
}
bool calldata_get_string(const calldata_t *data, const char *name,
const char **str)
const char **str)
{
uint8_t *pos;
if (!data || !name || !*name)

56
libobs/callback/calldata.h
View file

@ -40,14 +40,14 @@ enum call_param_type {
CALL_PARAM_TYPE_STRING
};
#define CALL_PARAM_IN (1<<0)
#define CALL_PARAM_OUT (1<<1)
#define CALL_PARAM_IN (1 << 0)
#define CALL_PARAM_OUT (1 << 1)
struct calldata {
uint8_t *stack;
size_t size; /* size of the stack, in bytes */
size_t capacity; /* capacity of the stack, in bytes */
bool fixed; /* fixed size (using call stack) */
size_t size; /* size of the stack, in bytes */
size_t capacity; /* capacity of the stack, in bytes */
bool fixed; /* fixed size (using call stack) */
};
typedef struct calldata calldata_t;
@ -60,7 +60,7 @@ static inline void calldata_init(struct calldata *data)
static inline void calldata_clear(struct calldata *data);
static inline void calldata_init_fixed(struct calldata *data, uint8_t *stack,
size_t size)
size_t size)
{
data->stack = stack;
data->capacity = size;
@ -76,9 +76,9 @@ static inline void calldata_free(struct calldata *data)
}
EXPORT bool calldata_get_data(const calldata_t *data, const char *name,
void *out, size_t size);
void *out, size_t size);
EXPORT void calldata_set_data(calldata_t *data, const char *name,
const void *in, size_t new_size);
const void *in, size_t new_size);
static inline void calldata_clear(struct calldata *data)
{
@ -90,7 +90,7 @@ static inline void calldata_clear(struct calldata *data)
static inline calldata_t *calldata_create(void)
{
return (calldata_t*)bzalloc(sizeof(struct calldata));
return (calldata_t *)bzalloc(sizeof(struct calldata));
}
static inline void calldata_destroy(calldata_t *cd)
@ -104,31 +104,31 @@ static inline void calldata_destroy(calldata_t *cd)
* same type. They return false otherwise. */
static inline bool calldata_get_int(const calldata_t *data, const char *name,
long long *val)
long long *val)
{
return calldata_get_data(data, name, val, sizeof(*val));
}
static inline bool calldata_get_float (const calldata_t *data, const char *name,
double *val)
static inline bool calldata_get_float(const calldata_t *data, const char *name,
double *val)
{
return calldata_get_data(data, name, val, sizeof(*val));
}
static inline bool calldata_get_bool (const calldata_t *data, const char *name,
bool *val)
static inline bool calldata_get_bool(const calldata_t *data, const char *name,
bool *val)
{
return calldata_get_data(data, name, val, sizeof(*val));
}
static inline bool calldata_get_ptr (const calldata_t *data, const char *name,
void *p_ptr)
static inline bool calldata_get_ptr(const calldata_t *data, const char *name,
void *p_ptr)
{
return calldata_get_data(data, name, p_ptr, sizeof(p_ptr));
}
EXPORT bool calldata_get_string(const calldata_t *data, const char *name,
const char **str);
const char **str);
/* ------------------------------------------------------------------------- */
/* call if you know your data is valid */
@ -162,7 +162,7 @@ static inline void *calldata_ptr(const calldata_t *data, const char *name)
}
static inline const char *calldata_string(const calldata_t *data,
const char *name)
const char *name)
{
const char *val = NULL;
calldata_get_string(data, name, &val);
@ -171,35 +171,35 @@ static inline const char *calldata_string(const calldata_t *data,
/* ------------------------------------------------------------------------- */
static inline void calldata_set_int (calldata_t *data, const char *name,
long long val)
static inline void calldata_set_int(calldata_t *data, const char *name,
long long val)
{
calldata_set_data(data, name, &val, sizeof(val));
}
static inline void calldata_set_float (calldata_t *data, const char *name,
double val)
static inline void calldata_set_float(calldata_t *data, const char *name,
double val)
{
calldata_set_data(data, name, &val, sizeof(val));
}
static inline void calldata_set_bool (calldata_t *data, const char *name,
bool val)
static inline void calldata_set_bool(calldata_t *data, const char *name,
bool val)
{
calldata_set_data(data, name, &val, sizeof(val));
}
static inline void calldata_set_ptr (calldata_t *data, const char *name,
void *ptr)
static inline void calldata_set_ptr(calldata_t *data, const char *name,
void *ptr)
{
calldata_set_data(data, name, &ptr, sizeof(ptr));
}
static inline void calldata_set_string(calldata_t *data, const char *name,
const char *str)
const char *str)
{
if (str)
calldata_set_data(data, name, str, strlen(str)+1);
calldata_set_data(data, name, str, strlen(str) + 1);
else
calldata_set_data(data, name, NULL, 0);
}

41
libobs/callback/decl.c
View file

@ -18,16 +18,16 @@
#include "decl.h"
static inline void err_specifier_exists(struct cf_parser *cfp,
const char *storage)
const char *storage)
{
cf_adderror(cfp, "'$1' specifier already exists", LEX_ERROR,
storage, NULL, NULL);
cf_adderror(cfp, "'$1' specifier already exists", LEX_ERROR, storage,
NULL, NULL);
}
static inline void err_reserved_name(struct cf_parser *cfp, const char *name)
{
cf_adderror(cfp, "'$1' is a reserved name", LEX_ERROR,
name, NULL, NULL);
cf_adderror(cfp, "'$1' is a reserved name", LEX_ERROR, name, NULL,
NULL);
}
static inline void err_existing_name(struct cf_parser *cfp, const char *name)
@ -36,7 +36,7 @@ static inline void err_existing_name(struct cf_parser *cfp, const char *name)
}
static bool is_in_out_specifier(struct cf_parser *cfp, struct strref *name,
uint32_t *type)
uint32_t *type)
{
if (strref_cmp(name, "in") == 0) {
if (*type & CALL_PARAM_IN)
@ -60,7 +60,7 @@ static bool is_in_out_specifier(struct cf_parser *cfp, struct strref *name,
#define TYPE_OR_STORAGE "type or storage specifier"
static bool get_type(struct strref *ref, enum call_param_type *type,
bool is_return)
bool is_return)
{
if (strref_cmp(ref, "int") == 0)
*type = CALL_PARAM_TYPE_INT;
@ -82,12 +82,9 @@ static bool get_type(struct strref *ref, enum call_param_type *type,
static bool is_reserved_name(const char *str)
{
return (strcmp(str, "int") == 0) ||
(strcmp(str, "float") == 0) ||
(strcmp(str, "bool") == 0) ||
(strcmp(str, "ptr") == 0) ||
(strcmp(str, "string") == 0) ||
(strcmp(str, "void") == 0) ||
return (strcmp(str, "int") == 0) || (strcmp(str, "float") == 0) ||
(strcmp(str, "bool") == 0) || (strcmp(str, "ptr") == 0) ||
(strcmp(str, "string") == 0) || (strcmp(str, "void") == 0) ||
(strcmp(str, "return") == 0);
}
@ -105,9 +102,9 @@ static bool name_exists(struct decl_info *decl, const char *name)
static int parse_param(struct cf_parser *cfp, struct decl_info *decl)
{
struct strref ref;
int code;
struct decl_param param = {0};
struct strref ref;
int code;
struct decl_param param = {0};
/* get storage specifiers */
code = cf_next_name_ref(cfp, &ref, TYPE_OR_STORAGE, ",");
@ -180,7 +177,7 @@ static void print_errors(struct cf_parser *cfp, const char *decl_string)
if (errors) {
blog(LOG_WARNING, "Errors/warnings for '%s':\n\n%s",
decl_string, errors);
decl_string, errors);
bfree(errors);
}
@ -188,11 +185,11 @@ static void print_errors(struct cf_parser *cfp, const char *decl_string)
bool parse_decl_string(struct decl_info *decl, const char *decl_string)
{
struct cf_parser cfp;
struct strref ret_type;
struct decl_param ret_param = {0};
int code;
bool success;
struct cf_parser cfp;
struct strref ret_type;
struct decl_param ret_param = {0};
int code;
bool success;
decl->decl_string = decl_string;
ret_param.flags = CALL_PARAM_OUT;

10
libobs/callback/decl.h
View file

@ -24,9 +24,9 @@ extern "C" {
#endif
struct decl_param {
char *name;
char *name;
enum call_param_type type;
uint32_t flags;
uint32_t flags;
};
static inline void decl_param_free(struct decl_param *param)
@ -37,8 +37,8 @@ static inline void decl_param_free(struct decl_param *param)
}
struct decl_info {
char *name;
const char *decl_string;
char *name;
const char *decl_string;
DARRAY(struct decl_param) params;
};
@ -46,7 +46,7 @@ static inline void decl_info_free(struct decl_info *decl)
{
if (decl) {
for (size_t i = 0; i < decl->params.num; i++)
decl_param_free(decl->params.array+i);
decl_param_free(decl->params.array + i);
da_free(decl->params);
bfree(decl->name);

22
libobs/callback/proc.c
View file

@ -20,8 +20,8 @@
#include "proc.h"
struct proc_info {
struct decl_info func;
void *data;
struct decl_info func;
void *data;
proc_handler_proc_t callback;
};
@ -46,39 +46,41 @@ void proc_handler_destroy(proc_handler_t *handler)
{
if (handler) {
for (size_t i = 0; i < handler->procs.num; i++)
proc_info_free(handler->procs.array+i);
proc_info_free(handler->procs.array + i);
da_free(handler->procs);
bfree(handler);
}
}
void proc_handler_add(proc_handler_t *handler, const char *decl_string,
proc_handler_proc_t proc, void *data)
proc_handler_proc_t proc, void *data)
{
if (!handler) return;
if (!handler)
return;
struct proc_info pi;
memset(&pi, 0, sizeof(struct proc_info));
if (!parse_decl_string(&pi.func, decl_string)) {
blog(LOG_ERROR, "Function declaration invalid: %s",
decl_string);
decl_string);
return;
}
pi.callback = proc;
pi.data = data;
pi.data = data;
da_push_back(handler->procs, &pi);
}
bool proc_handler_call(proc_handler_t *handler, const char *name,
calldata_t *params)
calldata_t *params)
{
if (!handler) return false;
if (!handler)
return false;
for (size_t i = 0; i < handler->procs.num; i++) {
struct proc_info *info = handler->procs.array+i;
struct proc_info *info = handler->procs.array + i;
if (strcmp(info->func.name, name) == 0) {
info->callback(info->data, params);

6
libobs/callback/proc.h
View file

@ -34,20 +34,20 @@ extern "C" {
struct proc_handler;
typedef struct proc_handler proc_handler_t;
typedef void (*proc_handler_proc_t)(void*, calldata_t*);
typedef void (*proc_handler_proc_t)(void *, calldata_t *);
EXPORT proc_handler_t *proc_handler_create(void);
EXPORT void proc_handler_destroy(proc_handler_t *handler);
EXPORT void proc_handler_add(proc_handler_t *handler, const char *decl_string,
proc_handler_proc_t proc, void *data);
proc_handler_proc_t proc, void *data);
/**
* Calls a function in a procedure handler. Returns false if the named
* procedure is not found.
*/
EXPORT bool proc_handler_call(proc_handler_t *handler, const char *name,
calldata_t *params);
calldata_t *params);
#ifdef __cplusplus
}

79
libobs/callback/signal.c
View file

@ -22,18 +22,18 @@
struct signal_callback {
signal_callback_t callback;
void *data;
bool remove;
bool keep_ref;
void *data;
bool remove;
bool keep_ref;
};
struct signal_info {
struct decl_info func;
struct decl_info func;
DARRAY(struct signal_callback) callbacks;
pthread_mutex_t mutex;
bool signalling;
pthread_mutex_t mutex;
bool signalling;
struct signal_info *next;
struct signal_info *next;
};
static inline struct signal_info *signal_info_create(struct decl_info *info)
@ -48,8 +48,8 @@ static inline struct signal_info *signal_info_create(struct decl_info *info)
si = bmalloc(sizeof(struct signal_info));
si->func = *info;
si->next = NULL;
si->func = *info;
si->next = NULL;
si->signalling = false;
da_init(si->callbacks);
@ -75,10 +75,11 @@ static inline void signal_info_destroy(struct signal_info *si)
}
static inline size_t signal_get_callback_idx(struct signal_info *si,
signal_callback_t callback, void *data)
signal_callback_t callback,
void *data)
{
for (size_t i = 0; i < si->callbacks.num; i++) {
struct signal_callback *sc = si->callbacks.array+i;
struct signal_callback *sc = si->callbacks.array + i;
if (sc->callback == callback && sc->data == data)
return i;
@ -89,24 +90,25 @@ static inline size_t signal_get_callback_idx(struct signal_info *si,
struct global_callback_info {
global_signal_callback_t callback;
void *data;
long signaling;
bool remove;
void *data;
long signaling;
bool remove;
};
struct signal_handler {
struct signal_info *first;
pthread_mutex_t mutex;
volatile long refs;
pthread_mutex_t mutex;
volatile long refs;
DARRAY(struct global_callback_info) global_callbacks;
pthread_mutex_t global_callbacks_mutex;
pthread_mutex_t global_callbacks_mutex;
};
static struct signal_info *getsignal(signal_handler_t *handler,
const char *name, struct signal_info **p_last)
const char *name,
struct signal_info **p_last)
{
struct signal_info *signal, *last= NULL;
struct signal_info *signal, *last = NULL;
signal = handler->first;
while (signal != NULL) {
@ -206,8 +208,9 @@ bool signal_handler_add(signal_handler_t *handler, const char *signal_decl)
}
static void signal_handler_connect_internal(signal_handler_t *handler,
const char *signal, signal_callback_t callback, void *data,
bool keep_ref)
const char *signal,
signal_callback_t callback,
void *data, bool keep_ref)
{
struct signal_info *sig, *last;
struct signal_callback cb_data = {callback, data, false, keep_ref};
@ -221,8 +224,10 @@ static void signal_handler_connect_internal(signal_handler_t *handler,
pthread_mutex_unlock(&handler->mutex);
if (!sig) {
blog(LOG_WARNING, "signal_handler_connect: "
"signal '%s' not found", signal);
blog(LOG_WARNING,
"signal_handler_connect: "
"signal '%s' not found",
signal);
return;
}
@ -241,19 +246,19 @@ static void signal_handler_connect_internal(signal_handler_t *handler,
}
void signal_handler_connect(signal_handler_t *handler, const char *signal,
signal_callback_t callback, void *data)
signal_callback_t callback, void *data)
{
signal_handler_connect_internal(handler, signal, callback, data, false);
}
void signal_handler_connect_ref(signal_handler_t *handler, const char *signal,
signal_callback_t callback, void *data)
signal_callback_t callback, void *data)
{
signal_handler_connect_internal(handler, signal, callback, data, true);
}
static inline struct signal_info *getsignal_locked(signal_handler_t *handler,
const char *name)
const char *name)
{
struct signal_info *sig;
@ -268,7 +273,7 @@ static inline struct signal_info *getsignal_locked(signal_handler_t *handler,
}
void signal_handler_disconnect(signal_handler_t *handler, const char *signal,
signal_callback_t callback, void *data)
signal_callback_t callback, void *data)
{
struct signal_info *sig = getsignal_locked(handler, signal);
bool keep_ref = false;
@ -308,7 +313,7 @@ void signal_handler_remove_current(void)
}
void signal_handler_signal(signal_handler_t *handler, const char *signal,
calldata_t *params)
calldata_t *params)
{
struct signal_info *sig = getsignal_locked(handler, signal);
long remove_refs = 0;
@ -320,7 +325,7 @@ void signal_handler_signal(signal_handler_t *handler, const char *signal,
sig->signalling = true;
for (size_t i = 0; i < sig->callbacks.num; i++) {
struct signal_callback *cb = sig->callbacks.array+i;
struct signal_callback *cb = sig->callbacks.array + i;
if (!cb->remove) {
current_signal_cb = cb;
cb->callback(cb->data, params);
@ -329,12 +334,12 @@ void signal_handler_signal(signal_handler_t *handler, const char *signal,
}
for (size_t i = sig->callbacks.num; i > 0; i--) {
struct signal_callback *cb = sig->callbacks.array+i-1;
struct signal_callback *cb = sig->callbacks.array + i - 1;
if (cb->remove) {
if (cb->keep_ref)
remove_refs++;
da_erase(sig->callbacks, i-1);
da_erase(sig->callbacks, i - 1);
}
}
@ -363,20 +368,21 @@ void signal_handler_signal(signal_handler_t *handler, const char *signal,
if (cb->remove && !cb->signaling)
da_erase(handler->global_callbacks, i - 1);
}
}
}
pthread_mutex_unlock(&handler->global_callbacks_mutex);
if (remove_refs) {
os_atomic_set_long(&handler->refs,
os_atomic_load_long(&handler->refs) -
remove_refs);
os_atomic_load_long(&handler->refs) -
remove_refs);
}
}
void signal_handler_connect_global(signal_handler_t *handler,
global_signal_callback_t callback, void *data)
global_signal_callback_t callback,
void *data)
{
struct global_callback_info cb_data = {callback, data, 0, false};
size_t idx;
@ -394,7 +400,8 @@ void signal_handler_connect_global(signal_handler_t *handler,
}
void signal_handler_disconnect_global(signal_handler_t *handler,
global_signal_callback_t callback, void *data)
global_signal_callback_t callback,
void *data)
{
struct global_callback_info cb_data = {callback, data, false};
size_t idx;

25
libobs/callback/signal.h
View file

@ -33,17 +33,17 @@ extern "C" {
struct signal_handler;
typedef struct signal_handler signal_handler_t;
typedef void (*global_signal_callback_t)(void*, const char*, calldata_t*);
typedef void (*signal_callback_t)(void*, calldata_t*);
typedef void (*global_signal_callback_t)(void *, const char *, calldata_t *);
typedef void (*signal_callback_t)(void *, calldata_t *);
EXPORT signal_handler_t *signal_handler_create(void);
EXPORT void signal_handler_destroy(signal_handler_t *handler);
EXPORT bool signal_handler_add(signal_handler_t *handler,
const char *signal_decl);
const char *signal_decl);
static inline bool signal_handler_add_array(signal_handler_t *handler,
const char **signal_decls)
const char **signal_decls)
{
bool success = true;
if (!signal_decls)
@ -57,21 +57,26 @@ static inline bool signal_handler_add_array(signal_handler_t *handler,
}
EXPORT void signal_handler_connect(signal_handler_t *handler,
const char *signal, signal_callback_t callback, void *data);
const char *signal,
signal_callback_t callback, void *data);
EXPORT void signal_handler_connect_ref(signal_handler_t *handler,
const char *signal, signal_callback_t callback, void *data);
const char *signal,
signal_callback_t callback, void *data);
EXPORT void signal_handler_disconnect(signal_handler_t *handler,
const char *signal, signal_callback_t callback, void *data);
const char *signal,
signal_callback_t callback, void *data);
EXPORT void signal_handler_connect_global(signal_handler_t *handler,
global_signal_callback_t callback, void *data);
global_signal_callback_t callback,
void *data);
EXPORT void signal_handler_disconnect_global(signal_handler_t *handler,
global_signal_callback_t callback, void *data);
global_signal_callback_t callback,
void *data);
EXPORT void signal_handler_remove_current(void);
EXPORT void signal_handler_signal(signal_handler_t *handler, const char *signal,
calldata_t *params);
calldata_t *params);
#ifdef __cplusplus
}