1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // Test various buffer queue configurations
18
19 #include <assert.h>
20 #include <math.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <unistd.h>
24
25 #include <SLES/OpenSLES.h>
26
27 typedef struct {
28 SLuint8 numChannels;
29 SLuint32 milliHz;
30 SLuint8 bitsPerSample;
31 } PCM;
32
33 PCM formats[] = {
34 {1, SL_SAMPLINGRATE_8, 8},
35 {2, SL_SAMPLINGRATE_8, 8},
36 {1, SL_SAMPLINGRATE_8, 16},
37 {2, SL_SAMPLINGRATE_8, 16},
38 {1, SL_SAMPLINGRATE_11_025, 8},
39 {2, SL_SAMPLINGRATE_11_025, 8},
40 {1, SL_SAMPLINGRATE_11_025, 16},
41 {2, SL_SAMPLINGRATE_11_025, 16},
42 {1, SL_SAMPLINGRATE_12, 8},
43 {2, SL_SAMPLINGRATE_12, 8},
44 {1, SL_SAMPLINGRATE_12, 16},
45 {2, SL_SAMPLINGRATE_12, 16},
46 {1, SL_SAMPLINGRATE_16, 8},
47 {2, SL_SAMPLINGRATE_16, 8},
48 {1, SL_SAMPLINGRATE_16, 16},
49 {2, SL_SAMPLINGRATE_16, 16},
50 {1, SL_SAMPLINGRATE_22_05, 8},
51 {2, SL_SAMPLINGRATE_22_05, 8},
52 {1, SL_SAMPLINGRATE_22_05, 16},
53 {2, SL_SAMPLINGRATE_22_05, 16},
54 {1, SL_SAMPLINGRATE_24, 8},
55 {2, SL_SAMPLINGRATE_24, 8},
56 {1, SL_SAMPLINGRATE_24, 16},
57 {2, SL_SAMPLINGRATE_24, 16},
58 {1, SL_SAMPLINGRATE_32, 8},
59 {2, SL_SAMPLINGRATE_32, 8},
60 {1, SL_SAMPLINGRATE_32, 16},
61 {2, SL_SAMPLINGRATE_32, 16},
62 {1, SL_SAMPLINGRATE_44_1, 8},
63 {2, SL_SAMPLINGRATE_44_1, 8},
64 {1, SL_SAMPLINGRATE_44_1, 16},
65 {2, SL_SAMPLINGRATE_44_1, 16},
66 {1, SL_SAMPLINGRATE_48, 8},
67 {2, SL_SAMPLINGRATE_48, 8},
68 {1, SL_SAMPLINGRATE_48, 16},
69 {2, SL_SAMPLINGRATE_48, 16},
70 {0, 0, 0}
71 };
72
main(int argc __unused,char ** argv __unused)73 int main(int argc __unused, char **argv __unused)
74 {
75 SLresult result;
76 SLObjectItf engineObject;
77
78 // create engine
79 result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
80 assert(SL_RESULT_SUCCESS == result);
81 SLEngineItf engineEngine;
82 result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
83 assert(SL_RESULT_SUCCESS == result);
84 result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
85 assert(SL_RESULT_SUCCESS == result);
86
87 // create output mix
88 SLObjectItf outputMixObject;
89 result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, NULL, NULL);
90 assert(SL_RESULT_SUCCESS == result);
91 result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
92 assert(SL_RESULT_SUCCESS == result);
93
94 // loop over all formats
95 PCM *format;
96 float hzLeft = 440.0; // A440 (Concert A)
97 float hzRight = 440.0;
98 for (format = formats; format->numChannels; ++format) {
99
100 printf("Channels: %d, sample rate: %u, bits: %u\n", format->numChannels,
101 format->milliHz / 1000, format->bitsPerSample);
102
103 // configure audio source
104 SLDataLocator_BufferQueue loc_bufq;
105 loc_bufq.locatorType = SL_DATALOCATOR_BUFFERQUEUE;
106 loc_bufq.numBuffers = 1;
107 SLDataFormat_PCM format_pcm;
108 format_pcm.formatType = SL_DATAFORMAT_PCM;
109 format_pcm.numChannels = format->numChannels;
110 format_pcm.samplesPerSec = format->milliHz;
111 format_pcm.bitsPerSample = format->bitsPerSample;
112 format_pcm.containerSize = format->bitsPerSample;
113 format_pcm.channelMask = 0;
114 format_pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
115 SLDataSource audioSrc;
116 audioSrc.pLocator = &loc_bufq;
117 audioSrc.pFormat = &format_pcm;
118
119 // configure audio sink
120 SLDataLocator_OutputMix loc_outmix;
121 loc_outmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
122 loc_outmix.outputMix = outputMixObject;
123 SLDataSink audioSnk;
124 audioSnk.pLocator = &loc_outmix;
125 audioSnk.pFormat = NULL;
126
127 // create audio player
128 SLuint32 numInterfaces = 1;
129 SLInterfaceID ids[1];
130 SLboolean req[1];
131 ids[0] = SL_IID_BUFFERQUEUE;
132 req[0] = SL_BOOLEAN_TRUE;
133 SLObjectItf playerObject;
134 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
135 &audioSnk, numInterfaces, ids, req);
136 if (SL_RESULT_SUCCESS != result) {
137 printf("failed %u\n", result);
138 continue;
139 }
140
141 // realize the player
142 result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
143 assert(SL_RESULT_SUCCESS == result);
144
145 // generate a sine wave buffer, ascending in half-steps for each format
146 #define N (44100*4)
147 static unsigned char buffer[N];
148 unsigned i;
149 for (i = 0; i < N; ) {
150 float seconds = (((i * 8) / (format->bitsPerSample * format->numChannels)) * 1000.0) /
151 format->milliHz;
152 short sampleLeft = sin(seconds * M_PI_2 * hzLeft) * 32767.0;
153 short sampleRight = sin(seconds * M_PI_2 * hzRight) * 32767.0;
154 if (2 == format->numChannels) {
155 if (8 == format->bitsPerSample) {
156 buffer[i++] = (sampleLeft + 32768) >> 8;
157 buffer[i++] = (sampleRight + 32768) >> 8;
158 } else {
159 assert(16 == format->bitsPerSample);
160 buffer[i++] = sampleLeft & 0xFF;
161 buffer[i++] = sampleLeft >> 8;
162 buffer[i++] = sampleRight & 0xFF;
163 buffer[i++] = sampleRight >> 8;
164 }
165 } else {
166 assert(1 == format->numChannels);
167 // cast to int and divide by 2 are needed to prevent overflow
168 short sampleMono = ((int) sampleLeft + (int) sampleRight) / 2;
169 if (8 == format->bitsPerSample) {
170 buffer[i++] = (sampleMono + 32768) >> 8;
171 } else {
172 assert(16 == format->bitsPerSample);
173 buffer[i++] = sampleMono & 0xFF;
174 buffer[i++] = sampleMono >> 8;
175 }
176 }
177 if (seconds >= 1.0f)
178 break;
179 }
180
181 // get the buffer queue interface and enqueue a buffer
182 SLBufferQueueItf playerBufferQueue;
183 result = (*playerObject)->GetInterface(playerObject, SL_IID_BUFFERQUEUE,
184 &playerBufferQueue);
185 assert(SL_RESULT_SUCCESS == result);
186 result = (*playerBufferQueue)->Enqueue(playerBufferQueue, buffer, i);
187 assert(SL_RESULT_SUCCESS == result);
188
189 // get the play interface
190 SLPlayItf playerPlay;
191 result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
192 assert(SL_RESULT_SUCCESS == result);
193
194 // set the player's state to playing
195 result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PLAYING);
196 assert(SL_RESULT_SUCCESS == result);
197
198 // wait for the buffer to be played
199 for (;;) {
200 SLBufferQueueState state;
201 result = (*playerBufferQueue)->GetState(playerBufferQueue, &state);
202 assert(SL_RESULT_SUCCESS == result);
203 if (state.count == 0)
204 break;
205 usleep(20000);
206 }
207
208 // destroy audio player
209 (*playerObject)->Destroy(playerObject);
210
211 //usleep(1000000);
212 hzLeft *= 1.05946309; // twelfth root of 2
213 hzRight /= 1.05946309;
214 }
215
216 // destroy output mix
217 (*outputMixObject)->Destroy(outputMixObject);
218
219 // destroy engine
220 (*engineObject)->Destroy(engineObject);
221
222 return EXIT_SUCCESS;
223 }
224