gecko-dev/media/libcubeb/tests/test_audio.cpp
Paul Adenot 29ce6e72b4 Bug 946618 - Skip some cubeb tests on some platforms. r=kinetik
For example, skip float tests on platform that don't support floating point
audio, and skip timing test on platform where we don't honor latency request.

--HG--
extra : rebase_source : 6d48b637f18747674d519b586a24a8f4680f293b
2014-03-24 11:06:05 +01:00

200 lines
4.9 KiB
C++

/*
* Copyright © 2013 Sebastien Alaiwan <sebastien.alaiwan@gmail.com>
*
* This program is made available under an ISC-style license. See the
* accompanying file LICENSE for details.
*/
/* libcubeb api/function exhaustive test. Plays a series of tones in different
* conditions. */
#ifdef NDEBUG
#undef NDEBUG
#endif
#define _XOPEN_SOURCE 500
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>
#include <string.h>
#include "cubeb/cubeb.h"
#include "common.h"
#define MAX_NUM_CHANNELS 32
#if !defined(M_PI)
#define M_PI 3.14159265358979323846
#endif
#define NELEMS(x) ((int) (sizeof(x) / sizeof(x[0])))
#define VOLUME 0.2
float get_frequency(int channel_index)
{
return 220.0f * (channel_index+1);
}
/* store the phase of the generated waveform */
typedef struct {
int num_channels;
float phase[MAX_NUM_CHANNELS];
float sample_rate;
} synth_state;
synth_state* synth_create(int num_channels, float sample_rate)
{
synth_state* synth = (synth_state *) malloc(sizeof(synth_state));
for(int i=0;i < MAX_NUM_CHANNELS;++i)
synth->phase[i] = 0.0f;
synth->num_channels = num_channels;
synth->sample_rate = sample_rate;
return synth;
}
void synth_destroy(synth_state* synth)
{
free(synth);
}
void synth_run_float(synth_state* synth, float* audiobuffer, long nframes)
{
for(int c=0;c < synth->num_channels;++c) {
float freq = get_frequency(c);
float phase_inc = 2.0 * M_PI * freq / synth->sample_rate;
for(long n=0;n < nframes;++n) {
audiobuffer[n*synth->num_channels+c] = sin(synth->phase[c]) * VOLUME;
synth->phase[c] += phase_inc;
}
}
}
long data_cb_float(cubeb_stream *stream, void *user, void *buffer, long nframes)
{
synth_state *synth = (synth_state *)user;
synth_run_float(synth, (float*)buffer, nframes);
return nframes;
}
void synth_run_16bit(synth_state* synth, short* audiobuffer, long nframes)
{
for(int c=0;c < synth->num_channels;++c) {
float freq = get_frequency(c);
float phase_inc = 2.0 * M_PI * freq / synth->sample_rate;
for(long n=0;n < nframes;++n) {
audiobuffer[n*synth->num_channels+c] = sin(synth->phase[c]) * VOLUME * 32767.0f;
synth->phase[c] += phase_inc;
}
}
}
long data_cb_short(cubeb_stream *stream, void *user, void *buffer, long nframes)
{
synth_state *synth = (synth_state *)user;
synth_run_16bit(synth, (short*)buffer, nframes);
return nframes;
}
void state_cb(cubeb_stream *stream, void *user, cubeb_state state)
{
}
/* Our android backends don't support float, only int16. */
int supports_float32(const char* backend_id)
{
return (strcmp(backend_id, "opensl") != 0 &&
strcmp(backend_id, "audiotrack") != 0);
}
/* Some backends don't have code to deal with more than mono or stereo. */
int supports_channel_count(const char* backend_id, int nchannels)
{
return nchannels <= 2 ||
(strcmp(backend_id, "opensl") != 0 && strcmp(backend_id, "audiotrack") != 0);
}
int run_test(int num_channels, int sampling_rate, int is_float)
{
int ret = CUBEB_OK;
cubeb *ctx = NULL;
synth_state* synth = NULL;
cubeb_stream *stream = NULL;
const char * backend_id = NULL;
ret = cubeb_init(&ctx, "Cubeb audio test");
if (ret != 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)) ||
!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;
}
ret = cubeb_stream_init(ctx, &stream, "test tone", params,
100, is_float ? data_cb_float : data_cb_short, state_cb, synth);
if (ret != CUBEB_OK) {
fprintf(stderr, "Error initializing cubeb stream: %d\n", ret);
goto cleanup;
}
cubeb_stream_start(stream);
delay(200);
cubeb_stream_stop(stream);
cleanup:
cubeb_stream_destroy(stream);
cubeb_destroy(ctx);
synth_destroy(synth);
return ret;
}
int main(int argc, char *argv[])
{
int channel_values[] = {
1,
2,
3,
4,
6,
};
int freq_values[] = {
16000,
24000,
44100,
48000,
};
for(int j = 0; j < NELEMS(channel_values); ++j) {
for(int i = 0; i < NELEMS(freq_values); ++i) {
assert(channel_values[j] < MAX_NUM_CHANNELS);
fprintf(stderr, "--------------------------\n");
assert(run_test(channel_values[j], freq_values[i], 0) == CUBEB_OK);
assert(run_test(channel_values[j], freq_values[i], 1) == CUBEB_OK);
}
}
return CUBEB_OK;
}