static void test_init_destroy_stream(void) { int r; cubeb * ctx; cubeb_stream * stream; cubeb_stream_params params; BEGIN_TEST r = cubeb_init(&ctx, "test_sanity"); assert(r == 0 && ctx); params.format = STREAM_FORMAT; params.rate = STREAM_RATE; params.channels = STREAM_CHANNELS; r = cubeb_stream_init(ctx, &stream, "test", params, STREAM_LATENCY, test_data_callback, test_state_callback, &dummy); assert(r == 0 && stream); cubeb_stream_destroy(stream); cubeb_destroy(ctx); END_TEST }
static void test_init_destroy_multiple_streams(void) { size_t i; int r; cubeb * ctx; cubeb_stream * stream[8]; cubeb_stream_params params; BEGIN_TEST; r = cubeb_init(&ctx, "test_sanity"); assert(r == 0 && ctx); params.format = STREAM_FORMAT; params.rate = STREAM_RATE; params.channels = STREAM_CHANNELS; for (i = 0; i < ARRAY_LENGTH(stream); ++i) { r = cubeb_stream_init(ctx, &stream[i], "test", params, STREAM_LATENCY, test_data_callback, test_state_callback, &dummy); assert(r == 0); assert(stream[i]); } for (i = 0; i < ARRAY_LENGTH(stream); ++i) { cubeb_stream_destroy(stream[i]); } cubeb_destroy(ctx); END_TEST; }
static void test_configure_stream(void) { int r; cubeb * ctx; cubeb_stream * stream; cubeb_stream_params params; BEGIN_TEST; r = cubeb_init(&ctx, "test_sanity"); assert(r == 0 && ctx); params.format = STREAM_FORMAT; params.rate = STREAM_RATE; params.channels = 2; // panning r = cubeb_stream_init(ctx, &stream, "test", params, STREAM_LATENCY, test_data_callback, test_state_callback, &dummy); assert(r == 0 && stream); r = cubeb_stream_set_volume(stream, 1.0f); assert(r == 0 || r == CUBEB_ERROR_NOT_SUPPORTED); r = cubeb_stream_set_panning(stream, 0.0f); assert(r == 0 || r == CUBEB_ERROR_NOT_SUPPORTED); cubeb_stream_destroy(stream); cubeb_destroy(ctx); END_TEST; }
static void test_context_variables(void) { int r; cubeb * ctx; uint32_t value; cubeb_stream_params params; BEGIN_TEST; r = cubeb_init(&ctx, "test_context_variables"); assert(r == 0 && ctx); params.channels = STREAM_CHANNELS; params.format = STREAM_FORMAT; params.rate = STREAM_RATE; r = cubeb_get_min_latency(ctx, params, &value); assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED); if (r == CUBEB_OK) { assert(value > 0); } r = cubeb_get_preferred_sample_rate(ctx, &value); assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED); if (r == CUBEB_OK) { assert(value > 0); } cubeb_destroy(ctx); END_TEST; }
int main(int /*argc*/, char * /*argv*/[]) { #ifdef CUBEB_GECKO_BUILD ScopedXPCOM xpcom("test_duplex"); #endif cubeb *ctx; cubeb_stream *stream; cubeb_stream_params input_params; cubeb_stream_params output_params; int r; user_state stream_state = { false }; uint32_t latency_frames = 0; r = cubeb_init(&ctx, "Cubeb duplex example"); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb library\n"); return r; } /* This test needs an available input device, skip it if this host does not * have one. */ if (!has_available_input_device(ctx)) { return 0; } /* typical user-case: mono input, stereo output, low latency. */ input_params.format = STREAM_FORMAT; input_params.rate = 48000; input_params.channels = 1; output_params.format = STREAM_FORMAT; output_params.rate = 48000; output_params.channels = 2; r = cubeb_get_min_latency(ctx, output_params, &latency_frames); if (r != CUBEB_OK) { fprintf(stderr, "Could not get minimal latency\n"); return r; } r = cubeb_stream_init(ctx, &stream, "Cubeb duplex", NULL, &input_params, NULL, &output_params, latency_frames, data_cb, state_cb, &stream_state); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb stream\n"); return r; } cubeb_stream_start(stream); delay(500); cubeb_stream_stop(stream); cubeb_stream_destroy(stream); cubeb_destroy(ctx); assert(stream_state.seen_noise); return CUBEB_OK; }
int main(int argc, char * argv[]) { cubeb * ctx = NULL; int rv; uint32_t max_channels; uint32_t preferred_rate; uint32_t latency_ms; rv = cubeb_init(&ctx, "Cubeb audio test"); assert(rv == CUBEB_OK && "Cubeb init failed."); rv = cubeb_get_max_channel_count(ctx, &max_channels); assert(rv == CUBEB_OK && "Could not query the max channe count."); assert(max_channels > 0 && "Invalid max channel count."); rv = cubeb_get_preferred_sample_rate(ctx, &preferred_rate); assert(rv == CUBEB_OK && "Could not query the preferred sample rate."); assert(preferred_rate && "Invalid preferred sample rate."); cubeb_stream_params params = { CUBEB_SAMPLE_FLOAT32NE, preferred_rate, max_channels }; rv = cubeb_get_min_latency(ctx, params, &latency_ms); assert(rv == CUBEB_OK && "Could not query the minimal latency."); assert(latency_ms && "Invalid minimal latency."); cubeb_destroy(ctx); return EXIT_SUCCESS; }
static void test_init_start_stop_destroy_multiple_streams(int early, int delay_ms) { int i; int r; cubeb * ctx; cubeb_stream * stream[8]; cubeb_stream_params params; BEGIN_TEST r = cubeb_init(&ctx, "test_sanity"); assert(r == 0 && ctx); params.format = STREAM_FORMAT; params.rate = STREAM_RATE; params.channels = STREAM_CHANNELS; for (i = 0; i < 8; ++i) { r = cubeb_stream_init(ctx, &stream[i], "test", params, STREAM_LATENCY, test_data_callback, test_state_callback, &dummy); assert(r == 0); assert(stream[i]); if (early) { r = cubeb_stream_start(stream[i]); assert(r == 0); } } if (!early) { for (i = 0; i < 8; ++i) { r = cubeb_stream_start(stream[i]); assert(r == 0); } } if (delay_ms) { delay(delay_ms); } if (!early) { for (i = 0; i < 8; ++i) { r = cubeb_stream_stop(stream[i]); assert(r == 0); } } for (i = 0; i < 8; ++i) { if (early) { r = cubeb_stream_stop(stream[i]); assert(r == 0); } cubeb_stream_destroy(stream[i]); } cubeb_destroy(ctx); END_TEST }
cubeb* GetCubebContextUnlocked() { sMutex.AssertCurrentThreadOwns(); if (sCubebState != CubebState::Uninitialized) { // If we have already passed the initialization point (below), just return // the current context, which may be null (e.g., after error or shutdown.) return sCubebContext; } if (!sBrandName && NS_IsMainThread()) { InitBrandName(); } else { NS_WARNING_ASSERTION( sBrandName, "Did not initialize sbrandName, and not on the main thread?"); } int rv = cubeb_init(&sCubebContext, sBrandName); NS_WARNING_ASSERTION(rv == CUBEB_OK, "Could not get a cubeb context."); sCubebState = (rv == CUBEB_OK) ? CubebState::Initialized : CubebState::Uninitialized; if (MOZ_LOG_TEST(gCubebLog, LogLevel::Verbose)) { cubeb_set_log_callback(CUBEB_LOG_VERBOSE, CubebLogCallback); } else if (MOZ_LOG_TEST(gCubebLog, LogLevel::Error)) { cubeb_set_log_callback(CUBEB_LOG_NORMAL, CubebLogCallback); } return sCubebContext; }
static cubeb* GetCubebContext() { MutexAutoLock lock(*gAudioPrefsLock); if (gCubebContext || cubeb_init(&gCubebContext, "AudioStream") == CUBEB_OK) { return gCubebContext; } NS_WARNING("cubeb_init failed"); return nullptr; }
cubeb* GetCubebContextUnlocked() { sMutex.AssertCurrentThreadOwns(); if (sCubebContext || cubeb_init(&sCubebContext, "CubebUtils") == CUBEB_OK) { return sCubebContext; } NS_WARNING("cubeb_init failed"); return nullptr; }
/*static*/ cubeb* AudioStream::GetCubebContextUnlocked() { sMutex.AssertCurrentThreadOwns(); if (sCubebContext || cubeb_init(&sCubebContext, "AudioStream") == CUBEB_OK) { return sCubebContext; } NS_WARNING("cubeb_init failed"); return nullptr; }
int run_test(int num_channels, int sampling_rate, int is_float) { int r = CUBEB_OK; cubeb *ctx = NULL; synth_state* synth = NULL; cubeb_stream *stream = NULL; const char * backend_id = NULL; r = cubeb_init(&ctx, "Cubeb audio test: channels"); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb library\n"); goto cleanup; } backend_id = cubeb_get_backend_id(ctx); if ((is_float && !supports_float32(backend_id)) || (!is_float && !supports_int16(backend_id)) || !supports_channel_count(backend_id, num_channels)) { /* don't treat this as a test failure. */ goto cleanup; } fprintf(stderr, "Testing %d channel(s), %d Hz, %s (%s)\n", num_channels, sampling_rate, is_float ? "float" : "short", cubeb_get_backend_id(ctx)); cubeb_stream_params params; params.format = is_float ? CUBEB_SAMPLE_FLOAT32NE : CUBEB_SAMPLE_S16NE; params.rate = sampling_rate; params.channels = num_channels; synth = synth_create(params.channels, params.rate); if (synth == NULL) { fprintf(stderr, "Out of memory\n"); goto cleanup; } r = cubeb_stream_init(ctx, &stream, "test tone", NULL, NULL, NULL, ¶ms, 4096, is_float ? data_cb_float : data_cb_short, state_cb_audio, synth); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb stream: %d\n", r); goto cleanup; } cubeb_stream_start(stream); delay(200); cubeb_stream_stop(stream); cleanup: cubeb_stream_destroy(stream); cubeb_destroy(ctx); synth_destroy(synth); return r; }
static void test_drain(void) { int r; cubeb * ctx; cubeb_stream * stream; cubeb_stream_params params; uint64_t position; BEGIN_TEST; total_frames_written = 0; r = cubeb_init(&ctx, "test_sanity"); assert(r == 0 && ctx); params.format = STREAM_FORMAT; params.rate = STREAM_RATE; params.channels = STREAM_CHANNELS; r = cubeb_stream_init(ctx, &stream, "test", params, STREAM_LATENCY, test_drain_data_callback, test_drain_state_callback, &dummy); assert(r == 0 && stream); r = cubeb_stream_start(stream); assert(r == 0); delay(500); do_drain = 1; for (;;) { r = cubeb_stream_get_position(stream, &position); assert(r == 0); if (got_drain) { break; } else { assert(position <= total_frames_written); } delay(500); } r = cubeb_stream_get_position(stream, &position); assert(r == 0); assert(got_drain); // Really, we should be able to rely on position reaching our final written frame, but // for now let's make sure it doesn't continue beyond that point. //assert(position <= total_frames_written); cubeb_stream_destroy(stream); cubeb_destroy(ctx); END_TEST; }
TEST(cubeb, duplex) { cubeb *ctx; cubeb_stream *stream; cubeb_stream_params input_params; cubeb_stream_params output_params; int r; user_state_duplex stream_state = { false }; uint32_t latency_frames = 0; r = cubeb_init(&ctx, "Cubeb duplex example", NULL); ASSERT_EQ(r, CUBEB_OK) << "Error initializing cubeb library"; std::unique_ptr<cubeb, decltype(&cubeb_destroy)> cleanup_cubeb_at_exit(ctx, cubeb_destroy); /* This test needs an available input device, skip it if this host does not * have one. */ if (!has_available_input_device(ctx)) { return; } /* typical user-case: mono input, stereo output, low latency. */ input_params.format = STREAM_FORMAT; input_params.rate = 48000; input_params.channels = 1; input_params.layout = CUBEB_LAYOUT_MONO; output_params.format = STREAM_FORMAT; output_params.rate = 48000; output_params.channels = 2; output_params.layout = CUBEB_LAYOUT_STEREO; r = cubeb_get_min_latency(ctx, output_params, &latency_frames); ASSERT_EQ(r, CUBEB_OK) << "Could not get minimal latency"; r = cubeb_stream_init(ctx, &stream, "Cubeb duplex", NULL, &input_params, NULL, &output_params, latency_frames, data_cb_duplex, state_cb_duplex, &stream_state); ASSERT_EQ(r, CUBEB_OK) << "Error initializing cubeb stream"; std::unique_ptr<cubeb_stream, decltype(&cubeb_stream_destroy)> cleanup_stream_at_exit(stream, cubeb_stream_destroy); cubeb_stream_start(stream); delay(500); cubeb_stream_stop(stream); ASSERT_TRUE(stream_state.seen_audio); }
TEST(cubeb, record) { if (cubeb_set_log_callback(CUBEB_LOG_DISABLED, nullptr /*print_log*/) != CUBEB_OK) { printf("Set log callback failed\n"); } cubeb *ctx; cubeb_stream *stream; cubeb_stream_params params; int r; user_state_record stream_state = { false }; r = cubeb_init(&ctx, "Cubeb record example"); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb library\n"); ASSERT_EQ(r, CUBEB_OK); } /* This test needs an available input device, skip it if this host does not * have one. */ if (!has_available_input_device(ctx)) { return; } params.format = STREAM_FORMAT; params.rate = SAMPLE_FREQUENCY; params.channels = 1; params.layout = CUBEB_LAYOUT_MONO; r = cubeb_stream_init(ctx, &stream, "Cubeb record (mono)", NULL, ¶ms, NULL, nullptr, 4096, data_cb_record, state_cb_record, &stream_state); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb stream\n"); ASSERT_EQ(r, CUBEB_OK); } cubeb_stream_start(stream); delay(500); cubeb_stream_stop(stream); cubeb_stream_destroy(stream); cubeb_destroy(ctx); #ifdef __linux__ // user callback does not arrive in Linux, silence the error printf("Check is disabled in Linux\n"); #else ASSERT_TRUE(stream_state.seen_audio); #endif }
static void test_init_destroy_context(void) { int r; cubeb * ctx; BEGIN_TEST r = cubeb_init(&ctx, "test_sanity"); assert(r == 0 && ctx); cubeb_destroy(ctx); END_TEST }
int main(int argc, char * argv[]) { #ifdef CUBEB_GECKO_BUILD ScopedXPCOM xpcom("test_latency"); #endif cubeb * ctx = NULL; int r; uint32_t max_channels; uint32_t preferred_rate; uint32_t latency_ms; LOG("latency_test start"); r = cubeb_init(&ctx, "Cubeb audio test"); assert(r == CUBEB_OK && "Cubeb init failed."); LOG("cubeb_init ok"); r = cubeb_get_max_channel_count(ctx, &max_channels); assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED); if (r == CUBEB_OK) { assert(max_channels > 0 && "Invalid max channel count."); LOG("cubeb_get_max_channel_count ok"); } r = cubeb_get_preferred_sample_rate(ctx, &preferred_rate); assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED); if (r == CUBEB_OK) { assert(preferred_rate > 0 && "Invalid preferred sample rate."); LOG("cubeb_get_preferred_sample_rate ok"); } cubeb_stream_params params = { CUBEB_SAMPLE_FLOAT32NE, preferred_rate, max_channels }; r = cubeb_get_min_latency(ctx, params, &latency_ms); assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED); if (r == CUBEB_OK) { assert(latency_ms > 0 && "Invalid minimal latency."); LOG("cubeb_get_min_latency ok"); } cubeb_destroy(ctx); LOG("cubeb_destroy ok"); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { #ifdef CUBEB_GECKO_BUILD ScopedXPCOM xpcom("test_record"); #endif cubeb *ctx; cubeb_stream *stream; cubeb_stream_params params; int r; user_state stream_state = { false }; r = cubeb_init(&ctx, "Cubeb record example"); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb library\n"); return r; } /* This test needs an available input device, skip it if this host does not * have one. */ if (!has_available_input_device(ctx)) { return 0; } params.format = STREAM_FORMAT; params.rate = SAMPLE_FREQUENCY; params.channels = 1; r = cubeb_stream_init(ctx, &stream, "Cubeb record (mono)", NULL, ¶ms, NULL, nullptr, 250, data_cb, state_cb, &stream_state); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb stream\n"); return r; } cubeb_stream_start(stream); delay(500); cubeb_stream_stop(stream); cubeb_stream_destroy(stream); cubeb_destroy(ctx); assert(stream_state.seen_noise); return CUBEB_OK; }
static void test_basic_stream_operations(void) { int r; cubeb * ctx; cubeb_stream * stream; cubeb_stream_params params; uint64_t position; BEGIN_TEST r = cubeb_init(&ctx, "test_sanity"); assert(r == 0 && ctx); params.format = STREAM_FORMAT; params.rate = STREAM_RATE; params.channels = STREAM_CHANNELS; r = cubeb_stream_init(ctx, &stream, "test", params, STREAM_LATENCY, test_data_callback, test_state_callback, &dummy); assert(r == 0 && stream); /* position and volume before stream has started */ r = cubeb_stream_get_position(stream, &position); assert(r == 0 && position == 0); r = cubeb_stream_start(stream); assert(r == 0); /* position and volume after while stream running */ r = cubeb_stream_get_position(stream, &position); assert(r == 0); r = cubeb_stream_stop(stream); assert(r == 0); /* position and volume after stream has stopped */ r = cubeb_stream_get_position(stream, &position); assert(r == 0); cubeb_stream_destroy(stream); cubeb_destroy(ctx); END_TEST }
TEST(cubeb, record) { cubeb *ctx; cubeb_stream *stream; cubeb_stream_params params; int r; user_state_record stream_state = { false }; r = cubeb_init(&ctx, "Cubeb record example"); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb library\n"); ASSERT_EQ(r, CUBEB_OK); } /* This test needs an available input device, skip it if this host does not * have one. */ if (!has_available_input_device(ctx)) { return; } params.format = STREAM_FORMAT; params.rate = SAMPLE_FREQUENCY; params.channels = 1; r = cubeb_stream_init(ctx, &stream, "Cubeb record (mono)", NULL, ¶ms, NULL, nullptr, 4096, data_cb_record, state_cb_record, &stream_state); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb stream\n"); ASSERT_EQ(r, CUBEB_OK); } cubeb_stream_start(stream); delay(500); cubeb_stream_stop(stream); cubeb_stream_destroy(stream); cubeb_destroy(ctx); ASSERT_TRUE(stream_state.seen_noise); }
static void test_init_destroy_multiple_contexts(void) { int i; int r; cubeb * ctx[4]; BEGIN_TEST for (i = 0; i < 4; ++i) { r = cubeb_init(&ctx[i], NULL); assert(r == 0 && ctx[i]); } /* destroy in a different order */ cubeb_destroy(ctx[2]); cubeb_destroy(ctx[0]); cubeb_destroy(ctx[3]); cubeb_destroy(ctx[1]); END_TEST }
static void test_init_destroy_context(void) { int r; cubeb * ctx; char const* backend_id; BEGIN_TEST; r = cubeb_init(&ctx, "test_sanity"); assert(r == 0 && ctx); backend_id = cubeb_get_backend_id(ctx); assert(backend_id); fprintf(stderr, "Backend: %s\n", backend_id); cubeb_destroy(ctx); END_TEST; }
static void test_init_destroy_multiple_contexts_and_streams(void) { size_t i, j; int r; cubeb * ctx[2]; cubeb_stream * stream[8]; cubeb_stream_params params; size_t streams_per_ctx = ARRAY_LENGTH(stream) / ARRAY_LENGTH(ctx); assert(ARRAY_LENGTH(ctx) * streams_per_ctx == ARRAY_LENGTH(stream)); BEGIN_TEST; params.format = STREAM_FORMAT; params.rate = STREAM_RATE; params.channels = STREAM_CHANNELS; for (i = 0; i < ARRAY_LENGTH(ctx); ++i) { r = cubeb_init(&ctx[i], "test_sanity"); assert(r == 0 && ctx[i]); for (j = 0; j < streams_per_ctx; ++j) { r = cubeb_stream_init(ctx[i], &stream[i * streams_per_ctx + j], "test", params, STREAM_LATENCY, test_data_callback, test_state_callback, &dummy); assert(r == 0); assert(stream[i * streams_per_ctx + j]); } } for (i = 0; i < ARRAY_LENGTH(ctx); ++i) { for (j = 0; j < streams_per_ctx; ++j) { cubeb_stream_destroy(stream[i * streams_per_ctx + j]); } cubeb_destroy(ctx[i]); } END_TEST; }
static void test_init_destroy_multiple_contexts(void) { size_t i; int r; cubeb * ctx[4]; int order[4] = {2, 0, 3, 1}; assert(ARRAY_LENGTH(ctx) == ARRAY_LENGTH(order)); BEGIN_TEST; for (i = 0; i < ARRAY_LENGTH(ctx); ++i) { r = cubeb_init(&ctx[i], NULL); assert(r == 0 && ctx[i]); } /* destroy in a different order */ for (i = 0; i < ARRAY_LENGTH(ctx); ++i) { cubeb_destroy(ctx[order[i]]); } END_TEST; }
static void test_init_destroy_multiple_contexts_and_streams(void) { int i, j; int r; cubeb * ctx[2]; cubeb_stream * stream[8]; cubeb_stream_params params; BEGIN_TEST params.format = STREAM_FORMAT; params.rate = STREAM_RATE; params.channels = STREAM_CHANNELS; for (i = 0; i < 2; ++i) { r = cubeb_init(&ctx[i], "test_sanity"); assert(r == 0 && ctx[i]); for (j = 0; j < 4; ++j) { r = cubeb_stream_init(ctx[i], &stream[i * 4 + j], "test", params, STREAM_LATENCY, test_data_callback, test_state_callback, &dummy); assert(r == 0); assert(stream[i * 4 + j]); } } for (i = 0; i < 2; ++i) { for (j = 0; j < 4; ++j) { cubeb_stream_destroy(stream[i * 4 + j]); } cubeb_destroy(ctx[i]); } END_TEST }
static void test_stream_position(void) { int i; int r; cubeb * ctx; cubeb_stream * stream; cubeb_stream_params params; uint64_t position, last_position; BEGIN_TEST total_frames_written = 0; r = cubeb_init(&ctx, "test_sanity"); assert(r == 0 && ctx); params.format = STREAM_FORMAT; params.rate = STREAM_RATE; params.channels = STREAM_CHANNELS; r = cubeb_stream_init(ctx, &stream, "test", params, STREAM_LATENCY, test_data_callback, test_state_callback, &dummy); assert(r == 0 && stream); /* stream position should not advance before starting playback */ r = cubeb_stream_get_position(stream, &position); assert(r == 0 && position == 0); delay(500); r = cubeb_stream_get_position(stream, &position); assert(r == 0 && position == 0); /* stream position should advance during playback */ r = cubeb_stream_start(stream); assert(r == 0); /* XXX let start happen */ delay(500); /* stream should have prefilled */ assert(total_frames_written > 0); r = cubeb_stream_get_position(stream, &position); assert(r == 0); last_position = position; delay(500); r = cubeb_stream_get_position(stream, &position); assert(r == 0); assert(position >= last_position); last_position = position; /* stream position should not exceed total frames written */ for (i = 0; i < 5; ++i) { r = cubeb_stream_get_position(stream, &position); assert(r == 0); assert(position >= last_position); assert(position <= total_frames_written); last_position = position; delay(500); } assert(last_position != 0); /* stream position should not advance after stopping playback */ r = cubeb_stream_stop(stream); assert(r == 0); /* XXX allow stream to settle */ delay(500); r = cubeb_stream_get_position(stream, &position); assert(r == 0); last_position = position; delay(500); r = cubeb_stream_get_position(stream, &position); assert(r == 0); assert(position == last_position); cubeb_stream_destroy(stream); cubeb_destroy(ctx); END_TEST }
static void test_drain(void) { int r; cubeb * ctx; cubeb_stream * stream; cubeb_stream_params params; uint64_t position; BEGIN_TEST total_frames_written = 0; r = cubeb_init(&ctx, "test_sanity"); assert(r == 0 && ctx); params.format = STREAM_FORMAT; params.rate = STREAM_RATE; params.channels = STREAM_CHANNELS; r = cubeb_stream_init(ctx, &stream, "test", params, STREAM_LATENCY, test_drain_data_callback, test_drain_state_callback, &dummy); assert(r == 0 && stream); r = cubeb_stream_start(stream); assert(r == 0); delay(500); do_drain = 1; for (;;) { r = cubeb_stream_get_position(stream, &position); assert(r == 0); if (got_drain) { break; } else { uint32_t i, skip = 0; /* Latency passed to cubeb_stream_init is not really honored on OSX, win32/winmm and android, skip this test. */ const char * backend_id = cubeb_get_backend_id(ctx); const char * latency_not_honored_bakends[] = { "audiounit", "winmm", "audiotrack", "opensl" }; for (i = 0; i < ARRAY_LENGTH(latency_not_honored_bakends); i++) { if (!strcmp(backend_id, latency_not_honored_bakends[i])) { skip = 1; } } if (!skip) { /* Position should roughly be equal to the number of written frames. We * need to take the latency into account. */ int latency = (STREAM_LATENCY * STREAM_RATE) / 1000; assert(position + latency <= total_frames_written); } } delay(500); } r = cubeb_stream_get_position(stream, &position); assert(r == 0); assert(got_drain); // Disabled due to failures in the ALSA backend. //assert(position == total_frames_written); cubeb_stream_destroy(stream); cubeb_destroy(ctx); END_TEST }
int run_panning_volume_test(int is_float) { int r = CUBEB_OK; cubeb *ctx = NULL; synth_state* synth = NULL; cubeb_stream *stream = NULL; const char * backend_id = NULL; r = cubeb_init(&ctx, "Cubeb audio test"); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb library\n"); goto cleanup; } backend_id = cubeb_get_backend_id(ctx); if ((is_float && !supports_float32(backend_id)) || (!is_float && !supports_int16(backend_id))) { /* don't treat this as a test failure. */ goto cleanup; } cubeb_stream_params params; params.format = is_float ? CUBEB_SAMPLE_FLOAT32NE : CUBEB_SAMPLE_S16NE; params.rate = 44100; params.channels = 2; synth = synth_create(params.channels, params.rate); if (synth == NULL) { fprintf(stderr, "Out of memory\n"); goto cleanup; } r = cubeb_stream_init(ctx, &stream, "test tone", NULL, NULL, NULL, ¶ms, 4096, is_float ? data_cb_float : data_cb_short, state_cb_audio, synth); if (r != CUBEB_OK) { fprintf(stderr, "Error initializing cubeb stream: %d\n", r); goto cleanup; } fprintf(stderr, "Testing: volume\n"); for(int i=0;i <= 4; ++i) { fprintf(stderr, "Volume: %d%%\n", i*25); cubeb_stream_set_volume(stream, i/4.0f); cubeb_stream_start(stream); delay(400); cubeb_stream_stop(stream); delay(100); } fprintf(stderr, "Testing: panning\n"); for(int i=-4;i <= 4; ++i) { fprintf(stderr, "Panning: %.2f%%\n", i/4.0f); cubeb_stream_set_panning(stream, i/4.0f); cubeb_stream_start(stream); delay(400); cubeb_stream_stop(stream); delay(100); } cleanup: cubeb_stream_destroy(stream); cubeb_destroy(ctx); synth_destroy(synth); return r; }