mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Backed out changeset 42eb493a3791 (bug 1286041)

This commit is contained in:
Sebastian Hengst 2016-09-06 19:07:18 +02:00
Родитель c150583370
Коммит 1cbc48137a
16 изменённых файлов: 97 добавлений и 161 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
media/libcubeb/README_MOZILLA
Просмотреть файл

@ -5,4 +5,4 @@ Makefile.in build files for the Mozilla build system.
The cubeb git repository is: git://github.com/kinetiknz/cubeb.git
The git commit ID used was 2f3b9eb51dcb11dbbe61df9a00219029f6dea90c.
The git commit ID used was e4074131e4d422bfe260d29ab0a49fc368406ef4.

4
media/libcubeb/include/cubeb.h
Просмотреть файл

@ -405,8 +405,8 @@ void cubeb_destroy(cubeb * context);
default output device is used.
@param output_stream_params Parameters for the output side of the stream, or
NULL if this stream is input only.
@param latency_frames Stream latency in frames. Valid range
is [1, 96000].
@param latency Stream latency in frames. Valid range
is [1, 96000].
@param data_callback Will be called to preroll data before playback is
started by cubeb_stream_start.
@param state_callback A pointer to a state callback.

32
media/libcubeb/src/cubeb-internal.h
Просмотреть файл

@ -11,29 +11,6 @@
#include <stdio.h>
#include <string.h>
#ifdef __clang__
#ifndef CLANG_ANALYZER_NORETURN
#if __has_feature(attribute_analyzer_noreturn)
#define CLANG_ANALYZER_NORETURN __attribute__((analyzer_noreturn))
#else
#define CLANG_ANALYZER_NORETURN
#endif // ifndef CLANG_ANALYZER_NORETURN
#endif // __has_feature(attribute_analyzer_noreturn)
#else // __clang__
#define CLANG_ANALYZER_NORETURN
#endif
#if defined(__cplusplus)
extern "C" {
#endif
/* Crash the caller. */
void cubeb_crash() CLANG_ANALYZER_NORETURN;
#if defined(__cplusplus)
}
#endif
struct cubeb_ops {
int (* init)(cubeb ** context, char const * context_name);
char const * (* get_backend_id)(cubeb * context);
@ -75,11 +52,12 @@ struct cubeb_ops {
void * user_ptr);
};
#define XASSERT(expr) do { \
if (!(expr)) { \
#define XASSERT(expr) do { \
if (!(expr)) { \
fprintf(stderr, "%s:%d - fatal error: %s\n", __FILE__, __LINE__, #expr); \
cubeb_crash(); \
} \
*((volatile int *) NULL) = 0; \
abort(); \
} \
} while (0)
#endif /* CUBEB_INTERNAL_0eb56756_4e20_4404_a76d_42bf88cd15a5 */

7
media/libcubeb/src/cubeb.c
Просмотреть файл

@ -454,10 +454,3 @@ int cubeb_register_device_collection_changed(cubeb * context,
return context->ops->register_device_collection_changed(context, devtype, callback, user_ptr);
}
void cubeb_crash()
{
abort();
*((volatile int *) NULL) = 0;
}

94
media/libcubeb/src/cubeb_audiounit.cpp
Просмотреть файл

@ -30,7 +30,6 @@
#include "cubeb_ring_array.h"
#include "cubeb_utils.h"
#include <algorithm>
#include <atomic>
#if !defined(kCFCoreFoundationVersionNumber10_7)
/* From CoreFoundation CFBase.h */
@ -54,12 +53,6 @@ typedef UInt32 AudioFormatFlags;
#define AU_OUT_BUS 0
#define AU_IN_BUS 1
#if TARGET_OS_IPHONE
#define CUBEB_AUDIOUNIT_SUBTYPE kAudioUnitSubType_RemoteIO
#else
#define CUBEB_AUDIOUNIT_SUBTYPE kAudioUnitSubType_HALOutput
#endif
//#define LOGGING_ENABLED
#ifdef LOGGING_ENABLED
#define LOG(...) do { \
@ -187,7 +180,7 @@ struct cubeb_stream {
int draining;
uint64_t current_latency_frames;
uint64_t hw_latency_frames;
std::atomic<float> panning;
float panning;
cubeb_resampler * resampler;
};
@ -416,8 +409,7 @@ audiounit_output_callback(void * user_ptr,
stm->frames_queued += outframes;
AudioFormatFlags outaff = stm->output_desc.mFormatFlags;
float panning = (stm->output_desc.mChannelsPerFrame == 2) ?
stm->panning.load(std::memory_order_relaxed) : 0.0f;
float panning = (stm->output_desc.mChannelsPerFrame == 2) ? stm->panning : 0.0f;
/* Post process output samples. */
if (stm->draining) {
@ -912,7 +904,21 @@ audiounit_create_unit(AudioUnit * unit,
OSStatus rv;
desc.componentType = kAudioUnitType_Output;
desc.componentSubType = CUBEB_AUDIOUNIT_SUBTYPE;
#if TARGET_OS_IPHONE
bool use_default_output = false;
desc.componentSubType = kAudioUnitSubType_RemoteIO;
#else
// Use the DefaultOutputUnit for output when no device is specified
// so we retain automatic output device switching when the default
// changes. Once we have complete support for device notifications
// and switching, we can use the AUHAL for everything.
bool use_default_output = device == NULL && !is_input;
if (use_default_output) {
desc.componentSubType = kAudioUnitSubType_DefaultOutput;
} else {
desc.componentSubType = kAudioUnitSubType_HALOutput;
}
#endif
desc.componentManufacturer = kAudioUnitManufacturer_Apple;
desc.componentFlags = 0;
desc.componentFlagsMask = 0;
@ -928,37 +934,39 @@ audiounit_create_unit(AudioUnit * unit,
return CUBEB_ERROR;
}
enable = 1;
rv = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_EnableIO,
is_input ? kAudioUnitScope_Input : kAudioUnitScope_Output,
is_input ? AU_IN_BUS : AU_OUT_BUS, &enable, sizeof(UInt32));
if (rv != noErr) {
PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_EnableIO", rv);
return CUBEB_ERROR;
}
if (!use_default_output) {
enable = 1;
rv = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_EnableIO,
is_input ? kAudioUnitScope_Input : kAudioUnitScope_Output,
is_input ? AU_IN_BUS : AU_OUT_BUS, &enable, sizeof(UInt32));
if (rv != noErr) {
PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_EnableIO", rv);
return CUBEB_ERROR;
}
enable = 0;
rv = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_EnableIO,
is_input ? kAudioUnitScope_Output : kAudioUnitScope_Input,
is_input ? AU_OUT_BUS : AU_IN_BUS, &enable, sizeof(UInt32));
if (rv != noErr) {
PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_EnableIO", rv);
return CUBEB_ERROR;
}
enable = 0;
rv = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_EnableIO,
is_input ? kAudioUnitScope_Output : kAudioUnitScope_Input,
is_input ? AU_OUT_BUS : AU_IN_BUS, &enable, sizeof(UInt32));
if (rv != noErr) {
PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_EnableIO", rv);
return CUBEB_ERROR;
}
if (device == NULL) {
devid = audiounit_get_default_device_id(is_input ? CUBEB_DEVICE_TYPE_INPUT
: CUBEB_DEVICE_TYPE_OUTPUT);
} else {
devid = reinterpret_cast<intptr_t>(device);
}
int err = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_CurrentDevice,
kAudioUnitScope_Global,
is_input ? AU_IN_BUS : AU_OUT_BUS,
&devid, sizeof(AudioDeviceID));
if (err != noErr) {
PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_CurrentDevice", rv);
return CUBEB_ERROR;
if (device == NULL) {
assert(is_input);
devid = audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_INPUT);
} else {
devid = reinterpret_cast<intptr_t>(device);
}
int err = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_CurrentDevice,
kAudioUnitScope_Global,
is_input ? AU_IN_BUS : AU_OUT_BUS,
&devid, sizeof(AudioDeviceID));
if (err != noErr) {
PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_CurrentDevice", rv);
return CUBEB_ERROR;
}
}
return CUBEB_OK;
@ -1605,7 +1613,11 @@ int audiounit_stream_set_panning(cubeb_stream * stm, float panning)
return CUBEB_ERROR_INVALID_PARAMETER;
}
stm->panning.store(panning, std::memory_order_relaxed);
{
auto_lock lock(stm->mutex);
stm->panning = panning;
}
return CUBEB_OK;
}

15
media/libcubeb/src/cubeb_jack.cpp
Просмотреть файл

@ -283,6 +283,8 @@ cbjack_graph_order_callback(void * arg)
{
cubeb * ctx = (cubeb *)arg;
int i;
uint32_t rate;
jack_latency_range_t latency_range;
jack_nframes_t port_latency, max_latency = 0;
@ -621,13 +623,13 @@ jack_init (cubeb ** context, char const * context_name)
}
static char const *
cbjack_get_backend_id(cubeb * /*context*/)
cbjack_get_backend_id(cubeb * context)
{
return "jack";
}
static int
cbjack_get_max_channel_count(cubeb * /*ctx*/, uint32_t * max_channels)
cbjack_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)
{
*max_channels = MAX_CHANNELS;
return CUBEB_OK;
@ -641,7 +643,7 @@ cbjack_get_latency(cubeb_stream * stm, unsigned int * latency_ms)
}
static int
cbjack_get_min_latency(cubeb * ctx, cubeb_stream_params /*params*/, uint32_t * latency_ms)
cbjack_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_ms)
{
*latency_ms = ctx->jack_latency;
return CUBEB_OK;
@ -701,7 +703,7 @@ cbjack_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_
cubeb_stream_params * input_stream_params,
cubeb_devid output_device,
cubeb_stream_params * output_stream_params,
unsigned int /*latency_frames*/,
unsigned int latency_frames,
cubeb_data_callback data_callback,
cubeb_state_callback state_callback,
void * user_ptr)
@ -723,9 +725,6 @@ cbjack_stream_init(cubeb * context, cubeb_stream ** stream, char const * stream_
return CUBEB_ERROR_INVALID_FORMAT;
}
if (input_device || output_device)
return CUBEB_ERROR_NOT_SUPPORTED;
*stream = NULL;
// Find a free stream.
@ -957,7 +956,7 @@ cbjack_stream_get_current_device(cubeb_stream * stm, cubeb_device ** const devic
}
static int
cbjack_stream_device_destroy(cubeb_stream * /*stream*/,
cbjack_stream_device_destroy(cubeb_stream * stream,
cubeb_device * device)
{
if (device->input_name)

52
media/libcubeb/src/cubeb_pulse.c
Просмотреть файл

@ -73,14 +73,12 @@
X(pa_stream_set_read_callback) \
X(pa_stream_connect_record) \
X(pa_stream_readable_size) \
X(pa_stream_writable_size) \
X(pa_stream_peek) \
X(pa_stream_drop) \
X(pa_stream_get_buffer_attr) \
X(pa_stream_get_device_name) \
X(pa_context_set_subscribe_callback) \
X(pa_context_subscribe) \
X(pa_mainloop_api_once) \
#define MAKE_TYPEDEF(x) static typeof(x) * cubeb_##x;
LIBPULSE_API_VISIT(MAKE_TYPEDEF);
@ -122,7 +120,6 @@ struct cubeb_stream {
pa_sample_spec input_sample_spec;
int shutdown;
float volume;
cubeb_state state;
};
const float PULSE_NO_GAIN = -1.0;
@ -175,22 +172,14 @@ stream_success_callback(pa_stream * s, int success, void * u)
WRAP(pa_threaded_mainloop_signal)(stm->context->mainloop, 0);
}
static void
stream_state_change_callback(cubeb_stream * stm, cubeb_state s)
{
stm->state = s;
stm->state_callback(stm, stm->user_ptr, s);
}
static void
stream_drain_callback(pa_mainloop_api * a, pa_time_event * e, struct timeval const * tv, void * u)
{
cubeb_stream * stm = u;
stream_state_change_callback(stm, CUBEB_STATE_DRAINED);
/* there's no pa_rttime_free, so use this instead. */
a->time_free(stm->drain_timer);
stm->drain_timer = NULL;
WRAP(pa_threaded_mainloop_signal)(stm->context->mainloop, 0);
stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_DRAINED);
}
static void
@ -198,7 +187,7 @@ stream_state_callback(pa_stream * s, void * u)
{
cubeb_stream * stm = u;
if (!PA_STREAM_IS_GOOD(WRAP(pa_stream_get_state)(s))) {
stream_state_change_callback(stm, CUBEB_STATE_ERROR);
stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
}
WRAP(pa_threaded_mainloop_signal)(stm->context->mainloop, 0);
}
@ -297,8 +286,7 @@ stream_write_callback(pa_stream * s, size_t nbytes, void * u)
{
LOG("Output callback to be written buffer size %zd\n", nbytes);
cubeb_stream * stm = u;
if (stm->shutdown ||
stm->state != CUBEB_STATE_STARTED) {
if (stm->shutdown) {
return;
}
@ -436,8 +424,8 @@ stream_cork(cubeb_stream * stm, enum cork_state state)
WRAP(pa_threaded_mainloop_unlock)(stm->context->mainloop);
if (state & NOTIFY) {
stream_state_change_callback(stm, state & CORK ? CUBEB_STATE_STOPPED
: CUBEB_STATE_STARTED);
stm->state_callback(stm, stm->user_ptr,
state & CORK ? CUBEB_STATE_STOPPED : CUBEB_STATE_STARTED);
}
}
@ -731,8 +719,6 @@ pulse_stream_init(cubeb * context,
stm->state_callback = state_callback;
stm->user_ptr = user_ptr;
stm->volume = PULSE_NO_GAIN;
stm->state = -1;
assert(stm->shutdown == 0);
WRAP(pa_threaded_mainloop_lock)(stm->context->mainloop);
if (output_stream_params) {
@ -844,44 +830,16 @@ pulse_stream_destroy(cubeb_stream * stm)
free(stm);
}
void
pulse_defer_event_cb(pa_mainloop_api * a, void * userdata)
{
cubeb_stream * stm = userdata;
size_t writable_size = WRAP(pa_stream_writable_size)(stm->output_stream);
trigger_user_callback(stm->output_stream, NULL, writable_size, stm);
}
static int
pulse_stream_start(cubeb_stream * stm)
{
stm->shutdown = 0;
stream_cork(stm, UNCORK | NOTIFY);
if (stm->output_stream && !stm->input_stream) {
/* On output only case need to manually call user cb once in order to make
* things roll. This is done via a defer event in order to execute it
* from PA server thread. */
WRAP(pa_threaded_mainloop_lock)(stm->context->mainloop);
WRAP(pa_mainloop_api_once)(WRAP(pa_threaded_mainloop_get_api)(stm->context->mainloop),
pulse_defer_event_cb, stm);
WRAP(pa_threaded_mainloop_unlock)(stm->context->mainloop);
}
return CUBEB_OK;
}
static int
pulse_stream_stop(cubeb_stream * stm)
{
WRAP(pa_threaded_mainloop_lock)(stm->context->mainloop);
stm->shutdown = 1;
// If draining is taking place wait to finish
while (stm->drain_timer) {
WRAP(pa_threaded_mainloop_wait)(stm->context->mainloop);
}
WRAP(pa_threaded_mainloop_unlock)(stm->context->mainloop);
stream_cork(stm, CORK | NOTIFY);
return CUBEB_OK;
}

2
media/libcubeb/src/cubeb_resampler.cpp
Просмотреть файл

@ -150,7 +150,7 @@ template<typename T, typename InputProcessor, typename OutputProcessor>
long
cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
::fill_internal_input(T * input_buffer, long * input_frames_count,
T * output_buffer, long /*output_frames_needed*/)
T * output_buffer, long output_frames_needed)
{
assert(input_buffer && input_frames_count && *input_frames_count &&
!output_buffer);

6
media/libcubeb/src/cubeb_utils_unix.h
Просмотреть файл

@ -20,11 +20,7 @@ public:
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
#ifdef DEBUG
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
#else
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
#endif
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
#ifdef DEBUG
int r =

8
media/libcubeb/tests/test_audio.cpp
Просмотреть файл

@ -73,7 +73,7 @@ void synth_run_float(synth_state* synth, float* audiobuffer, long nframes)
}
}
long data_cb_float(cubeb_stream * /*stream*/, void * user, const void * /*inputbuffer*/, void * outputbuffer, long nframes)
long data_cb_float(cubeb_stream *stream, void *user, const void * inputbuffer, void *outputbuffer, long nframes)
{
synth_state *synth = (synth_state *)user;
synth_run_float(synth, (float*)outputbuffer, nframes);
@ -92,14 +92,14 @@ void synth_run_16bit(synth_state* synth, short* audiobuffer, long nframes)
}
}
long data_cb_short(cubeb_stream * /*stream*/, void * user, const void * /*inputbuffer*/, void * outputbuffer, long nframes)
long data_cb_short(cubeb_stream *stream, void *user, const void * inputbuffer, void *outputbuffer, long nframes)
{
synth_state *synth = (synth_state *)user;
synth_run_16bit(synth, (short*)outputbuffer, nframes);
return nframes;
}
void state_cb(cubeb_stream * /*stream*/, void * /*user*/, cubeb_state /*state*/)
void state_cb(cubeb_stream *stream, void *user, cubeb_state state)
{
}
@ -280,7 +280,7 @@ void run_channel_rate_test()
}
int main(int /*argc*/, char * /*argv*/[])
int main(int argc, char *argv[])
{
#ifdef CUBEB_GECKO_BUILD
ScopedXPCOM xpcom("test_audio");

6
media/libcubeb/tests/test_duplex.cpp
Просмотреть файл

@ -38,7 +38,7 @@ struct user_state
long data_cb(cubeb_stream * stream, void * user, const void * inputbuffer, void * outputbuffer, long nframes)
long data_cb(cubeb_stream *stream, void *user, const void * inputbuffer, void *outputbuffer, long nframes)
{
user_state * u = reinterpret_cast<user_state*>(user);
#if (defined(_WIN32) || defined(__WIN32__))
@ -70,7 +70,7 @@ long data_cb(cubeb_stream * stream, void * user, const void * inputbuffer, void
return nframes;
}
void state_cb(cubeb_stream * stream, void * /*user*/, cubeb_state state)
void state_cb(cubeb_stream *stream, void *user, cubeb_state state)
{
if (stream == NULL)
return;
@ -89,7 +89,7 @@ void state_cb(cubeb_stream * stream, void * /*user*/, cubeb_state state)
return;
}
int main(int /*argc*/, char * /*argv*/[])
int main(int argc, char *argv[])
{
#ifdef CUBEB_GECKO_BUILD
ScopedXPCOM xpcom("test_duplex");

2
media/libcubeb/tests/test_latency.cpp
Просмотреть файл

@ -11,7 +11,7 @@
#define LOG(msg) fprintf(stderr, "%s\n", msg);
int main(int /*argc*/, char * /*argv*/[])
int main(int argc, char * argv[])
{
#ifdef CUBEB_GECKO_BUILD
ScopedXPCOM xpcom("test_latency");

6
media/libcubeb/tests/test_record.cpp
Просмотреть файл

@ -33,7 +33,7 @@ struct user_state
bool seen_noise;
};
long data_cb(cubeb_stream * stream, void * user, const void * inputbuffer, void * outputbuffer, long nframes)
long data_cb(cubeb_stream *stream, void *user, const void * inputbuffer, void *outputbuffer, long nframes)
{
user_state * u = reinterpret_cast<user_state*>(user);
#if STREAM_FORMAT != CUBEB_SAMPLE_FLOAT32LE
@ -58,7 +58,7 @@ long data_cb(cubeb_stream * stream, void * user, const void * inputbuffer, void
return nframes;
}
void state_cb(cubeb_stream * stream, void * /*user*/, cubeb_state state)
void state_cb(cubeb_stream *stream, void *user, cubeb_state state)
{
if (stream == NULL)
return;
@ -77,7 +77,7 @@ void state_cb(cubeb_stream * stream, void * /*user*/, cubeb_state state)
return;
}
int main(int /*argc*/, char * /*argv*/[])
int main(int argc, char *argv[])
{
#ifdef CUBEB_GECKO_BUILD
ScopedXPCOM xpcom("test_record");

6
media/libcubeb/tests/test_resampler.cpp
Просмотреть файл

@ -283,7 +283,7 @@ uint32_t fill_with_sine(float * buf, uint32_t rate, uint32_t channels,
return initial_phase;
}
long data_cb(cubeb_stream * /*stm*/, void * user_ptr,
long data_cb(cubeb_stream * stm, void * user_ptr,
const void * input_buffer, void * output_buffer, long frame_count)
{
osc_state * state = reinterpret_cast<osc_state*>(user_ptr);
@ -464,7 +464,7 @@ void test_delay_line()
}
}
long test_output_only_noop_data_cb(cubeb_stream * /*stm*/, void * /*user_ptr*/,
long test_output_only_noop_data_cb(cubeb_stream * stm, void * user_ptr,
const void * input_buffer,
void * output_buffer, long frame_count)
{
@ -500,7 +500,7 @@ void test_output_only_noop()
cubeb_resampler_destroy(resampler);
}
long test_drain_data_cb(cubeb_stream * /*stm*/, void * /*user_ptr*/,
long test_drain_data_cb(cubeb_stream * stm, void * user_ptr,
const void * input_buffer,
void * output_buffer, long frame_count)
{

10
media/libcubeb/tests/test_sanity.cpp
Просмотреть файл

@ -36,7 +36,7 @@ static uint64_t total_frames_written;
static int delay_callback;
static long
test_data_callback(cubeb_stream * stm, void * user_ptr, const void * /*inputbuffer*/, void * outputbuffer, long nframes)
test_data_callback(cubeb_stream * stm, void * user_ptr, const void * inputbuffer, void * outputbuffer, long nframes)
{
assert(stm && user_ptr == &dummy && outputbuffer && nframes > 0);
#if (defined(_WIN32) || defined(__WIN32__))
@ -53,7 +53,7 @@ test_data_callback(cubeb_stream * stm, void * user_ptr, const void * /*inputbuff
}
void
test_state_callback(cubeb_stream * /*stm*/, void * /*user_ptr*/, cubeb_state /*state*/)
test_state_callback(cubeb_stream * stm, void * user_ptr, cubeb_state state)
{
}
@ -494,7 +494,7 @@ static int do_drain;
static int got_drain;
static long
test_drain_data_callback(cubeb_stream * stm, void * user_ptr, const void * /*inputbuffer*/, void * outputbuffer, long nframes)
test_drain_data_callback(cubeb_stream * stm, void * user_ptr, const void * inputbuffer, void * outputbuffer, long nframes)
{
assert(stm && user_ptr == &dummy && outputbuffer && nframes > 0);
if (do_drain == 1) {
@ -513,7 +513,7 @@ test_drain_data_callback(cubeb_stream * stm, void * user_ptr, const void * /*inp
}
void
test_drain_state_callback(cubeb_stream * /*stm*/, void * /*user_ptr*/, cubeb_state state)
test_drain_state_callback(cubeb_stream * stm, void * user_ptr, cubeb_state state)
{
if (state == CUBEB_STATE_DRAINED) {
assert(!got_drain);
@ -608,7 +608,7 @@ int is_windows_7()
}
int
main(int /*argc*/, char * /*argv*/[])
main(int argc, char * argv[])
{
#ifdef CUBEB_GECKO_BUILD
ScopedXPCOM xpcom("test_sanity");

4
media/libcubeb/tests/test_tone.cpp
Просмотреть файл

@ -34,7 +34,7 @@ struct cb_user_data {
long position;
};
long data_cb(cubeb_stream *stream, void *user, const void* /*inputbuffer*/, void *outputbuffer, long nframes)
long data_cb(cubeb_stream *stream, void *user, const void* inputbuffer, void *outputbuffer, long nframes)
{
struct cb_user_data *u = (struct cb_user_data *)user;
#if (defined(_WIN32) || defined(__WIN32__))
@ -98,7 +98,7 @@ void state_cb(cubeb_stream *stream, void *user, cubeb_state state)
return;
}
int main(int /*argc*/, char * /*argv*/[])
int main(int argc, char *argv[])
{
#ifdef CUBEB_GECKO_BUILD
ScopedXPCOM xpcom("test_tone");