/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* interactive buffer queue test program */
#ifdef ANDROID
#define USE_ANDROID_SIMPLE_BUFFER_QUEUE // change to #undef for compatibility testing
#endif
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <SLES/OpenSLES.h>
#ifdef USE_ANDROID_SIMPLE_BUFFER_QUEUE
#include <SLES/OpenSLES_Android.h>
#endif
#include "getch.h"
#ifdef USE_ANDROID_SIMPLE_BUFFER_QUEUE
#define DATALOCATOR_BUFFERQUEUE SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE
#define IID_BUFFERQUEUE SL_IID_ANDROIDSIMPLEBUFFERQUEUE
#define BufferQueueItf SLAndroidSimpleBufferQueueItf
#define BufferQueueState SLAndroidSimpleBufferQueueState
#define INDEX index
#else
#define DATALOCATOR_BUFFERQUEUE SL_DATALOCATOR_BUFFERQUEUE
#define IID_BUFFERQUEUE SL_IID_BUFFERQUEUE
#define BufferQueueItf SLBufferQueueItf
#define BufferQueueState SLBufferQueueState
#define INDEX playIndex
#endif
#define checkResult(r) do { if ((r) != SL_RESULT_SUCCESS) fprintf(stderr, "error %d at %s:%d\n", \
(int) (r), __FILE__, __LINE__); } while (0)
typedef struct {
short left;
short right;
} frame_t;
#define SINE_FRAMES (44100*5)
frame_t sine[SINE_FRAMES];
#define SQUARE_FRAMES (44100*5)
frame_t square[SQUARE_FRAMES];
#define SAWTOOTH_FRAMES (44100*5)
frame_t sawtooth[SAWTOOTH_FRAMES];
#define HALF_FRAMES (44100*5)
frame_t half[HALF_FRAMES];
BufferQueueItf expectedCaller = NULL;
void *expectedContext = NULL;
static void callback(BufferQueueItf caller, void *context)
{
putchar('.');
if (caller != expectedCaller)
printf("caller %p expected %p\r\n", caller, expectedCaller);
if (context != expectedContext)
printf("context %p expected %p\r\n", context, expectedContext);
fflush(stdout);
}
int main(int argc __unused, char **argv __unused)
{
SLresult result;
// create engine
SLObjectItf engineObject;
result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
checkResult(result);
result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
checkResult(result);
SLEngineItf engineEngine;
result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
checkResult(result);
// create output mix
SLObjectItf outputmixObject;
result = (*engineEngine)->CreateOutputMix(engineEngine, &outputmixObject, 0, NULL, NULL);
checkResult(result);
result = (*outputmixObject)->Realize(outputmixObject, SL_BOOLEAN_FALSE);
checkResult(result);
// create audio player
SLDataSource audiosrc;
SLDataSink audiosnk;
SLDataFormat_PCM pcm;
SLDataLocator_OutputMix locator_outputmix;
SLDataLocator_BufferQueue locator_bufferqueue;
locator_bufferqueue.locatorType = DATALOCATOR_BUFFERQUEUE;
locator_bufferqueue.numBuffers = 255;
locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
locator_outputmix.outputMix = outputmixObject;
pcm.formatType = SL_DATAFORMAT_PCM;
pcm.numChannels = 2;
pcm.samplesPerSec = SL_SAMPLINGRATE_44_1;
pcm.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
pcm.containerSize = 16;
pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
audiosrc.pLocator = &locator_bufferqueue;
audiosrc.pFormat = &pcm;
audiosnk.pLocator = &locator_outputmix;
audiosnk.pFormat = NULL;
SLObjectItf playerObject;
SLInterfaceID ids[2] = {IID_BUFFERQUEUE, SL_IID_MUTESOLO};
SLboolean flags[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audiosrc, &audiosnk,
2, ids, flags);
checkResult(result);
result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
checkResult(result);
SLPlayItf playerPlay;
result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
checkResult(result);
BufferQueueItf playerBufferqueue;
result = (*playerObject)->GetInterface(playerObject, IID_BUFFERQUEUE, &playerBufferqueue);
checkResult(result);
SLMuteSoloItf playerMuteSolo;
result = (*playerObject)->GetInterface(playerObject, SL_IID_MUTESOLO, &playerMuteSolo);
checkResult(result);
SLuint8 numChannels = 123;
result = (*playerMuteSolo)->GetNumChannels(playerMuteSolo, &numChannels);
assert(2 == numChannels);
SLuint32 state;
state = SL_PLAYSTATE_PLAYING;
result = (*playerPlay)->SetPlayState(playerPlay, state);
checkResult(result);
unsigned i;
float pi2 = 3.14*2;
float hz = 441;
float sr = 44100;
for (i = 0; i < SINE_FRAMES; ++i) {
sine[i].left = sin((float) (i / (sr / hz)) * pi2 ) * 32000.0;
sine[i].right = sine[i].left;
}
for (i = 0; i < SQUARE_FRAMES; ++i) {
square[i].left = (i % (unsigned) (sr / hz)) < 50 ? 32767 : -32768;
square[i].right = square[i].left;
}
for (i = 0; i < SAWTOOTH_FRAMES; ++i) {
sawtooth[i].left = ((((int) (i % (unsigned) (sr / hz))) - 50) / 100.0) * 60000.0 - 30000.0;
sawtooth[i].right = sawtooth[i].left;
}
for (i = 0; i < HALF_FRAMES; ++i) {
half[i].left = sine[i].left;
half[i].right = sawtooth[i].right / 2;
}
set_conio_terminal_mode();
int in_count = 0;
uintptr_t count = 0;
for (;;) {
usleep(10000);
if (kbhit()) {
frame_t *buffer;
unsigned size;
BufferQueueState bufqstate;
int ch = getch();
switch (ch) {
case '0' ... '9':
if (in_count) {
count = count * 10 + (ch - '0');
} else {
count = ch - '0';
in_count = 1;
}
continue;
case 'i':
buffer = sine;
size = sizeof(sine);
goto enqueue;
case 'q':
buffer = square;
size = sizeof(square);
goto enqueue;
case 'h':
buffer = half;
size = sizeof(half);
goto enqueue;
case 'r':
if (in_count) {
expectedCaller = playerBufferqueue;
expectedContext = (void *) count;
} else {
expectedCaller = NULL;
expectedContext = (void *) NULL;
}
result = (*playerBufferqueue)->RegisterCallback(playerBufferqueue, in_count ?
callback : NULL, expectedContext);
checkResult(result);
break;
case 'a':
buffer = sawtooth;
size = sizeof(sawtooth);
enqueue:
for (i = 0; i < (in_count ? count : 1); ++i) {
result = (*playerBufferqueue)->Enqueue(playerBufferqueue, buffer, size);
checkResult(result);
}
break;
case 'c':
result = (*playerBufferqueue)->Clear(playerBufferqueue);
checkResult(result);
putchar('\r');
result = (*playerBufferqueue)->GetState(playerBufferqueue, &bufqstate);
checkResult(result);
if (bufqstate.count != 0)
printf("\rcount=%u\r\n", (unsigned) bufqstate.count);
#if 0
putchar('\r');
putchar('\n');
#endif
fflush(stdout);
break;
case 'g':
result = (*playerBufferqueue)->GetState(playerBufferqueue, &bufqstate);
checkResult(result);
printf("\rplayIndex=%u\r\n", (unsigned) bufqstate.INDEX);
printf("count=%u\r\n", (unsigned) bufqstate.count);
break;
case 'p':
state = SL_PLAYSTATE_PAUSED;
goto setplaystate;
case 's':
state = SL_PLAYSTATE_STOPPED;
goto setplaystate;
case 'P':
state = SL_PLAYSTATE_PLAYING;
setplaystate:
result = (*playerPlay)->SetPlayState(playerPlay, state);
checkResult(result);
SLuint32 newstate;
result = (*playerPlay)->GetPlayState(playerPlay, &newstate);
checkResult(result);
if (newstate != state)
printf("\rSetPlayState(%u) -> GetPlayState(%u)\r\n", (unsigned) state,
(unsigned) newstate);
#if 0
putchar('\r');
putchar('\n');
fflush(stdout);
#endif
checkResult(result);
break;
case 'x':
goto out;
default:
putchar('?');
fflush(stdout);
break;
}
in_count = 0;
}
}
out:
(*playerObject)->Destroy(playerObject);
(*outputmixObject)->Destroy(outputmixObject);
(*engineObject)->Destroy(engineObject);
return EXIT_SUCCESS;
}