You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
224 lines
7.9 KiB
224 lines
7.9 KiB
/*
|
|
* 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.
|
|
*/
|
|
|
|
// Test various buffer queue configurations
|
|
|
|
#include <assert.h>
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
|
|
#include <SLES/OpenSLES.h>
|
|
|
|
typedef struct {
|
|
SLuint8 numChannels;
|
|
SLuint32 milliHz;
|
|
SLuint8 bitsPerSample;
|
|
} PCM;
|
|
|
|
PCM formats[] = {
|
|
{1, SL_SAMPLINGRATE_8, 8},
|
|
{2, SL_SAMPLINGRATE_8, 8},
|
|
{1, SL_SAMPLINGRATE_8, 16},
|
|
{2, SL_SAMPLINGRATE_8, 16},
|
|
{1, SL_SAMPLINGRATE_11_025, 8},
|
|
{2, SL_SAMPLINGRATE_11_025, 8},
|
|
{1, SL_SAMPLINGRATE_11_025, 16},
|
|
{2, SL_SAMPLINGRATE_11_025, 16},
|
|
{1, SL_SAMPLINGRATE_12, 8},
|
|
{2, SL_SAMPLINGRATE_12, 8},
|
|
{1, SL_SAMPLINGRATE_12, 16},
|
|
{2, SL_SAMPLINGRATE_12, 16},
|
|
{1, SL_SAMPLINGRATE_16, 8},
|
|
{2, SL_SAMPLINGRATE_16, 8},
|
|
{1, SL_SAMPLINGRATE_16, 16},
|
|
{2, SL_SAMPLINGRATE_16, 16},
|
|
{1, SL_SAMPLINGRATE_22_05, 8},
|
|
{2, SL_SAMPLINGRATE_22_05, 8},
|
|
{1, SL_SAMPLINGRATE_22_05, 16},
|
|
{2, SL_SAMPLINGRATE_22_05, 16},
|
|
{1, SL_SAMPLINGRATE_24, 8},
|
|
{2, SL_SAMPLINGRATE_24, 8},
|
|
{1, SL_SAMPLINGRATE_24, 16},
|
|
{2, SL_SAMPLINGRATE_24, 16},
|
|
{1, SL_SAMPLINGRATE_32, 8},
|
|
{2, SL_SAMPLINGRATE_32, 8},
|
|
{1, SL_SAMPLINGRATE_32, 16},
|
|
{2, SL_SAMPLINGRATE_32, 16},
|
|
{1, SL_SAMPLINGRATE_44_1, 8},
|
|
{2, SL_SAMPLINGRATE_44_1, 8},
|
|
{1, SL_SAMPLINGRATE_44_1, 16},
|
|
{2, SL_SAMPLINGRATE_44_1, 16},
|
|
{1, SL_SAMPLINGRATE_48, 8},
|
|
{2, SL_SAMPLINGRATE_48, 8},
|
|
{1, SL_SAMPLINGRATE_48, 16},
|
|
{2, SL_SAMPLINGRATE_48, 16},
|
|
{0, 0, 0}
|
|
};
|
|
|
|
int main(int argc __unused, char **argv __unused)
|
|
{
|
|
SLresult result;
|
|
SLObjectItf engineObject;
|
|
|
|
// create engine
|
|
result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
|
|
assert(SL_RESULT_SUCCESS == result);
|
|
SLEngineItf engineEngine;
|
|
result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
|
|
assert(SL_RESULT_SUCCESS == result);
|
|
result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
|
|
assert(SL_RESULT_SUCCESS == result);
|
|
|
|
// create output mix
|
|
SLObjectItf outputMixObject;
|
|
result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, NULL, NULL);
|
|
assert(SL_RESULT_SUCCESS == result);
|
|
result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
|
|
assert(SL_RESULT_SUCCESS == result);
|
|
|
|
// loop over all formats
|
|
PCM *format;
|
|
float hzLeft = 440.0; // A440 (Concert A)
|
|
float hzRight = 440.0;
|
|
for (format = formats; format->numChannels; ++format) {
|
|
|
|
printf("Channels: %d, sample rate: %u, bits: %u\n", format->numChannels,
|
|
format->milliHz / 1000, format->bitsPerSample);
|
|
|
|
// configure audio source
|
|
SLDataLocator_BufferQueue loc_bufq;
|
|
loc_bufq.locatorType = SL_DATALOCATOR_BUFFERQUEUE;
|
|
loc_bufq.numBuffers = 1;
|
|
SLDataFormat_PCM format_pcm;
|
|
format_pcm.formatType = SL_DATAFORMAT_PCM;
|
|
format_pcm.numChannels = format->numChannels;
|
|
format_pcm.samplesPerSec = format->milliHz;
|
|
format_pcm.bitsPerSample = format->bitsPerSample;
|
|
format_pcm.containerSize = format->bitsPerSample;
|
|
format_pcm.channelMask = 0;
|
|
format_pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
|
|
SLDataSource audioSrc;
|
|
audioSrc.pLocator = &loc_bufq;
|
|
audioSrc.pFormat = &format_pcm;
|
|
|
|
// configure audio sink
|
|
SLDataLocator_OutputMix loc_outmix;
|
|
loc_outmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
|
|
loc_outmix.outputMix = outputMixObject;
|
|
SLDataSink audioSnk;
|
|
audioSnk.pLocator = &loc_outmix;
|
|
audioSnk.pFormat = NULL;
|
|
|
|
// create audio player
|
|
SLuint32 numInterfaces = 1;
|
|
SLInterfaceID ids[1];
|
|
SLboolean req[1];
|
|
ids[0] = SL_IID_BUFFERQUEUE;
|
|
req[0] = SL_BOOLEAN_TRUE;
|
|
SLObjectItf playerObject;
|
|
result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
|
|
&audioSnk, numInterfaces, ids, req);
|
|
if (SL_RESULT_SUCCESS != result) {
|
|
printf("failed %u\n", result);
|
|
continue;
|
|
}
|
|
|
|
// realize the player
|
|
result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
|
|
assert(SL_RESULT_SUCCESS == result);
|
|
|
|
// generate a sine wave buffer, ascending in half-steps for each format
|
|
#define N (44100*4)
|
|
static unsigned char buffer[N];
|
|
unsigned i;
|
|
for (i = 0; i < N; ) {
|
|
float seconds = (((i * 8) / (format->bitsPerSample * format->numChannels)) * 1000.0) /
|
|
format->milliHz;
|
|
short sampleLeft = sin(seconds * M_PI_2 * hzLeft) * 32767.0;
|
|
short sampleRight = sin(seconds * M_PI_2 * hzRight) * 32767.0;
|
|
if (2 == format->numChannels) {
|
|
if (8 == format->bitsPerSample) {
|
|
buffer[i++] = (sampleLeft + 32768) >> 8;
|
|
buffer[i++] = (sampleRight + 32768) >> 8;
|
|
} else {
|
|
assert(16 == format->bitsPerSample);
|
|
buffer[i++] = sampleLeft & 0xFF;
|
|
buffer[i++] = sampleLeft >> 8;
|
|
buffer[i++] = sampleRight & 0xFF;
|
|
buffer[i++] = sampleRight >> 8;
|
|
}
|
|
} else {
|
|
assert(1 == format->numChannels);
|
|
// cast to int and divide by 2 are needed to prevent overflow
|
|
short sampleMono = ((int) sampleLeft + (int) sampleRight) / 2;
|
|
if (8 == format->bitsPerSample) {
|
|
buffer[i++] = (sampleMono + 32768) >> 8;
|
|
} else {
|
|
assert(16 == format->bitsPerSample);
|
|
buffer[i++] = sampleMono & 0xFF;
|
|
buffer[i++] = sampleMono >> 8;
|
|
}
|
|
}
|
|
if (seconds >= 1.0f)
|
|
break;
|
|
}
|
|
|
|
// get the buffer queue interface and enqueue a buffer
|
|
SLBufferQueueItf playerBufferQueue;
|
|
result = (*playerObject)->GetInterface(playerObject, SL_IID_BUFFERQUEUE,
|
|
&playerBufferQueue);
|
|
assert(SL_RESULT_SUCCESS == result);
|
|
result = (*playerBufferQueue)->Enqueue(playerBufferQueue, buffer, i);
|
|
assert(SL_RESULT_SUCCESS == result);
|
|
|
|
// get the play interface
|
|
SLPlayItf playerPlay;
|
|
result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
|
|
assert(SL_RESULT_SUCCESS == result);
|
|
|
|
// set the player's state to playing
|
|
result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PLAYING);
|
|
assert(SL_RESULT_SUCCESS == result);
|
|
|
|
// wait for the buffer to be played
|
|
for (;;) {
|
|
SLBufferQueueState state;
|
|
result = (*playerBufferQueue)->GetState(playerBufferQueue, &state);
|
|
assert(SL_RESULT_SUCCESS == result);
|
|
if (state.count == 0)
|
|
break;
|
|
usleep(20000);
|
|
}
|
|
|
|
// destroy audio player
|
|
(*playerObject)->Destroy(playerObject);
|
|
|
|
//usleep(1000000);
|
|
hzLeft *= 1.05946309; // twelfth root of 2
|
|
hzRight /= 1.05946309;
|
|
}
|
|
|
|
// destroy output mix
|
|
(*outputMixObject)->Destroy(outputMixObject);
|
|
|
|
// destroy engine
|
|
(*engineObject)->Destroy(engineObject);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|