diff --git a/libobs/build/libobs.core-output+.h.c b/libobs/build/libobs.core-output+.h.c index ad2821422e..0ef0052580 100644 --- a/libobs/build/libobs.core-output+.h.c +++ b/libobs/build/libobs.core-output+.h.c @@ -66,6 +66,7 @@ #include "libobs/obs-output-set-media-fields.c.h" #include "libobs/obs-output-settings-fields.c.h" #include "libobs/obs-output-size-getters-fields.c.h" +#include "libobs/obs-output-starting-queries.c.h" #include "libobs/obs-output-supported-codecs-fields.c.h" #include "libobs/obs-output-total-bytes-query.c.h" #include "libobs/obs-output-total-frames-fields.c.h" diff --git a/libobs/obs-output-starting-queries.c.h b/libobs/obs-output-starting-queries.c.h new file mode 100644 index 0000000000..b2eed67c64 --- /dev/null +++ b/libobs/obs-output-starting-queries.c.h @@ -0,0 +1,20 @@ +#include "libobs/build/libobs.pch.h" + +/* Defined later by obs-output.c.h in the core-output unity group. */ +static inline bool active(const struct obs_output *output); +static inline bool reconnecting(const struct obs_output *output); +static inline bool delay_active(const struct obs_output *output); + +/* Whether the output is using its encoders or about to: it is starting, + * running, reconnecting or delaying. */ +bool obs_output_needs_encoders(const struct obs_output *output) +{ + return active(output) || os_atomic_load_bool(&output->starting) || reconnecting(output) || delay_active(output); +} + +/* Whether the output is about to use its encoders: it is starting (a stream + * still connecting), reconnecting or delaying. */ +bool obs_output_starting(const struct obs_output *output) +{ + return os_atomic_load_bool(&output->starting) || reconnecting(output) || delay_active(output); +} diff --git a/libobs/obs-output.c.h b/libobs/obs-output.c.h index 9a82a080ec..33d84eff5f 100644 --- a/libobs/obs-output.c.h +++ b/libobs/obs-output.c.h @@ -1956,20 +1956,6 @@ static void *end_data_capture_thread(void *data) return NULL; } -/* Whether the output is using its encoders or about to: it is starting, - * running, reconnecting or delaying. */ -bool obs_output_needs_encoders(const struct obs_output *output) -{ - return active(output) || os_atomic_load_bool(&output->starting) || reconnecting(output) || delay_active(output); -} - -/* Whether the output is about to use its encoders: it is starting (a stream - * still connecting), reconnecting or delaying. */ -bool obs_output_starting(const struct obs_output *output) -{ - return os_atomic_load_bool(&output->starting) || reconnecting(output) || delay_active(output); -} - static void shutdown_unstarted_encoders(obs_output_t *output) { for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; i++) { diff --git a/test/cmocka/build/test-graph.json b/test/cmocka/build/test-graph.json index 8a3dffd34e..3b261a5d9a 100644 --- a/test/cmocka/build/test-graph.json +++ b/test/cmocka/build/test-graph.json @@ -10544,6 +10544,21 @@ "OBS::native-test-cmocka" ] }, + "test_output_starting_queries": { + "sources": [ + "test/cmocka/test_output_starting_queries.c" + ], + "libraries": [ + "OBS::libobs", + "OBS::caption", + "Uthash::Uthash", + "OBS::native-test-cmocka", + { + "name": "OBS::w32-pthreads", + "requires": "OS_WINDOWS" + } + ] + }, "test_output_stop_stats_steps": { "sources": [ "test/cmocka/test_output_stop_stats_steps.c", @@ -25445,6 +25460,12 @@ "${target}" ] }, + "test_output_starting_queries": { + "target": "test_output_starting_queries", + "command": [ + "${target}" + ] + }, "test_output_stop_stats_steps": { "target": "test_output_stop_stats_steps", "command": [ diff --git a/test/cmocka/test_output_starting_queries.c b/test/cmocka/test_output_starting_queries.c new file mode 100644 index 0000000000..429913e5d9 --- /dev/null +++ b/test/cmocka/test_output_starting_queries.c @@ -0,0 +1,85 @@ +/* C-source characterization of the private output predicates (#5229). + * Record atomic-load addresses, including skipped reads, using real layouts. + * A later Rust swap must relink this fixture through real private adapters; + * the unchanged failed-start/bind/reset tests also cover the live library. */ +#include +#include +#include +#include +#include +#include "obs-internal.h" + +static struct obs_output output; +static const volatile bool *expected_reads[4]; +static size_t expected_count, read_count; + +bool output_starting_recording_load_bool(const volatile bool *ptr); + +bool output_starting_recording_load_bool(const volatile bool *ptr) +{ + assert_true(read_count < expected_count); + assert_ptr_equal(ptr, expected_reads[read_count]); + read_count++; + return os_atomic_load_bool(ptr); +} + +/* A later swap selects external predicates and links the real atomic adapter + * to output_starting_recording_load_bool without changing these assertions. */ +#ifndef OUTPUT_STARTING_QUERIES_EXTERNAL +/* The three same-group helpers retain their original atomic-load behavior. */ +static inline bool active(const struct obs_output *out) +{ + return output_starting_recording_load_bool(&out->active); +} + +static inline bool reconnecting(const struct obs_output *out) +{ + return output_starting_recording_load_bool(&out->reconnecting); +} + +static inline bool delay_active(const struct obs_output *out) +{ + return output_starting_recording_load_bool(&out->delay_active); +} + +#define os_atomic_load_bool output_starting_recording_load_bool +#include "libobs/obs-output-starting-queries.c.h" +#undef os_atomic_load_bool +#endif + +static void flag_matrix(void **state) +{ + (void)state; + for (unsigned flags = 0; flags < 16; flags++) { + memset(&output, 0, sizeof(output)); + output.active = (flags & 1) != 0; + output.starting = (flags & 2) != 0; + output.reconnecting = (flags & 4) != 0; + output.delay_active = (flags & 8) != 0; + /* Irrelevant flags must never be read, even when they are true. */ + output.delay_capturing = true; + output.data_active = true; + const volatile bool *fields[] = {&output.active, &output.starting, &output.reconnecting, + &output.delay_active}; + unsigned char before[sizeof(output)]; + memcpy(before, &output, sizeof(output)); + for (unsigned first = 0; first < 2; first++) { + expected_count = read_count = 0; + for (unsigned i = first; i < 4; i++) { + expected_reads[expected_count++] = fields[i]; + if ((flags & (1U << i)) != 0) + break; + } + bool actual = first == 0 ? obs_output_needs_encoders(&output) : obs_output_starting(&output); + assert_int_equal(actual, (flags & (first == 0 ? 15U : 14U)) != 0); + assert_int_equal(read_count, expected_count); + assert_memory_equal(&output, before, sizeof(output)); + } + } +} + +int main(void) +{ + const struct CMUnitTest tests[] = {cmocka_unit_test(flag_matrix)}; + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/test/cmocka/tests.d/test_output_starting_queries.cmake b/test/cmocka/tests.d/test_output_starting_queries.cmake new file mode 100644 index 0000000000..d85a840326 --- /dev/null +++ b/test/cmocka/tests.d/test_output_starting_queries.cmake @@ -0,0 +1 @@ +# Registered in the canonical native test graph (test/cmocka/build/test-graph.json).