xref: /dports/audio/fossmixer/detroit-0.2.3/engine/worker_cb.c

#include "declarations.h"
#include "worker_cb.h"



void worker_cb(void *ta) {
	struct t_ctx *ti;

	ti = (struct t_ctx *) ta;

	/* This thread likes to receive pthread_cancel() */
	ti->ar = THREAD_TERM_CANCEL;

	pthread_cleanup_push(worker_cb_cancel, ti);

	if(worker_cb_init(ti) == 0) {
		worker_cb_again:

		(void) callback_event_run(ti->tp);

		if(thread_wait(ti) == 0) goto worker_cb_again;
	}

	/* Free allocated resources and terminate thread (never reached, but pthread_cleanup_pop() needs to be there) */
	pthread_cleanup_pop(1);

	(void) worker_cb_finalize(ti);
}

static void worker_cb_cancel(void *ta) {
	struct t_ctx *ti;

	ti = (struct t_ctx *) ta;

	if(ti->tp != NULL) {
		(void) worker_cb_cancel_local(ti, (struct t_str *) ti->tp);

		(void) free(ti->tp);

		ti->tp = NULL;
	}

	ti->tr = THREAD_STATE_STOP;
}

static void worker_cb_cancel_local(__UNUSED__ struct t_ctx *ti, __UNUSED__ struct t_str *tp) {
}

static void worker_cb_finalize(struct t_ctx *ti) {
	(void) thread_exit(ti, NULL);
}

static int worker_cb_init(struct t_ctx *ti) {
	int r;

	int *a;

	struct t_str *c;

	APP_MALLOC_RET_VALUE(c, sizeof(struct t_str), -1);

	ti->tp = c;

	(void) thread_title(ti, APPLICATION_EXEC "_cb");

	if((a = (int *) conf_fetch("cpu_callback")) != NULL) {
		if(*a != 0) (void) thread_affinity(*a);
	}

	r = worker_cb_init_local(ti, (struct t_str *) ti->tp);

	ti->tr = THREAD_STATE_IDLE;

	return(r);
}

static int worker_cb_init_local(__UNUSED__ struct t_ctx *ti, struct t_str *tp) {
	unsigned int i;

	tp->c_lck = IS_NO;
	tp->c_pnd = IS_NO;
	tp->c_cnt = 0;

	for(i = 0; i < WORKER_CB_CALLBACK_MAX; i++) {
		tp->cb[0][i].cb = NULL;
		tp->cb[1][i].cb = NULL;
	}

	return(0);
}

static void callback_event_run(struct t_str *tp) {
	unsigned int i, p;

	struct w_par *wp;
	struct d_par *dp;

	void (*cb)(struct w_par *, struct d_par *);

	/* If there are no pending callbacks, leave */
	if(tp->c_pnd != IS_YES) return;

	tp->c_pnd = IS_NO;

	/* Hold on a while if callback pipeline is locked by callback_event_add() */
	while(tp->c_lck == IS_YES) {
		(void) timer_wait(0, TIMER_RESOLUTION_VERYFAST);
	}

	tp->c_lck = IS_MAYBE;

	/* Make sorted copy of pipeline, skipping unused slots */
	p = callback_event_run_op(tp);

	tp->c_lck = IS_NO;

	for(i = 0; i < p; i++) {
		if(tp->cb[1][i].cb != NULL) {
			cb = tp->cb[1][i].cb;
			wp = tp->cb[1][i].wp;
			dp = tp->cb[1][i].dp;

			tp->cb[1][i].cb = NULL;

			(void) (*cb)(wp, dp);
		}
	}
}

static unsigned int callback_event_run_op(struct t_str *tp) {
	unsigned int i, p;

	p = 0;

	for(i = 0; i < WORKER_CB_CALLBACK_MAX; i++) {
		if(tp->cb[0][i].cb == NULL) continue;

		tp->cb[1][p].n = tp->cb[0][i].n;

		tp->cb[1][p].cb = tp->cb[0][i].cb;
		tp->cb[1][p].wp = tp->cb[0][i].wp;
		tp->cb[1][p].dp = tp->cb[0][i].dp;

		tp->cb[0][i].cb = NULL;

		++p;
	}

	if(p > 1) (void) qsort((void *) tp->cb[1], (size_t) p, sizeof(struct t_cb), callback_event_run_cmp);

	tp->c_cnt = 0;

	return(p);
}

static int callback_event_run_cmp(const void *a, const void *b) {
	const struct t_cb *c, *d;

	c = (const struct t_cb *) a;
	d = (const struct t_cb *) b;

	return(c->n - d->n);
}

void callback_event_add(struct t_ctx *ti, void *cb, struct w_par *wp, struct d_par *dp) {
	unsigned int i;

	struct t_str *tp;

	/* Add callback only if callback function name is specified */
	if(dp->s == NULL || dp->s[0] == 0) return;

	tp = ti->tp;

	/* Hold on a while if callback pipeline is locked by callback_event_run() */
	while(tp->c_lck == IS_MAYBE) {
		(void) timer_wait(0, TIMER_RESOLUTION_VERYFAST);
	}

	tp->c_lck = IS_YES;

	for(i = 0; i < WORKER_CB_CALLBACK_MAX; i++) {
		if(tp->cb[0][i].cb == NULL) {
			tp->cb[0][i].n = ++tp->c_cnt;

			tp->cb[0][i].cb = cb;
			tp->cb[0][i].wp = wp;
			tp->cb[0][i].dp = dp;

			tp->c_pnd = IS_YES;
			tp->c_lck = IS_NO;

			return;
		}
	}

	tp->c_lck = IS_NO;

	(void) flush_error();

	LOGWARN(
		ERROR_SLIGHT, SUBSYSTEM,
		_("Failed to add callback event to queue because event queue is full")
	);
}