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 combinations of data sources and sinks
18
19 #include <assert.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include "SLES/OpenSLES.h"
23
main(int argc,char ** argv)24 int main(int argc, char **argv)
25 {
26 SLresult result;
27 SLObjectItf engineObject;
28
29 // create engine
30 result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
31 assert(SL_RESULT_SUCCESS == result);
32 SLEngineItf engineEngine;
33 result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
34 assert(SL_RESULT_SUCCESS == result);
35 result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
36 assert(SL_RESULT_SUCCESS == result);
37
38 // configure a typical audio source of 44.1 kHz stereo 16-bit little endian
39 SLDataLocator_BufferQueue loc_bufq;
40 loc_bufq.locatorType = SL_DATALOCATOR_BUFFERQUEUE;
41 loc_bufq.numBuffers = 1;
42 SLDataFormat_PCM format_pcm;
43 format_pcm.formatType = SL_DATAFORMAT_PCM;
44 format_pcm.numChannels = 2;
45 format_pcm.samplesPerSec = SL_SAMPLINGRATE_44_1;
46 format_pcm.bitsPerSample = 16;
47 format_pcm.containerSize = 16;
48 format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
49 format_pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
50 SLDataSource audioSrc;
51 audioSrc.pLocator = &loc_bufq;
52 audioSrc.pFormat = &format_pcm;
53
54 // configure audio sink
55 SLDataLocator_OutputMix loc_outmix;
56 loc_outmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
57 loc_outmix.outputMix = NULL;
58 SLDataSink audioSnk;
59 audioSnk.pLocator = &loc_outmix;
60 audioSnk.pFormat = NULL;
61
62 // create audio player using a NULL output mix
63 SLInterfaceID ids[1] = {SL_IID_BUFFERQUEUE};
64 SLboolean req[1] = {SL_BOOLEAN_TRUE};
65 SLObjectItf playerObject;
66 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
67 &audioSnk, 1, ids, req);
68 assert(SL_RESULT_PARAMETER_INVALID == result);
69 assert(NULL == playerObject);
70
71 // create audio player using an engine as the output mix
72 loc_outmix.outputMix = engineObject;
73 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
74 &audioSnk, 1, ids, req);
75 assert(SL_RESULT_PARAMETER_INVALID == result);
76 assert(NULL == playerObject);
77
78 // create output mix but don't realize it yet
79 SLObjectItf outputMixObject;
80 result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, NULL, NULL);
81 assert(SL_RESULT_SUCCESS == result);
82
83 // create audio player using the unrealized output mix
84 loc_outmix.outputMix = outputMixObject;
85 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
86 &audioSnk, 1, ids, req);
87 assert(SL_RESULT_PRECONDITIONS_VIOLATED == result);
88 assert(NULL == playerObject);
89
90 // now realize the output mix
91 result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
92 assert(SL_RESULT_SUCCESS == result);
93
94 // create audio player using the realized output mix
95 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
96 &audioSnk, 1, ids, req);
97 assert(SL_RESULT_SUCCESS == result);
98 assert(NULL != playerObject);
99
100 // destroy player
101 (*playerObject)->Destroy(playerObject);
102
103 // now try to create audio player using various unusual parameters
104
105 // number of channels
106 format_pcm.numChannels = 0;
107 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
108 &audioSnk, 1, ids, req);
109 assert(SL_RESULT_PARAMETER_INVALID == result);
110 assert(NULL == playerObject);
111 format_pcm.numChannels = 3;
112 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
113 &audioSnk, 1, ids, req);
114 assert(SL_RESULT_CONTENT_UNSUPPORTED == result);
115 assert(NULL == playerObject);
116 format_pcm.numChannels = 2;
117
118 // sample rate
119 format_pcm.samplesPerSec = 0;
120 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
121 &audioSnk, 1, ids, req);
122 assert(SL_RESULT_PARAMETER_INVALID == result);
123 assert(NULL == playerObject);
124 format_pcm.samplesPerSec = 1000;
125 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
126 &audioSnk, 1, ids, req);
127 assert(SL_RESULT_CONTENT_UNSUPPORTED == result);
128 assert(NULL == playerObject);
129 format_pcm.samplesPerSec = SL_SAMPLINGRATE_44_1;
130
131 // bits per sample
132 format_pcm.bitsPerSample = 17;
133 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
134 &audioSnk, 1, ids, req);
135 assert(SL_RESULT_PARAMETER_INVALID == result);
136 assert(NULL == playerObject);
137 format_pcm.bitsPerSample = 24;
138 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
139 &audioSnk, 1, ids, req);
140 assert(SL_RESULT_CONTENT_UNSUPPORTED == result);
141 assert(NULL == playerObject);
142 format_pcm.bitsPerSample = 16;
143
144 // container size
145 format_pcm.containerSize = 8;
146 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
147 &audioSnk, 1, ids, req);
148 #if 0
149 assert(SL_RESULT_PARAMETER_INVALID == result);
150 assert(NULL == playerObject);
151 #else
152 if (SL_RESULT_PARAMETER_INVALID == result) {
153 printf("ERROR: expected SL_RESULT_PARAMETER_INVALID\n");
154 if (NULL != playerObject)
155 (*playerObject)->Destroy(playerObject);
156 }
157 #endif
158 format_pcm.containerSize = 32;
159 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
160 &audioSnk, 1, ids, req);
161 assert(SL_RESULT_CONTENT_UNSUPPORTED == result);
162 assert(NULL == playerObject);
163 format_pcm.containerSize = 16;
164
165 // channel mask
166 format_pcm.channelMask = 0;
167 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
168 &audioSnk, 1, ids, req);
169 assert(SL_RESULT_SUCCESS == result);
170 assert(NULL != playerObject);
171 (*playerObject)->Destroy(playerObject);
172 format_pcm.channelMask = SL_SPEAKER_FRONT_CENTER;
173 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
174 &audioSnk, 1, ids, req);
175 assert(SL_RESULT_PARAMETER_INVALID == result);
176 assert(NULL == playerObject);
177 format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
178 SL_SPEAKER_FRONT_CENTER;
179 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
180 &audioSnk, 1, ids, req);
181 assert(SL_RESULT_PARAMETER_INVALID == result);
182 assert(NULL == playerObject);
183 format_pcm.numChannels = 1;
184 format_pcm.channelMask = 0;
185 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
186 &audioSnk, 1, ids, req);
187 assert(SL_RESULT_SUCCESS == result);
188 assert(NULL != playerObject);
189 (*playerObject)->Destroy(playerObject);
190 format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
191 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
192 &audioSnk, 1, ids, req);
193 assert(SL_RESULT_PARAMETER_INVALID == result);
194 assert(NULL == playerObject);
195 format_pcm.numChannels = 2;
196
197 // endianness
198 format_pcm.endianness = SL_BYTEORDER_BIGENDIAN;
199 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
200 &audioSnk, 1, ids, req);
201 #ifdef ANDROID // known bug on SDL
202 assert(SL_RESULT_CONTENT_UNSUPPORTED == result);
203 assert(NULL == playerObject);
204 #else
205 if (SL_RESULT_CONTENT_UNSUPPORTED != result) {
206 printf("ERROR: expected SL_RESULT_CONTENT_UNSUPPORTED\n");
207 if (NULL != playerObject)
208 (*playerObject)->Destroy(playerObject);
209 }
210 #endif
211 format_pcm.endianness = 0;
212 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
213 &audioSnk, 1, ids, req);
214 assert(SL_RESULT_PARAMETER_INVALID == result);
215 assert(NULL == playerObject);
216 format_pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
217
218 // destroy output mix
219 (*outputMixObject)->Destroy(outputMixObject);
220
221 // destroy engine
222 (*engineObject)->Destroy(engineObject);
223
224 return EXIT_SUCCESS;
225 }
226