diff --git a/libobs/build/libobs.core+.h.c b/libobs/build/libobs.core+.h.c index 0cdb9512d5..a7e01daf43 100644 --- a/libobs/build/libobs.core+.h.c +++ b/libobs/build/libobs.core+.h.c @@ -2,6 +2,7 @@ #include "libobs/build/libobs.pch.h" +#include "libobs/obs-audio-info-queries.c.h" #include "libobs/obs-base-effect-fields.c.h" #include "libobs/obs-core-cmdline-fields.c.h" #include "libobs/obs-core-frame-interval-fields.c.h" @@ -56,6 +57,7 @@ #include "libobs/obs-ui-task-handler-fields.c.h" #include "libobs/obs-video-info-query-fields.c.h" #include "libobs/obs-video-level-queries.c.h" +#include "libobs/obs-video-stats-queries.c.h" #include "libobs/obs-weak-object-expired-fields.c.h" #include "libobs/obs-weak-object-identity-fields.c.h" #include "libobs/obs-weak-object-refs-fields.c.h" diff --git a/libobs/obs-audio-info-queries.c.h b/libobs/obs-audio-info-queries.c.h new file mode 100644 index 0000000000..1bf7442021 --- /dev/null +++ b/libobs/obs-audio-info-queries.c.h @@ -0,0 +1,41 @@ +#include "libobs/build/libobs.pch.h" + +bool obs_get_audio_info(struct obs_audio_info *oai) +{ + /* no core (before obs_startup): no audio (#2566) */ + if (!obs) + return false; + + struct obs_core_audio *audio = &obs->audio; + const struct audio_output_info *info; + + if (!oai || !audio->audio) + return false; + + info = audio_output_get_info(audio->audio); + + oai->samples_per_sec = info->samples_per_sec; + oai->speakers = info->speakers; + return true; +} + +bool obs_get_audio_info2(struct obs_audio_info2 *oai2) +{ + /* no core (before obs_startup): no audio (#3363) */ + if (!obs) + return false; + + struct obs_core_audio *audio = &obs->audio; + struct obs_audio_info oai; + + if (!obs_get_audio_info(&oai) || !oai2 || !audio->audio) { + return false; + } else { + oai2->samples_per_sec = oai.samples_per_sec; + oai2->speakers = oai.speakers; + oai2->fixed_buffering = audio->fixed_buffer; + oai2->max_buffering_ms = + (uint32_t)obs_core_setup_rules_buffer_ms(audio->max_buffering_ticks, oai2->samples_per_sec); + return true; + } +} diff --git a/libobs/obs-video-stats-queries.c.h b/libobs/obs-video-stats-queries.c.h new file mode 100644 index 0000000000..786df6840b --- /dev/null +++ b/libobs/obs-video-stats-queries.c.h @@ -0,0 +1,26 @@ +#include "libobs/build/libobs.pch.h" + +uint64_t obs_get_video_frame_time(void) +{ + return obs_video_stats_frame_time(&obs->video.stats); +} + +double obs_get_active_fps(void) +{ + return obs_video_stats_fps(&obs->video.stats); +} + +uint64_t obs_get_average_frame_time_ns(void) +{ + return obs_video_stats_avg_frame_time_ns(&obs->video.stats); +} + +uint32_t obs_get_total_frames(void) +{ + return obs_video_stats_total_frames(&obs->video.stats); +} + +uint32_t obs_get_lagged_frames(void) +{ + return obs_video_stats_lagged_frames(&obs->video.stats); +} diff --git a/libobs/obs.c.h b/libobs/obs.c.h index 1439afb8a3..adbc67e9ad 100644 --- a/libobs/obs.c.h +++ b/libobs/obs.c.h @@ -1703,46 +1703,6 @@ void obs_set_video_levels(float sdr_white_level, float hdr_nominal_peak_level) (double)hdr_nominal_peak_level, (double)video->hdr_nominal_peak_level); } -bool obs_get_audio_info(struct obs_audio_info *oai) -{ - /* no core (before obs_startup): no audio (#2566) */ - if (!obs) - return false; - - struct obs_core_audio *audio = &obs->audio; - const struct audio_output_info *info; - - if (!oai || !audio->audio) - return false; - - info = audio_output_get_info(audio->audio); - - oai->samples_per_sec = info->samples_per_sec; - oai->speakers = info->speakers; - return true; -} - -bool obs_get_audio_info2(struct obs_audio_info2 *oai2) -{ - /* no core (before obs_startup): no audio (#3363) */ - if (!obs) - return false; - - struct obs_core_audio *audio = &obs->audio; - struct obs_audio_info oai; - - if (!obs_get_audio_info(&oai) || !oai2 || !audio->audio) { - return false; - } else { - oai2->samples_per_sec = oai.samples_per_sec; - oai2->speakers = oai.speakers; - oai2->fixed_buffering = audio->fixed_buffer; - oai2->max_buffering_ms = - (uint32_t)obs_core_setup_rules_buffer_ms(audio->max_buffering_ticks, oai2->samples_per_sec); - return true; - } -} - const char *obs_get_latest_input_type_id(const char *unversioned_id) { struct obs_source_info *latest = NULL; @@ -2852,21 +2812,6 @@ profiler_name_store_t *obs_get_profiler_name_store(void) return obs->name_store; } -uint64_t obs_get_video_frame_time(void) -{ - return obs_video_stats_frame_time(&obs->video.stats); -} - -double obs_get_active_fps(void) -{ - return obs_video_stats_fps(&obs->video.stats); -} - -uint64_t obs_get_average_frame_time_ns(void) -{ - return obs_video_stats_avg_frame_time_ns(&obs->video.stats); -} - void *obs_obj_get_data(void *obj) { struct obs_context_data *context = obj; @@ -2937,16 +2882,6 @@ bool obs_set_audio_monitoring_device(const char *name, const char *id) return true; } -uint32_t obs_get_total_frames(void) -{ - return obs_video_stats_total_frames(&obs->video.stats); -} - -uint32_t obs_get_lagged_frames(void) -{ - return obs_video_stats_lagged_frames(&obs->video.stats); -} - /* An encoder that rescales on the GPU encodes from an encoder-only mix of * the same view (maybe_set_up_gpu_rescale() in obs-encoder.c), and that * mix's video_t counts its frames. The mixes are read under mixes_mutex: an diff --git a/test/cmocka/build/test-graph.json b/test/cmocka/build/test-graph.json index 2028cfc8f8..2c14211435 100644 --- a/test/cmocka/build/test-graph.json +++ b/test/cmocka/build/test-graph.json @@ -641,6 +641,28 @@ "OBS::native-test-cmocka" ] }, + "test_audio_info_queries": { + "sources": [ + "test/cmocka/test_audio_info_queries.c" + ], + "includes": [ + "libobs", + "deps/libcaption" + ], + "libraries": [ + "OBS::libobs", + "OBS::caption", + "Uthash::Uthash", + "OBS::native-test-cmocka", + { + "name": "OBS::w32-pthreads", + "requires": "OS_WINDOWS" + } + ], + "watch_inputs": [ + "libobs/obs-audio-info-queries.c.h" + ] + }, "test_audio_io_inlines": { "sources": [ "test/cmocka/test_audio_io_inlines.c" @@ -19822,6 +19844,28 @@ ], "sanitizers": "address,undefined" }, + "test_video_stats_queries": { + "sources": [ + "test/cmocka/test_video_stats_queries.c" + ], + "includes": [ + "libobs", + "deps/libcaption" + ], + "libraries": [ + "OBS::libobs", + "OBS::caption", + "Uthash::Uthash", + "OBS::native-test-cmocka", + { + "name": "OBS::w32-pthreads", + "requires": "OS_WINDOWS" + } + ], + "watch_inputs": [ + "libobs/obs-video-stats-queries.c.h" + ] + }, "test_video_stats_race": { "sources": [ "test/cmocka/test_video_stats_race.c" @@ -21591,6 +21635,14 @@ ] ] }, + "test_audio_info_queries": { + "target": "test_audio_info_queries", + "command": [ + "${target}" + ], + "suite": "core", + "timeout_seconds": 30 + }, "test_audio_io_inlines": { "target": "test_audio_io_inlines", "command": [ @@ -28291,6 +28343,14 @@ "${target}" ] }, + "test_video_stats_queries": { + "target": "test_video_stats_queries", + "command": [ + "${target}" + ], + "suite": "core", + "timeout_seconds": 30 + }, "test_video_stats_race": { "target": "test_video_stats_race" }, diff --git a/test/cmocka/test_audio_info_queries.c b/test/cmocka/test_audio_info_queries.c new file mode 100644 index 0000000000..dec687930b --- /dev/null +++ b/test/cmocka/test_audio_info_queries.c @@ -0,0 +1,254 @@ +/* Characterize obs_get_audio_info and obs_get_audio_info2 before the Rust + * swap (Refs #5169): the exact extracted bodies run against a stack core, with + * audio_output_get_info and the buffering-milliseconds helper replaced by + * probes that record every call. No OBS startup or audio thread is needed. + * The milliseconds arithmetic itself is pinned by test_core_setup_rules_ms_steps; + * here only its arguments, its call order and the uint32_t cast are pinned. */ +#include +#include +#include +#include +#include +#include +#include "libobs/build/libobs.pch.h" + +#if !__has_include("libobs/obs-audio-info-queries.c.h") +#error "audio-info query extraction seam is missing" +#endif + +/* The bodies under test read this core, not the library's hidden global. */ +struct obs_core *obs; + +const struct audio_output_info *probe_get_info(const audio_t *audio); +int probe_buffer_ms(int ticks, uint32_t samples_per_sec); +#define obs_get_audio_info info_body +#define obs_get_audio_info2 info2_body +#define audio_output_get_info probe_get_info +#define obs_core_setup_rules_buffer_ms probe_buffer_ms +#include "libobs/obs-audio-info-queries.c.h" +#undef obs_core_setup_rules_buffer_ms +#undef audio_output_get_info +#undef obs_get_audio_info2 +#undef obs_get_audio_info + +static struct obs_core core; +static struct audio_output_info output_info; + +/* A non-NULL handle the probe compares against; never dereferenced. */ +static char fake_audio_storage; +#define FAKE_AUDIO ((audio_t *)&fake_audio_storage) + +/* Call log: 'i' for audio_output_get_info, 'm' for the milliseconds helper. */ +static char calls[8]; +static size_t num_calls; +static int ms_ticks; +static uint32_t ms_rate; +static int ms_result; + +const struct audio_output_info *probe_get_info(const audio_t *audio) +{ + assert_ptr_equal(audio, FAKE_AUDIO); + assert_true(num_calls < sizeof(calls)); + calls[num_calls++] = 'i'; + return &output_info; +} + +int probe_buffer_ms(int ticks, uint32_t samples_per_sec) +{ + assert_true(num_calls < sizeof(calls)); + calls[num_calls++] = 'm'; + ms_ticks = ticks; + ms_rate = samples_per_sec; + return ms_result; +} + +static int setup(void **state) +{ + (void)state; + memset(&core, 0, sizeof(core)); + memset(&output_info, 0, sizeof(output_info)); + memset(calls, 0, sizeof(calls)); + num_calls = 0; + ms_ticks = -1; + ms_rate = 0; + ms_result = 0; + core.audio.audio = FAKE_AUDIO; + obs = &core; + return 0; +} + +static void assert_calls(const char *expected) +{ + assert_int_equal(num_calls, strlen(expected)); + assert_memory_equal(calls, expected, num_calls); +} + +#define SENTINEL_BYTE 0xA5 + +static void fill_sentinel(void *p, size_t size) +{ + memset(p, SENTINEL_BYTE, size); +} + +static void assert_sentinel(const void *p, size_t size) +{ + const unsigned char *bytes = p; + for (size_t i = 0; i < size; i++) + assert_int_equal(bytes[i], SENTINEL_BYTE); +} + +/* No core: both reject before forming &obs->audio and write nothing (#3363). */ +static void test_no_core(void **state) +{ + (void)state; + struct obs_audio_info oai; + struct obs_audio_info2 oai2; + obs = NULL; + + fill_sentinel(&oai, sizeof(oai)); + assert_false(info_body(&oai)); + assert_sentinel(&oai, sizeof(oai)); + + fill_sentinel(&oai2, sizeof(oai2)); + assert_false(info2_body(&oai2)); + assert_sentinel(&oai2, sizeof(oai2)); + + assert_false(info_body(NULL)); + assert_false(info2_body(NULL)); + assert_calls(""); +} + +static void test_info_null_output(void **state) +{ + (void)state; + assert_false(info_body(NULL)); + assert_calls(""); +} + +static void test_info_no_audio(void **state) +{ + (void)state; + struct obs_audio_info oai; + core.audio.audio = NULL; + fill_sentinel(&oai, sizeof(oai)); + assert_false(info_body(&oai)); + assert_sentinel(&oai, sizeof(oai)); + assert_calls(""); +} + +/* Success: one info read, rate and speakers copied, nothing else read. */ +static void test_info_copies_rate_and_speakers(void **state) +{ + (void)state; + static const struct { + uint32_t rate; + enum speaker_layout speakers; + } cases[] = { + {44100, SPEAKERS_STEREO}, + {48000, SPEAKERS_7POINT1}, + {0, SPEAKERS_UNKNOWN}, + {UINT32_MAX, SPEAKERS_MONO}, + }; + + for (size_t i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) { + struct obs_audio_info oai; + num_calls = 0; + output_info.samples_per_sec = cases[i].rate; + output_info.speakers = cases[i].speakers; + output_info.format = AUDIO_FORMAT_FLOAT_PLANAR; + fill_sentinel(&oai, sizeof(oai)); + assert_true(info_body(&oai)); + assert_int_equal(oai.samples_per_sec, cases[i].rate); + assert_int_equal(oai.speakers, cases[i].speakers); + assert_calls("i"); + } +} + +/* info2 calls obs_get_audio_info into its local first, even when the extended + * output is NULL; only then does it check oai2. */ +static void test_info2_null_output_still_reads_info(void **state) +{ + (void)state; + output_info.samples_per_sec = 48000; + output_info.speakers = SPEAKERS_STEREO; + assert_false(info2_body(NULL)); + assert_calls("i"); +} + +static void test_info2_no_audio(void **state) +{ + (void)state; + struct obs_audio_info2 oai2; + core.audio.audio = NULL; + fill_sentinel(&oai2, sizeof(oai2)); + assert_false(info2_body(&oai2)); + assert_sentinel(&oai2, sizeof(oai2)); + assert_calls(""); +} + +/* Success: rate and speakers from the info read, fixed_buffering from the core, + * then the milliseconds helper with the core's ticks and the copied rate. */ +static void test_info2_copies_all_fields(void **state) +{ + (void)state; + static const struct { + uint32_t rate; + enum speaker_layout speakers; + bool fixed; + int ticks; + int ms; + } cases[] = { + {48000, SPEAKERS_STEREO, false, 1, 21}, + {44100, SPEAKERS_5POINT1, true, 45, 1000}, + {96000, SPEAKERS_4POINT0, true, 0, 0}, + {8000, SPEAKERS_MONO, false, INT32_MAX, INT32_MAX}, + }; + + for (size_t i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) { + struct obs_audio_info2 oai2; + num_calls = 0; + output_info.samples_per_sec = cases[i].rate; + output_info.speakers = cases[i].speakers; + core.audio.fixed_buffer = cases[i].fixed; + core.audio.max_buffering_ticks = cases[i].ticks; + ms_result = cases[i].ms; + fill_sentinel(&oai2, sizeof(oai2)); + + assert_true(info2_body(&oai2)); + assert_int_equal(oai2.samples_per_sec, cases[i].rate); + assert_int_equal(oai2.speakers, cases[i].speakers); + assert_int_equal(oai2.fixed_buffering, cases[i].fixed); + assert_int_equal(oai2.max_buffering_ms, (uint32_t)cases[i].ms); + assert_int_equal(ms_ticks, cases[i].ticks); + assert_int_equal(ms_rate, cases[i].rate); + assert_calls("im"); + } +} + +/* The helper's int result is cast straight to uint32_t, negative included. */ +static void test_info2_casts_helper_result(void **state) +{ + (void)state; + struct obs_audio_info2 oai2; + output_info.samples_per_sec = 48000; + output_info.speakers = SPEAKERS_STEREO; + ms_result = -1; + assert_true(info2_body(&oai2)); + assert_int_equal(oai2.max_buffering_ms, UINT32_MAX); + assert_calls("im"); +} + +int main(void) +{ + const struct CMUnitTest tests[] = { + cmocka_unit_test_setup(test_no_core, setup), + cmocka_unit_test_setup(test_info_null_output, setup), + cmocka_unit_test_setup(test_info_no_audio, setup), + cmocka_unit_test_setup(test_info_copies_rate_and_speakers, setup), + cmocka_unit_test_setup(test_info2_null_output_still_reads_info, setup), + cmocka_unit_test_setup(test_info2_no_audio, setup), + cmocka_unit_test_setup(test_info2_copies_all_fields, setup), + cmocka_unit_test_setup(test_info2_casts_helper_result, setup), + }; + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/test/cmocka/test_video_stats_queries.c b/test/cmocka/test_video_stats_queries.c new file mode 100644 index 0000000000..462297fe53 --- /dev/null +++ b/test/cmocka/test_video_stats_queries.c @@ -0,0 +1,180 @@ +/* Characterize the five public video-statistics queries before the Rust swap + * (Refs #5171): obs_get_video_frame_time, obs_get_active_fps, + * obs_get_average_frame_time_ns, obs_get_total_frames and + * obs_get_lagged_frames. The exact extracted bodies run against stack cores; + * each must read its own field of obs->video.stats through the matching + * obs_video_stats_* helper, from whichever core obs points at, and release the + * stats mutex afterwards. A NULL core is outside the C contract. */ +#include +#include +#include +#include +#include +#include +#include "libobs/build/libobs.pch.h" + +#if !__has_include("libobs/obs-video-stats-queries.c.h") +#error "video-statistics query extraction seam is missing" +#endif + +/* The bodies under test read this core, not the library's hidden global. */ +struct obs_core *obs; + +#define obs_get_video_frame_time frame_time_body +#define obs_get_active_fps active_fps_body +#define obs_get_average_frame_time_ns avg_frame_time_body +#define obs_get_total_frames total_frames_body +#define obs_get_lagged_frames lagged_frames_body +#include "libobs/obs-video-stats-queries.c.h" +#undef obs_get_lagged_frames +#undef obs_get_total_frames +#undef obs_get_average_frame_time_ns +#undef obs_get_active_fps +#undef obs_get_video_frame_time + +static struct obs_core core_a, core_b; + +struct stats_values { + uint64_t frame_time_ns; + uint64_t avg_frame_time_ns; + double fps; + uint32_t total_frames; + uint32_t lagged_frames; +}; + +static void load(struct obs_core *core, const struct stats_values *v) +{ + core->video.stats.frame_time_ns = v->frame_time_ns; + core->video.stats.avg_frame_time_ns = v->avg_frame_time_ns; + core->video.stats.fps = v->fps; + core->video.stats.total_frames = v->total_frames; + core->video.stats.lagged_frames = v->lagged_frames; +} + +static void *trylock_thread(void *arg) +{ + pthread_mutex_t *mutex = arg; + int result = pthread_mutex_trylock(mutex); + if (result == 0) + pthread_mutex_unlock(mutex); + return (void *)(intptr_t)result; +} + +/* The stats mutex is free again after each query. */ +static void assert_unlocked(struct obs_core *core) +{ + pthread_t thread; + void *result = (void *)(intptr_t)-1; + assert_int_equal(pthread_create(&thread, NULL, trylock_thread, &core->video.stats.mutex), 0); + assert_int_equal(pthread_join(thread, &result), 0); + assert_int_equal((int)(intptr_t)result, 0); +} + +static void assert_queries(struct obs_core *core, const struct stats_values *v) +{ + obs = core; + assert_true(frame_time_body() == v->frame_time_ns); + assert_unlocked(core); + assert_true(active_fps_body() == v->fps); + assert_unlocked(core); + assert_true(avg_frame_time_body() == v->avg_frame_time_ns); + assert_unlocked(core); + assert_true(total_frames_body() == v->total_frames); + assert_unlocked(core); + assert_true(lagged_frames_body() == v->lagged_frames); + assert_unlocked(core); +} + +static int setup(void **state) +{ + (void)state; + memset(&core_a, 0, sizeof(core_a)); + memset(&core_b, 0, sizeof(core_b)); + assert_int_equal(obs_video_stats_init(&core_a.video.stats), 0); + assert_int_equal(obs_video_stats_init(&core_b.video.stats), 0); + return 0; +} + +static int teardown(void **state) +{ + (void)state; + obs_video_stats_destroy(&core_a.video.stats); + obs_video_stats_destroy(&core_b.video.stats); + obs = NULL; + return 0; +} + +/* A fresh core reports zero everywhere. */ +static void test_zeroed_stats(void **state) +{ + (void)state; + static const struct stats_values zero = {0}; + assert_queries(&core_a, &zero); +} + +/* Every query reads its own field: all five values are distinct. */ +static void test_each_query_reads_its_field(void **state) +{ + (void)state; + static const struct stats_values v = { + .frame_time_ns = 0x1122334455667788ULL, + .avg_frame_time_ns = 16666667ULL, + .fps = 59.94, + .total_frames = 123456u, + .lagged_frames = 7u, + }; + load(&core_a, &v); + assert_queries(&core_a, &v); +} + +/* Full-width values pass through unchanged (no narrowing or rounding). */ +static void test_boundary_values(void **state) +{ + (void)state; + static const struct stats_values v = { + .frame_time_ns = UINT64_MAX, + .avg_frame_time_ns = UINT64_MAX - 1, + .fps = 1e308, + .total_frames = UINT32_MAX, + .lagged_frames = UINT32_MAX - 1, + }; + load(&core_a, &v); + assert_queries(&core_a, &v); +} + +/* The queries follow the obs pointer: switching cores switches the values. */ +static void test_reads_current_core(void **state) +{ + (void)state; + static const struct stats_values a = {1, 2, 30.0, 4, 5}; + static const struct stats_values b = {10, 20, 0.5, 40, 50}; + load(&core_a, &a); + load(&core_b, &b); + assert_queries(&core_a, &a); + assert_queries(&core_b, &b); + assert_queries(&core_a, &a); +} + +/* Values written through the private setters are the ones read back. */ +static void test_reads_setter_writes(void **state) +{ + (void)state; + obs_video_stats_set_frame_time(&core_a.video.stats, 1000); + obs_video_stats_set_timing(&core_a.video.stats, 29.97, 33366700ULL); + obs_video_stats_add_frames(&core_a.video.stats, 10, 3); + obs_video_stats_add_frames(&core_a.video.stats, 5, 1); + static const struct stats_values v = {1000, 33366700ULL, 29.97, 15, 4}; + assert_queries(&core_a, &v); +} + +int main(void) +{ + const struct CMUnitTest tests[] = { + cmocka_unit_test_setup_teardown(test_zeroed_stats, setup, teardown), + cmocka_unit_test_setup_teardown(test_each_query_reads_its_field, setup, teardown), + cmocka_unit_test_setup_teardown(test_boundary_values, setup, teardown), + cmocka_unit_test_setup_teardown(test_reads_current_core, setup, teardown), + cmocka_unit_test_setup_teardown(test_reads_setter_writes, setup, teardown), + }; + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/test/cmocka/tests.d/test_audio_info_queries.cmake b/test/cmocka/tests.d/test_audio_info_queries.cmake new file mode 100644 index 0000000000..b420a62916 --- /dev/null +++ b/test/cmocka/tests.d/test_audio_info_queries.cmake @@ -0,0 +1 @@ +# Registered once in build/test-graph.json. diff --git a/test/cmocka/tests.d/test_video_stats_queries.cmake b/test/cmocka/tests.d/test_video_stats_queries.cmake new file mode 100644 index 0000000000..b420a62916 --- /dev/null +++ b/test/cmocka/tests.d/test_video_stats_queries.cmake @@ -0,0 +1 @@ +# Registered once in build/test-graph.json.