New upstream version 21.0.2+dfsg1

test/test-input/CMakeLists.txt

@@ -12,6 +12,10 @@ set(test-input_SOURCES
 	test-filter.c
 	test-input.c
 	test-sinewave.c
+	sync-async-source.c
+	sync-audio-buffering.c
+	sync-pair-vid.c
+	sync-pair-aud.c
 	test-random.c)
 
 add_library(test-input MODULE

test/test-input/sync-async-source.c

@@ -0,0 +1,143 @@
+#include <stdlib.h>
+#include <util/threading.h>
+#include <util/platform.h>
+#include <obs.h>
+
+struct async_sync_test {
+	obs_source_t *source;
+	os_event_t   *stop_signal;
+	pthread_t    thread;
+	bool         initialized;
+};
+
+/* middle C */
+static const double rate = 261.63/48000.0;
+
+#ifndef M_PI
+#define M_PI 3.1415926535897932384626433832795
+#endif
+
+#define M_PI_X2 M_PI*2
+
+static const char *ast_getname(void *unused)
+{
+	UNUSED_PARAMETER(unused);
+	return "Sync Test (Async Video/Audio Source)";
+}
+
+static void ast_destroy(void *data)
+{
+	struct async_sync_test *ast = data;
+
+	if (ast->initialized) {
+		os_event_signal(ast->stop_signal);
+		pthread_join(ast->thread, NULL);
+	}
+
+	os_event_destroy(ast->stop_signal);
+	bfree(ast);
+}
+
+static inline void fill_texture(uint32_t *pixels, uint32_t color)
+{
+	size_t x, y;
+
+	for (y = 0; y < 20; y++) {
+		for (x = 0; x < 20; x++) {
+			pixels[y*20 + x] = color;
+		}
+	}
+}
+
+static void *video_thread(void *data)
+{
+	struct async_sync_test *ast = data;
+
+	uint32_t sample_rate = audio_output_get_sample_rate(obs_get_audio());
+
+	uint32_t *pixels = bmalloc(20 * 20 * sizeof(uint32_t));
+	float    *samples = bmalloc(sample_rate * sizeof(float));
+	uint64_t cur_time = os_gettime_ns();
+	bool     whitelist = false;
+	double   cos_val = 0.0;
+	uint64_t start_time = cur_time;
+
+	struct obs_source_frame frame = {
+		.data     = {[0] = (uint8_t*)pixels},
+		.linesize = {[0] = 20*4},
+		.width    = 20,
+		.height   = 20,
+		.format   = VIDEO_FORMAT_BGRX
+	};
+	struct obs_source_audio audio = {
+		.speakers        = SPEAKERS_MONO,
+		.data            = {[0] = (uint8_t*)samples},
+		.samples_per_sec = sample_rate,
+		.frames          = sample_rate,
+		.format          = AUDIO_FORMAT_FLOAT
+	};
+
+	while (os_event_try(ast->stop_signal) == EAGAIN) {
+		fill_texture(pixels, whitelist ? 0xFFFFFFFF : 0xFF000000);
+
+		frame.timestamp = cur_time - start_time;
+		audio.timestamp = cur_time - start_time;
+
+		if (whitelist) {
+			for (size_t i = 0; i < sample_rate; i++) {
+				cos_val += rate * M_PI_X2;
+				if (cos_val > M_PI_X2)
+					cos_val -= M_PI_X2;
+
+				samples[i] = (float)(cos(cos_val) * 0.5);
+			}
+		} else {
+			for (size_t i = 0; i < sample_rate; i++)
+				samples[i] = 0.0f;
+		}
+
+		obs_source_output_video(ast->source, &frame);
+		obs_source_output_audio(ast->source, &audio);
+
+		os_sleepto_ns(cur_time += 1000000000);
+
+		whitelist = !whitelist;
+	}
+
+	bfree(pixels);
+	bfree(samples);
+
+	return NULL;
+}
+
+static void *ast_create(obs_data_t *settings, obs_source_t *source)
+{
+	struct async_sync_test *ast = bzalloc(sizeof(struct async_sync_test));
+	ast->source = source;
+
+	if (os_event_init(&ast->stop_signal, OS_EVENT_TYPE_MANUAL) != 0) {
+		ast_destroy(ast);
+		return NULL;
+	}
+
+	if (pthread_create(&ast->thread, NULL, video_thread, ast) != 0) {
+		ast_destroy(ast);
+		return NULL;
+	}
+
+	ast->initialized = true;
+
+	UNUSED_PARAMETER(settings);
+	UNUSED_PARAMETER(source);
+	return ast;
+}
+
+struct obs_source_info async_sync_test = {
+	.id           = "async_sync_test",
+	.type         = OBS_SOURCE_TYPE_INPUT,
+	.output_flags = OBS_SOURCE_ASYNC_VIDEO |
+	                OBS_SOURCE_AUDIO,
+	.get_name     = ast_getname,
+	.create       = ast_create,
+	.destroy      = ast_destroy,
+};

test/test-input/sync-audio-buffering.c

@@ -0,0 +1,200 @@
+#include <stdlib.h>
+#include <util/threading.h>
+#include <util/platform.h>
+#include <obs.h>
+
+struct buffering_async_sync_test {
+	obs_source_t *source;
+	os_event_t   *stop_signal;
+	pthread_t    thread;
+	bool         initialized;
+	bool         buffer_audio;
+};
+
+#define CYCLE_COUNT 7
+
+static const double aud_rates[CYCLE_COUNT] = {
+	220.00/48000.0, /* A */
+	233.08/48000.0, /* A# */
+	246.94/48000.0, /* B */
+	261.63/48000.0, /* C */
+	277.18/48000.0, /* C# */
+	293.67/48000.0, /* D */
+	311.13/48000.0, /* D# */
+};
+
+#define MAKE_COL_CHAN(x, y) (((0xFF / 7) * x) << (y * 8))
+#define MAKE_GRAYSCALE(x) \
+	(MAKE_COL_CHAN(x, 0) | \
+	 MAKE_COL_CHAN(x, 1) | \
+	 MAKE_COL_CHAN(x, 2))
+
+static const uint32_t vid_colors[CYCLE_COUNT] = {
+	0xFF000000,
+	0xFF000000 + MAKE_GRAYSCALE(1),
+	0xFF000000 + MAKE_GRAYSCALE(2),
+	0xFF000000 + MAKE_GRAYSCALE(3),
+	0xFF000000 + MAKE_GRAYSCALE(4),
+	0xFF000000 + MAKE_GRAYSCALE(5),
+	0xFF000000 + MAKE_GRAYSCALE(6),
+};
+
+#ifndef M_PI
+#define M_PI 3.1415926535897932384626433832795
+#endif
+
+#define M_PI_X2 M_PI*2
+
+static const char *bast_getname(void *unused)
+{
+	UNUSED_PARAMETER(unused);
+	return "Audio Buffering Sync Test (Async Video/Audio Source)";
+}
+
+static void bast_destroy(void *data)
+{
+	struct buffering_async_sync_test *bast = data;
+
+	if (bast->initialized) {
+		os_event_signal(bast->stop_signal);
+		pthread_join(bast->thread, NULL);
+	}
+
+	os_event_destroy(bast->stop_signal);
+	bfree(bast);
+}
+
+static inline void fill_texture(uint32_t *pixels, uint32_t color)
+{
+	size_t x, y;
+
+	for (y = 0; y < 20; y++) {
+		for (x = 0; x < 20; x++) {
+			pixels[y*20 + x] = color;
+		}
+	}
+}
+
+static void *video_thread(void *data)
+{
+	struct buffering_async_sync_test *bast = data;
+
+	uint32_t sample_rate = audio_output_get_sample_rate(obs_get_audio());
+
+	uint32_t *pixels = bmalloc(20 * 20 * sizeof(uint32_t));
+	float    *samples = bmalloc(sample_rate * sizeof(float));
+	uint64_t cur_time = os_gettime_ns();
+	int      cur_vid_pos = 0;
+	int      cur_aud_pos = 0;
+	double   cos_val = 0.0;
+	uint64_t start_time = cur_time;
+	bool     audio_buffering_enabled = false;
+
+	struct obs_source_frame frame = {
+		.data     = {[0] = (uint8_t*)pixels},
+		.linesize = {[0] = 20*4},
+		.width    = 20,
+		.height   = 20,
+		.format   = VIDEO_FORMAT_BGRX
+	};
+	struct obs_source_audio audio = {
+		.speakers        = SPEAKERS_MONO,
+		.data            = {[0] = (uint8_t*)samples},
+		.samples_per_sec = sample_rate,
+		.frames          = sample_rate / 4,
+		.format          = AUDIO_FORMAT_FLOAT
+	};
+
+	while (os_event_try(bast->stop_signal) == EAGAIN) {
+		fill_texture(pixels, vid_colors[cur_vid_pos]);
+
+		if (!audio_buffering_enabled && bast->buffer_audio) {
+			audio_buffering_enabled = true;
+			blog(LOG_DEBUG, "okay, buffering audio: now");
+
+			/* 1 second = 4 cycles when running at
+			 *            250ms per cycle */
+			cur_aud_pos -= 4;
+			if (cur_aud_pos < 0)
+				cur_aud_pos += CYCLE_COUNT;
+		}
+
+		/* should cause approximately 750 milliseconds of audio
+		 * buffering */
+		frame.timestamp = cur_time - start_time;
+		audio.timestamp = cur_time - start_time -
+			(audio_buffering_enabled ? 1000000000 : 0);
+
+		const double rate = aud_rates[cur_aud_pos];
+
+		for (size_t i = 0; i < sample_rate / 4; i++) {
+			cos_val += rate * M_PI_X2;
+			if (cos_val > M_PI_X2)
+				cos_val -= M_PI_X2;
+
+			samples[i] = (float)(cos(cos_val) * 0.5);
+		}
+
+		obs_source_output_video(bast->source, &frame);
+		obs_source_output_audio(bast->source, &audio);
+
+		os_sleepto_ns(cur_time += 250000000);
+
+		if (++cur_vid_pos == CYCLE_COUNT)
+			cur_vid_pos = 0;
+		if (++cur_aud_pos == CYCLE_COUNT)
+			cur_aud_pos = 0;
+	}
+
+	bfree(pixels);
+	bfree(samples);
+
+	return NULL;
+}
+
+static void bast_buffer_audio(void *data, obs_hotkey_id id,
+		obs_hotkey_t *hotkey, bool pressed)
+{
+	struct buffering_async_sync_test *bast = data;
+
+	UNUSED_PARAMETER(id);
+	UNUSED_PARAMETER(hotkey);
+
+	if (pressed)
+		bast->buffer_audio = true;
+}
+
+static void *bast_create(obs_data_t *settings, obs_source_t *source)
+{
+	struct buffering_async_sync_test *bast = bzalloc(sizeof(*bast));
+	bast->source = source;
+
+	if (os_event_init(&bast->stop_signal, OS_EVENT_TYPE_MANUAL) != 0) {
+		bast_destroy(bast);
+		return NULL;
+	}
+
+	if (pthread_create(&bast->thread, NULL, video_thread, bast) != 0) {
+		bast_destroy(bast);
+		return NULL;
+	}
+
+	obs_hotkey_register_source(source, "AudioBufferingSyncTest.Buffer",
+			"Buffer Audio", bast_buffer_audio, bast);
+
+	bast->initialized = true;
+
+	UNUSED_PARAMETER(settings);
+	UNUSED_PARAMETER(source);
+	return bast;
+}
+
+struct obs_source_info buffering_async_sync_test = {
+	.id           = "buffering_async_sync_test",
+	.type         = OBS_SOURCE_TYPE_INPUT,
+	.output_flags = OBS_SOURCE_ASYNC_VIDEO |
+	                OBS_SOURCE_AUDIO,
+	.get_name     = bast_getname,
+	.create       = bast_create,
+	.destroy      = bast_destroy,
+};

test/test-input/sync-pair-aud.c

@@ -0,0 +1,137 @@
+#include <math.h>
+#include <util/bmem.h>
+#include <util/threading.h>
+#include <util/platform.h>
+#include <obs.h>
+
+struct sync_pair_aud {
+	bool         initialized_thread;
+	pthread_t    thread;
+	os_event_t   *event;
+	obs_source_t *source;
+};
+
+/* middle C */
+static const double rate = 261.63/48000.0;
+
+#ifndef M_PI
+#define M_PI 3.1415926535897932384626433832795
+#endif
+
+#define M_PI_X2 M_PI*2
+
+extern uint64_t starting_time;
+
+static inline bool whitelist_time(uint64_t ts, uint64_t interval,
+		uint64_t fps_num, uint64_t fps_den)
+{
+	if (!starting_time)
+		return false;
+
+	uint64_t count = (ts - starting_time) / interval;
+	uint64_t sec = count * fps_den / fps_num;
+	return sec % 2 == 1;
+}
+
+static void *sync_pair_aud_thread(void *pdata)
+{
+	struct sync_pair_aud *spa = pdata;
+	uint32_t sample_rate = audio_output_get_sample_rate(obs_get_audio());
+	uint32_t frames = sample_rate / 100;
+	uint64_t last_time = obs_get_video_frame_time();
+	double cos_val = 0.0;
+	float *samples = malloc(frames * sizeof(float));
+
+	uint64_t interval = video_output_get_frame_time(obs_get_video());
+	const struct video_output_info *voi =
+		video_output_get_info(obs_get_video());
+	uint64_t fps_num = voi->fps_num;
+	uint64_t fps_den = voi->fps_den;
+
+	while (os_event_try(spa->event) == EAGAIN) {
+		if (!os_sleepto_ns(last_time += 10000000))
+			last_time = obs_get_video_frame_time();
+
+		for (uint64_t i = 0; i < frames; i++) {
+			uint64_t ts = last_time +
+				i * 1000000000ULL / sample_rate;
+
+			if (whitelist_time(ts, interval, fps_num, fps_den)) {
+				cos_val += rate * M_PI_X2;
+				if (cos_val > M_PI_X2)
+					cos_val -= M_PI_X2;
+
+				samples[i] = (float)(cos(cos_val) * 0.5);
+			} else {
+				samples[i] = 0.0f;
+			}
+		}
+
+		struct obs_source_audio data;
+		data.data[0] = (uint8_t*)samples;
+		data.frames = frames;
+		data.speakers = SPEAKERS_MONO;
+		data.samples_per_sec = sample_rate;
+		data.timestamp = last_time;
+		data.format = AUDIO_FORMAT_FLOAT;
+		obs_source_output_audio(spa->source, &data);
+	}
+
+	free(samples);
+
+	return NULL;
+}
+
+/* ------------------------------------------------------------------------- */
+
+static const char *sync_pair_aud_getname(void *unused)
+{
+	UNUSED_PARAMETER(unused);
+	return "Sync Test Pair (Audio)";
+}
+
+static void sync_pair_aud_destroy(void *data)
+{
+	struct sync_pair_aud *spa = data;
+
+	if (spa) {
+		if (spa->initialized_thread) {
+			void *ret;
+			os_event_signal(spa->event);
+			pthread_join(spa->thread, &ret);
+		}
+
+		os_event_destroy(spa->event);
+		bfree(spa);
+	}
+}
+
+static void *sync_pair_aud_create(obs_data_t *settings,
+		obs_source_t *source)
+{
+	struct sync_pair_aud *spa = bzalloc(sizeof(struct sync_pair_aud));
+	spa->source = source;
+
+	if (os_event_init(&spa->event, OS_EVENT_TYPE_MANUAL) != 0)
+		goto fail;
+	if (pthread_create(&spa->thread, NULL, sync_pair_aud_thread, spa) != 0)
+		goto fail;
+
+	spa->initialized_thread = true;
+
+	UNUSED_PARAMETER(settings);
+	return spa;
+
+fail:
+	sync_pair_aud_destroy(spa);
+	return NULL;
+}
+
+struct obs_source_info sync_audio = {
+	.id           = "sync_audio",
+	.type         = OBS_SOURCE_TYPE_INPUT,
+	.output_flags = OBS_SOURCE_AUDIO,
+	.get_name     = sync_pair_aud_getname,
+	.create       = sync_pair_aud_create,
+	.destroy      = sync_pair_aud_destroy,
+};

test/test-input/sync-pair-vid.c

@@ -0,0 +1,132 @@
+#include <stdlib.h>
+#include <util/threading.h>
+#include <util/platform.h>
+#include <graphics/graphics.h>
+#include <obs.h>
+
+struct sync_pair_vid {
+	obs_source_t *source;
+	gs_texture_t *tex;
+	gs_texture_t *white;
+	gs_texture_t *black;
+};
+
+uint64_t starting_time = 0;
+uint64_t last_frame = 0;
+
+static const char *sync_pair_vid_getname(void *unused)
+{
+	UNUSED_PARAMETER(unused);
+	return "Sync Test Pair (Video)";
+}
+
+static void sync_pair_vid_destroy(void *data)
+{
+	struct sync_pair_vid *spv = data;
+
+	obs_enter_graphics();
+	gs_texture_destroy(spv->tex);
+	gs_texture_destroy(spv->white);
+	gs_texture_destroy(spv->black);
+	obs_leave_graphics();
+
+	bfree(spv);
+}
+
+static inline void fill_texture(uint32_t *pixels, uint32_t pixel)
+{
+	size_t x, y;
+
+	for (y = 0; y < 32; y++) {
+		for (x = 0; x < 32; x++) {
+			pixels[y*32 + x] = pixel;
+		}
+	}
+}
+
+static void *sync_pair_vid_create(obs_data_t *settings, obs_source_t *source)
+{
+	struct sync_pair_vid *spv = bzalloc(sizeof(struct sync_pair_vid));
+	spv->source = source;
+
+	obs_enter_graphics();
+	spv->tex = gs_texture_create(32, 32, GS_RGBA, 1, NULL, GS_DYNAMIC);
+	spv->white = gs_texture_create(32, 32, GS_RGBA, 1, NULL, GS_DYNAMIC);
+	spv->black = gs_texture_create(32, 32, GS_RGBA, 1, NULL, GS_DYNAMIC);
+
+	uint8_t *ptr;
+	uint32_t linesize;
+	if (gs_texture_map(spv->white, &ptr, &linesize)) {
+		fill_texture((uint32_t*)ptr, 0xFFFFFFFF);
+		gs_texture_unmap(spv->white);
+	}
+	if (gs_texture_map(spv->black, &ptr, &linesize)) {
+		fill_texture((uint32_t*)ptr, 0xFF000000);
+		gs_texture_unmap(spv->black);
+	}
+
+	obs_leave_graphics();
+
+	return spv;
+}
+
+static inline bool whitelist_time(uint64_t ts, uint64_t interval,
+		uint64_t fps_num, uint64_t fps_den)
+{
+	if (!starting_time)
+		return false;
+
+	uint64_t count = (ts - starting_time) / interval;
+	uint64_t sec = count * fps_den / fps_num;
+	return sec % 2 == 1;
+}
+
+static void sync_pair_vid_render(void *data, gs_effect_t *effect)
+{
+	struct sync_pair_vid *spv = data;
+
+	uint64_t ts = obs_get_video_frame_time();
+	if (!starting_time)
+		starting_time = ts;
+
+	uint64_t interval = video_output_get_frame_time(obs_get_video());
+	const struct video_output_info *voi =
+		video_output_get_info(obs_get_video());
+	uint64_t fps_num = voi->fps_num;
+	uint64_t fps_den = voi->fps_den;
+
+	bool whitelist = whitelist_time(ts, interval, fps_num, fps_den);
+
+#if 0
+	if (last_frame != ts) {
+		uint8_t *ptr;
+		uint32_t linesize;
+		if (gs_texture_map(spv->tex, &ptr, &linesize)) {
+			fill_texture((uint32_t*)ptr, whitelist ? 0xFFFFFFFF : 0xFF000000);
+			gs_texture_unmap(spv->tex);
+		}
+		last_frame = ts;
+	}
+
+	obs_source_draw(spv->tex, 0, 0, 0, 0, 0);
+#else
+	obs_source_draw(whitelist ? spv->white : spv->black, 0, 0, 0, 0, 0);
+#endif
+}
+
+static uint32_t sync_pair_vid_size(void *data)
+{
+	return 32;
+}
+
+struct obs_source_info sync_video = {
+	.id           = "sync_video",
+	.type         = OBS_SOURCE_TYPE_INPUT,
+	.output_flags = OBS_SOURCE_VIDEO,
+	.get_name     = sync_pair_vid_getname,
+	.create       = sync_pair_vid_create,
+	.destroy      = sync_pair_vid_destroy,
+	.video_render = sync_pair_vid_render,
+	.get_width    = sync_pair_vid_size,
+	.get_height   = sync_pair_vid_size,
+};

test/test-input/test-input.c

@@ -5,11 +5,19 @@ OBS_DECLARE_MODULE()
 extern struct obs_source_info test_random;
 extern struct obs_source_info test_sinewave;
 extern struct obs_source_info test_filter;
+extern struct obs_source_info async_sync_test;
+extern struct obs_source_info buffering_async_sync_test;
+extern struct obs_source_info sync_video;
+extern struct obs_source_info sync_audio;
 
 bool obs_module_load(void)
 {
 	obs_register_source(&test_random);
 	obs_register_source(&test_sinewave);
 	obs_register_source(&test_filter);
+	obs_register_source(&async_sync_test);
+	obs_register_source(&buffering_async_sync_test);
+	obs_register_source(&sync_video);
+	obs_register_source(&sync_audio);
 	return true;
 }