obs-studio/libobs/callback/signal.c

211 lines
4.9 KiB
C
Raw Normal View History

/*
* Copyright (c) 2013 Hugh Bailey <obs.jim@gmail.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
2013-12-26 03:26:17 -08:00
#include "../util/darray.h"
#include "../util/threading.h"
2013-12-26 03:26:17 -08:00
#include "signal.h"
struct signal_callback {
void (*callback)(calldata_t, void*);
void *data;
};
struct signal_info {
char *name;
DARRAY(struct signal_callback) callbacks;
pthread_mutex_t mutex;
struct signal_info *next;
};
static inline struct signal_info *signal_info_create(const char *name)
{
struct signal_info *si = bmalloc(sizeof(struct signal_info));
si->name = bstrdup(name);
si->next = NULL;
da_init(si->callbacks);
if (pthread_mutex_init(&si->mutex, NULL) != 0) {
2013-12-26 03:26:17 -08:00
blog(LOG_ERROR, "Could not create signal!");
bfree(si->name);
bfree(si);
return NULL;
}
return si;
}
static inline void signal_info_destroy(struct signal_info *si)
{
if (si) {
pthread_mutex_destroy(&si->mutex);
bfree(si->name);
da_free(si->callbacks);
bfree(si);
}
}
static inline size_t signal_get_callback_idx(struct signal_info *si,
void (*callback)(void*, calldata_t), void *data)
2013-12-26 03:26:17 -08:00
{
for (size_t i = 0; i < si->callbacks.num; i++) {
struct signal_callback *sc = si->callbacks.array+i;
if (sc->callback == callback && sc->data == data)
return i;
}
return DARRAY_INVALID;
}
struct signal_handler {
/* TODO: might be good to use hash table instead */
struct signal_info *first;
pthread_mutex_t mutex;
};
static struct signal_info *getsignal(signal_handler_t handler,
const char *name, struct signal_info **p_last)
{
struct signal_info *signal, *last= NULL;
signal = handler->first;
while (signal != NULL) {
if (strcmp(signal->name, name) == 0)
break;
last = signal;
signal = signal->next;
}
if (p_last)
*p_last = last;
return signal;
}
/* ------------------------------------------------------------------------- */
signal_handler_t signal_handler_create(void)
{
struct signal_handler *handler = bmalloc(sizeof(struct signal_handler));
handler->first = NULL;
if (pthread_mutex_init(&handler->mutex, NULL) != 0) {
blog(LOG_ERROR, "Couldn't create signal handler!");
2013-12-26 03:26:17 -08:00
bfree(handler);
return NULL;
}
return handler;
}
void signal_handler_destroy(signal_handler_t handler)
{
if (handler) {
struct signal_info *sig = handler->first;
while (sig != NULL) {
struct signal_info *next = sig->next;
signal_info_destroy(sig);
sig = next;
}
pthread_mutex_destroy(&handler->mutex);
bfree(handler);
}
}
void signal_handler_connect(signal_handler_t handler, const char *signal,
void (*callback)(void*, calldata_t), void *data)
2013-12-26 03:26:17 -08:00
{
struct signal_info *sig, *last;
struct signal_callback cb_data = {callback, data};
size_t idx;
pthread_mutex_lock(&handler->mutex);
sig = getsignal(handler, signal, &last);
if (!sig) {
sig = signal_info_create(signal);
if (!last)
handler->first = sig;
else
last->next = sig;
if (!sig)
return;
}
pthread_mutex_unlock(&handler->mutex);
/* -------------- */
pthread_mutex_lock(&sig->mutex);
idx = signal_get_callback_idx(sig, callback, data);
if (idx == DARRAY_INVALID)
da_push_back(sig->callbacks, &cb_data);
pthread_mutex_unlock(&sig->mutex);
}
static inline struct signal_info *getsignal_locked(signal_handler_t handler,
const char *name)
{
struct signal_info *sig;
pthread_mutex_lock(&handler->mutex);
sig = getsignal(handler, name, NULL);
pthread_mutex_unlock(&handler->mutex);
return sig;
}
void signal_handler_disconnect(signal_handler_t handler, const char *signal,
void (*callback)(void*, calldata_t), void *data)
2013-12-26 03:26:17 -08:00
{
struct signal_info *sig = getsignal_locked(handler, signal);
size_t idx;
if (!sig)
return;
2013-12-26 03:26:17 -08:00
pthread_mutex_lock(&sig->mutex);
idx = signal_get_callback_idx(sig, callback, data);
if (idx != DARRAY_INVALID)
2013-12-26 03:26:17 -08:00
da_erase(sig->callbacks, idx);
pthread_mutex_unlock(&sig->mutex);
}
void signal_handler_signal(signal_handler_t handler, const char *signal,
calldata_t params)
{
struct signal_info *sig = getsignal_locked(handler, signal);
if (!sig)
return;
2013-12-26 03:26:17 -08:00
pthread_mutex_lock(&sig->mutex);
for (size_t i = 0; i < sig->callbacks.num; i++) {
struct signal_callback *cb = sig->callbacks.array+i;
cb->callback(cb->data, params);
2013-12-26 03:26:17 -08:00
}
pthread_mutex_unlock(&sig->mutex);
}