noobs 0.0.6

package/include/audio-monitoring/pulse/pulseaudio-wrapper.h

@@ -0,0 +1,212 @@
+/*
+Copyright (C) 2014 by Leonhard Oelke <leonhard@in-verted.de>
+Copyright (C) 2017 by Fabio Madia <admshao@gmail.com>
+
+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 <pulse/stream.h>
+#include <pulse/context.h>
+#include <pulse/introspect.h>
+
+#pragma once
+
+struct pulseaudio_default_output {
+	char *default_sink_name;
+};
+
+struct enum_cb {
+	obs_enum_audio_device_cb cb;
+	void *data;
+	int cont;
+};
+
+void get_default_id(char **id);
+
+bool devices_match(const char *id1, const char *id2);
+
+/**
+ * Initialize the pulseaudio mainloop and increase the reference count
+ */
+int_fast32_t pulseaudio_init();
+
+/**
+ * Unreference the pulseaudio mainloop, when the reference count reaches
+ * zero the mainloop will automatically be destroyed
+ */
+void pulseaudio_unref();
+
+/**
+ * Lock the mainloop
+ *
+ * In order to allow for multiple threads to use the same mainloop pulseaudio
+ * provides it's own locking mechanism. This function should be called before
+ * using any pulseaudio function that is in any way related to the mainloop or
+ * context.
+ *
+ * @note use of this function may cause deadlocks
+ *
+ * @warning do not use with pulseaudio_ wrapper functions
+ */
+void pulseaudio_lock();
+
+/**
+ * Unlock the mainloop
+ *
+ * @see pulseaudio_lock()
+ */
+void pulseaudio_unlock();
+
+/**
+ * Wait for events to happen
+ *
+ * This function should be called when waiting for an event to happen.
+ */
+void pulseaudio_wait();
+
+/**
+ * Wait for accept signal from calling thread
+ *
+ * This function tells the pulseaudio mainloop whether the data provided to
+ * the callback should be retained until the calling thread executes
+ * pulseaudio_accept()
+ *
+ * If wait_for_accept is 0 the function returns and the data is freed.
+ */
+void pulseaudio_signal(int wait_for_accept);
+
+/**
+ * Signal the waiting callback to return
+ *
+ * This function is used in conjunction with pulseaudio_signal()
+ */
+void pulseaudio_accept();
+
+/**
+ * Request source information
+ *
+ * The function will block until the operation was executed and the mainloop
+ * called the provided callback function.
+ *
+ * @return negative on error
+ *
+ * @note The function will block until the server context is ready.
+ *
+ * @warning call without active locks
+ */
+int_fast32_t pulseaudio_get_source_info_list(pa_source_info_cb_t cb, void *userdata);
+
+/**
+ * Request source information from a specific source
+ *
+ * The function will block until the operation was executed and the mainloop
+ * called the provided callback function.
+ *
+ * @param cb pointer to the callback function
+ * @param name the source name to get information for
+ * @param userdata pointer to userdata the callback will be called with
+ *
+ * @return negative on error
+ *
+ * @note The function will block until the server context is ready.
+ *
+ * @warning call without active locks
+ */
+int_fast32_t pulseaudio_get_source_info(pa_source_info_cb_t cb, const char *name, void *userdata);
+
+/**
+ * Request sink information
+ *
+ * The function will block until the operation was executed and the mainloop
+ * called the provided callback function.
+ *
+ * @return negative on error
+ *
+ * @note The function will block until the server context is ready.
+ *
+ * @warning call without active locks
+ */
+int_fast32_t pulseaudio_get_sink_info_list(pa_sink_info_cb_t cb, void *userdata);
+
+/**
+ * Request sink information from a specific sink
+ *
+ * The function will block until the operation was executed and the mainloop
+ * called the provided callback function.
+ *
+ * @param cb pointer to the callback function
+ * @param name the sink name to get information for
+ * @param userdata pointer to userdata the callback will be called with
+ *
+ * @return negative on error
+ *
+ * @note The function will block until the server context is ready.
+ *
+ * @warning call without active locks
+ */
+int_fast32_t pulseaudio_get_sink_info(pa_sink_info_cb_t cb, const char *name, void *userdata);
+
+/**
+ * Request server information
+ *
+ * The function will block until the operation was executed and the mainloop
+ * called the provided callback function.
+ *
+ * @return negative on error
+ *
+ * @note The function will block until the server context is ready.
+ *
+ * @warning call without active locks
+ */
+int_fast32_t pulseaudio_get_server_info(pa_server_info_cb_t cb, void *userdata);
+
+/**
+ * Create a new stream with the default properties
+ *
+ * @note The function will block until the server context is ready.
+ *
+ * @warning call without active locks
+ */
+pa_stream *pulseaudio_stream_new(const char *name, const pa_sample_spec *ss, const pa_channel_map *map);
+
+/**
+ * Connect to a pulseaudio playback stream
+ *
+ * @param s pa_stream to connect to. NULL for default
+ * @param attr pa_buffer_attr
+ * @param name Device name. NULL for default device
+ * @param flags pa_stream_flags_t
+ * @return negative on error
+ */
+int_fast32_t pulseaudio_connect_playback(pa_stream *s, const char *name, const pa_buffer_attr *attr,
+					 pa_stream_flags_t flags);
+
+/**
+ * Sets a callback function for when data can be written to the stream
+ *
+ * @param p pa_stream to connect to. NULL for default
+ * @param cb pa_stream_request_cb_t
+ * @param userdata pointer to userdata the callback will be called with
+ */
+void pulseaudio_write_callback(pa_stream *p, pa_stream_request_cb_t cb, void *userdata);
+
+/**
+ * Sets a callback function for when an underflow happen
+ *
+ * @param p pa_stream to connect to. NULL for default
+ * @param cb pa_stream_notify_cb_t
+ * @param userdata pointer to userdata the callback will be called with
+ */
+void pulseaudio_set_underflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

package/include/audio-monitoring/win32/wasapi-output.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <windows.h>
+#include <mmdeviceapi.h>
+#include <audioclient.h>
+
+#ifndef KSAUDIO_SPEAKER_2POINT1
+#define KSAUDIO_SPEAKER_2POINT1 (KSAUDIO_SPEAKER_STEREO | SPEAKER_LOW_FREQUENCY)
+#endif
+
+#define KSAUDIO_SPEAKER_SURROUND_AVUTIL (KSAUDIO_SPEAKER_STEREO | SPEAKER_FRONT_CENTER)
+
+#ifndef KSAUDIO_SPEAKER_4POINT1
+#define KSAUDIO_SPEAKER_4POINT1 (KSAUDIO_SPEAKER_SURROUND | SPEAKER_LOW_FREQUENCY)
+#endif
+
+#define safe_release(ptr)                          \
+	do {                                       \
+		if (ptr) {                         \
+			ptr->lpVtbl->Release(ptr); \
+		}                                  \
+	} while (false)

package/include/callback/calldata.h

@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.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.
+ */
+
+#pragma once
+
+#include <string.h>
+#include "../util/c99defs.h"
+#include "../util/bmem.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Procedure call data structure
+ *
+ *   This is used to store parameters (and return value) sent to/from signals,
+ * procedures, and callbacks.
+ */
+
+enum call_param_type {
+	CALL_PARAM_TYPE_VOID,
+	CALL_PARAM_TYPE_INT,
+	CALL_PARAM_TYPE_FLOAT,
+	CALL_PARAM_TYPE_BOOL,
+	CALL_PARAM_TYPE_PTR,
+	CALL_PARAM_TYPE_STRING
+};
+
+#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) */
+};
+
+typedef struct calldata calldata_t;
+
+static inline void calldata_init(struct calldata *data)
+{
+	memset(data, 0, sizeof(struct calldata));
+}
+
+static inline void calldata_clear(struct calldata *data);
+
+static inline void calldata_init_fixed(struct calldata *data, uint8_t *stack, size_t size)
+{
+	data->stack = stack;
+	data->capacity = size;
+	data->fixed = true;
+	data->size = 0;
+	calldata_clear(data);
+}
+
+static inline void calldata_free(struct calldata *data)
+{
+	if (!data->fixed)
+		bfree(data->stack);
+}
+
+EXPORT bool calldata_get_data(const calldata_t *data, const char *name, void *out, size_t size);
+EXPORT void calldata_set_data(calldata_t *data, const char *name, const void *in, size_t new_size);
+
+static inline void calldata_clear(struct calldata *data)
+{
+	if (data->stack) {
+		data->size = sizeof(size_t);
+		memset(data->stack, 0, sizeof(size_t));
+	}
+}
+
+static inline calldata_t *calldata_create(void)
+{
+	return (calldata_t *)bzalloc(sizeof(struct calldata));
+}
+
+static inline void calldata_destroy(calldata_t *cd)
+{
+	calldata_free(cd);
+	bfree(cd);
+}
+
+/* ------------------------------------------------------------------------- */
+/* NOTE: 'get' functions return true only if parameter exists, and is the
+ *       same type.  They return false otherwise. */
+
+static inline bool calldata_get_int(const calldata_t *data, const char *name, 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)
+{
+	return calldata_get_data(data, name, val, sizeof(*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)
+{
+	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);
+
+/* ------------------------------------------------------------------------- */
+/* call if you know your data is valid */
+
+static inline long long calldata_int(const calldata_t *data, const char *name)
+{
+	long long val = 0;
+	calldata_get_int(data, name, &val);
+	return val;
+}
+
+static inline double calldata_float(const calldata_t *data, const char *name)
+{
+	double val = 0.0;
+	calldata_get_float(data, name, &val);
+	return val;
+}
+
+static inline bool calldata_bool(const calldata_t *data, const char *name)
+{
+	bool val = false;
+	calldata_get_bool(data, name, &val);
+	return val;
+}
+
+static inline void *calldata_ptr(const calldata_t *data, const char *name)
+{
+	void *val = NULL;
+	calldata_get_ptr(data, name, &val);
+	return val;
+}
+
+static inline const char *calldata_string(const calldata_t *data, const char *name)
+{
+	const char *val = NULL;
+	calldata_get_string(data, name, &val);
+	return 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)
+{
+	calldata_set_data(data, name, &val, sizeof(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)
+{
+	calldata_set_data(data, name, &ptr, sizeof(ptr));
+}
+
+static inline void calldata_set_string(calldata_t *data, const char *name, const char *str)
+{
+	if (str)
+		calldata_set_data(data, name, str, strlen(str) + 1);
+	else
+		calldata_set_data(data, name, NULL, 0);
+}
+
+#ifdef __cplusplus
+}
+#endif

package/include/callback/decl.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.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.
+ */
+
+#pragma once
+
+#include "calldata.h"
+#include "../util/darray.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct decl_param {
+	char *name;
+	enum call_param_type type;
+	uint32_t flags;
+};
+
+static inline void decl_param_free(struct decl_param *param)
+{
+	if (param->name)
+		bfree(param->name);
+	memset(param, 0, sizeof(struct decl_param));
+}
+
+struct decl_info {
+	char *name;
+	const char *decl_string;
+	DARRAY(struct decl_param) params;
+};
+
+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);
+		da_free(decl->params);
+
+		bfree(decl->name);
+		memset(decl, 0, sizeof(struct decl_info));
+	}
+}
+
+EXPORT bool parse_decl_string(struct decl_info *decl, const char *decl_string);
+
+#ifdef __cplusplus
+}
+#endif

package/include/callback/proc.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.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.
+ */
+
+#pragma once
+
+#include "../util/c99defs.h"
+
+#include "calldata.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Procedure handler
+ *
+ *   This handler is used to allow access to one or more procedures that can be
+ *   added and called without having to have direct access to declarations or
+ *   procedure callback pointers.
+ */
+
+struct proc_handler;
+typedef struct proc_handler proc_handler_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);
+
+/**
+ * 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);
+
+#ifdef __cplusplus
+}
+#endif

package/include/callback/signal.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.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.
+ */
+
+#pragma once
+
+#include "../util/c99defs.h"
+
+#include "calldata.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Signal handler
+ *
+ *   This is used to create a signal handler which can broadcast events
+ * to one or more callbacks connected to a signal.
+ */
+
+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 *);
+
+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);
+
+static inline bool signal_handler_add_array(signal_handler_t *handler, const char **signal_decls)
+{
+	bool success = true;
+	if (!signal_decls)
+		return false;
+
+	while (*signal_decls)
+		if (!signal_handler_add(handler, *(signal_decls++)))
+			success = false;
+
+	return success;
+}
+
+EXPORT void signal_handler_connect(signal_handler_t *handler, 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);
+EXPORT void signal_handler_disconnect(signal_handler_t *handler, 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);
+EXPORT void signal_handler_disconnect_global(signal_handler_t *handler, 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);
+
+#ifdef __cplusplus
+}
+#endif

package/include/graphics/axisang.h

@@ -0,0 +1,65 @@
+/******************************************************************************
+    Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
+
+    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/>.
+******************************************************************************/
+
+#pragma once
+
+#include "../util/c99defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct quat;
+
+struct axisang {
+	union {
+		struct {
+			float x, y, z, w;
+		};
+		float ptr[4];
+	};
+};
+
+static inline void axisang_zero(struct axisang *dst)
+{
+	dst->x = 0.0f;
+	dst->y = 0.0f;
+	dst->z = 0.0f;
+	dst->w = 0.0f;
+}
+
+static inline void axisang_copy(struct axisang *dst, struct axisang *aa)
+{
+	dst->x = aa->x;
+	dst->y = aa->y;
+	dst->z = aa->z;
+	dst->w = aa->w;
+}
+
+static inline void axisang_set(struct axisang *dst, float x, float y, float z, float w)
+{
+	dst->x = x;
+	dst->y = y;
+	dst->z = z;
+	dst->w = w;
+}
+
+EXPORT void axisang_from_quat(struct axisang *dst, const struct quat *q);
+
+#ifdef __cplusplus
+}
+#endif