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;
}