srcsink.c revision 2246c698482ab6860906672229f0ae6d886e6302 
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
24int 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    assert(SL_RESULT_PARAMETER_INVALID == result);
149    assert(NULL == playerObject);
150    format_pcm.containerSize = 32;
151    result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
152            &audioSnk, 1, ids, req);
153    assert(SL_RESULT_CONTENT_UNSUPPORTED == result);
154    assert(NULL == playerObject);
155    format_pcm.containerSize = 16;
156
157    // channel mask
158    format_pcm.channelMask = 0;
159    result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
160            &audioSnk, 1, ids, req);
161    assert(SL_RESULT_SUCCESS == result);
162    assert(NULL != playerObject);
163    (*playerObject)->Destroy(playerObject);
164    format_pcm.channelMask = SL_SPEAKER_FRONT_CENTER;
165    result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
166            &audioSnk, 1, ids, req);
167    assert(SL_RESULT_PARAMETER_INVALID == result);
168    assert(NULL == playerObject);
169    format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT |
170            SL_SPEAKER_FRONT_CENTER;
171    result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
172            &audioSnk, 1, ids, req);
173    assert(SL_RESULT_PARAMETER_INVALID == result);
174    assert(NULL == playerObject);
175    format_pcm.numChannels = 1;
176    format_pcm.channelMask = 0;
177    result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
178            &audioSnk, 1, ids, req);
179    assert(SL_RESULT_SUCCESS == result);
180    assert(NULL != playerObject);
181    (*playerObject)->Destroy(playerObject);
182    format_pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
183    result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
184            &audioSnk, 1, ids, req);
185    assert(SL_RESULT_PARAMETER_INVALID == result);
186    assert(NULL == playerObject);
187    format_pcm.numChannels = 2;
188
189    // endianness
190    format_pcm.endianness = SL_BYTEORDER_BIGENDIAN;
191    result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
192            &audioSnk, 1, ids, req);
193#ifdef ANDROID // known bug on SDL
194    assert(SL_RESULT_CONTENT_UNSUPPORTED == result);
195    assert(NULL == playerObject);
196#else
197    if (SL_RESULT_CONTENT_UNSUPPORTED != result) {
198        printf("ERROR: expected SL_RESULT_CONTENT_UNSUPPORTED\n");
199        if (NULL != playerObject)
200            (*playerObject)->Destroy(playerObject);
201    }
202#endif
203    format_pcm.endianness = 0;
204    result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
205            &audioSnk, 1, ids, req);
206    assert(SL_RESULT_PARAMETER_INVALID == result);
207    assert(NULL == playerObject);
208    format_pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
209
210    // destroy output mix
211    (*outputMixObject)->Destroy(outputMixObject);
212
213    // destroy engine
214    (*engineObject)->Destroy(engineObject);
215
216    return EXIT_SUCCESS;
217}
218