• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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  /* interactive buffer queue test program */
18  
19  #ifdef ANDROID
20  #define USE_ANDROID_SIMPLE_BUFFER_QUEUE     // change to #undef for compatibility testing
21  #endif
22  
23  #include <assert.h>
24  #include <math.h>
25  #include <stdio.h>
26  #include <stdlib.h>
27  #include <unistd.h>
28  #include <SLES/OpenSLES.h>
29  #ifdef USE_ANDROID_SIMPLE_BUFFER_QUEUE
30  #include <SLES/OpenSLES_Android.h>
31  #endif
32  #include "getch.h"
33  
34  #ifdef USE_ANDROID_SIMPLE_BUFFER_QUEUE
35  #define DATALOCATOR_BUFFERQUEUE SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE
36  #define IID_BUFFERQUEUE SL_IID_ANDROIDSIMPLEBUFFERQUEUE
37  #define BufferQueueItf SLAndroidSimpleBufferQueueItf
38  #define BufferQueueState SLAndroidSimpleBufferQueueState
39  #define INDEX index
40  #else
41  #define DATALOCATOR_BUFFERQUEUE SL_DATALOCATOR_BUFFERQUEUE
42  #define IID_BUFFERQUEUE SL_IID_BUFFERQUEUE
43  #define BufferQueueItf SLBufferQueueItf
44  #define BufferQueueState SLBufferQueueState
45  #define INDEX playIndex
46  #endif
47  
48  #define checkResult(r) do { if ((r) != SL_RESULT_SUCCESS) fprintf(stderr, "error %d at %s:%d\n", \
49      (int) (r), __FILE__, __LINE__); } while (0)
50  
51  typedef struct {
52      short left;
53      short right;
54  } frame_t;
55  
56  #define SINE_FRAMES (44100*5)
57  frame_t sine[SINE_FRAMES];
58  
59  #define SQUARE_FRAMES (44100*5)
60  frame_t square[SQUARE_FRAMES];
61  
62  #define SAWTOOTH_FRAMES (44100*5)
63  frame_t sawtooth[SAWTOOTH_FRAMES];
64  
65  #define HALF_FRAMES (44100*5)
66  frame_t half[HALF_FRAMES];
67  
68  BufferQueueItf expectedCaller = NULL;
69  void *expectedContext = NULL;
70  
71  static void callback(BufferQueueItf caller, void *context)
72  {
73      putchar('.');
74      if (caller != expectedCaller)
75          printf("caller %p expected %p\r\n", caller, expectedCaller);
76      if (context != expectedContext)
77          printf("context %p expected %p\r\n", context, expectedContext);
78      fflush(stdout);
79  }
80  
81  int main(int argc __unused, char **argv __unused)
82  {
83      SLresult result;
84  
85      // create engine
86      SLObjectItf engineObject;
87      result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
88      checkResult(result);
89      result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
90      checkResult(result);
91      SLEngineItf engineEngine;
92      result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
93      checkResult(result);
94  
95      // create output mix
96      SLObjectItf outputmixObject;
97      result = (*engineEngine)->CreateOutputMix(engineEngine, &outputmixObject, 0, NULL, NULL);
98      checkResult(result);
99      result = (*outputmixObject)->Realize(outputmixObject, SL_BOOLEAN_FALSE);
100      checkResult(result);
101  
102      // create audio player
103      SLDataSource audiosrc;
104      SLDataSink audiosnk;
105      SLDataFormat_PCM pcm;
106      SLDataLocator_OutputMix locator_outputmix;
107      SLDataLocator_BufferQueue locator_bufferqueue;
108      locator_bufferqueue.locatorType = DATALOCATOR_BUFFERQUEUE;
109      locator_bufferqueue.numBuffers = 255;
110      locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
111      locator_outputmix.outputMix = outputmixObject;
112      pcm.formatType = SL_DATAFORMAT_PCM;
113      pcm.numChannels = 2;
114      pcm.samplesPerSec = SL_SAMPLINGRATE_44_1;
115      pcm.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
116      pcm.containerSize = 16;
117      pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
118      pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
119      audiosrc.pLocator = &locator_bufferqueue;
120      audiosrc.pFormat = &pcm;
121      audiosnk.pLocator = &locator_outputmix;
122      audiosnk.pFormat = NULL;
123      SLObjectItf playerObject;
124      SLInterfaceID ids[2] = {IID_BUFFERQUEUE, SL_IID_MUTESOLO};
125      SLboolean flags[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
126      result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audiosrc, &audiosnk,
127              2, ids, flags);
128      checkResult(result);
129      result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
130      checkResult(result);
131      SLPlayItf playerPlay;
132      result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
133      checkResult(result);
134      BufferQueueItf playerBufferqueue;
135      result = (*playerObject)->GetInterface(playerObject, IID_BUFFERQUEUE, &playerBufferqueue);
136      checkResult(result);
137      SLMuteSoloItf playerMuteSolo;
138      result = (*playerObject)->GetInterface(playerObject, SL_IID_MUTESOLO, &playerMuteSolo);
139      checkResult(result);
140      SLuint8 numChannels = 123;
141      result = (*playerMuteSolo)->GetNumChannels(playerMuteSolo, &numChannels);
142      assert(2 == numChannels);
143      SLuint32 state;
144      state = SL_PLAYSTATE_PLAYING;
145      result = (*playerPlay)->SetPlayState(playerPlay, state);
146      checkResult(result);
147  
148      unsigned i;
149      float pi2 = 3.14*2;
150      float hz = 441;
151      float sr = 44100;
152      for (i = 0; i < SINE_FRAMES; ++i) {
153          sine[i].left = sin((float) (i  / (sr / hz)) * pi2 ) * 32000.0;
154          sine[i].right = sine[i].left;
155      }
156      for (i = 0; i < SQUARE_FRAMES; ++i) {
157          square[i].left = (i % (unsigned) (sr / hz)) < 50 ? 32767 : -32768;
158          square[i].right = square[i].left;
159      }
160      for (i = 0; i < SAWTOOTH_FRAMES; ++i) {
161          sawtooth[i].left = ((((int) (i % (unsigned) (sr / hz))) - 50) / 100.0) * 60000.0 - 30000.0;
162          sawtooth[i].right = sawtooth[i].left;
163      }
164      for (i = 0; i < HALF_FRAMES; ++i) {
165          half[i].left = sine[i].left;
166          half[i].right = sawtooth[i].right / 2;
167      }
168  
169      set_conio_terminal_mode();
170      int in_count = 0;
171      uintptr_t count = 0;
172      for (;;) {
173          usleep(10000);
174          if (kbhit()) {
175              frame_t *buffer;
176              unsigned size;
177              BufferQueueState bufqstate;
178              int ch = getch();
179              switch (ch) {
180              case '0' ... '9':
181                  if (in_count) {
182                      count = count * 10 + (ch - '0');
183                  } else {
184                      count = ch - '0';
185                      in_count = 1;
186                  }
187                  continue;
188              case 'i':
189                  buffer = sine;
190                  size = sizeof(sine);
191                  goto enqueue;
192              case 'q':
193                  buffer = square;
194                  size = sizeof(square);
195                  goto enqueue;
196              case 'h':
197                  buffer = half;
198                  size = sizeof(half);
199                  goto enqueue;
200              case 'r':
201                  if (in_count) {
202                      expectedCaller = playerBufferqueue;
203                      expectedContext = (void *) count;
204                  } else {
205                      expectedCaller = NULL;
206                      expectedContext = (void *) NULL;
207                  }
208                  result = (*playerBufferqueue)->RegisterCallback(playerBufferqueue, in_count ?
209                      callback : NULL, expectedContext);
210                  checkResult(result);
211                  break;
212              case 'a':
213                  buffer = sawtooth;
214                  size = sizeof(sawtooth);
215  enqueue:
216                  for (i = 0; i < (in_count ? count : 1); ++i) {
217                      result = (*playerBufferqueue)->Enqueue(playerBufferqueue, buffer, size);
218                      checkResult(result);
219                  }
220                  break;
221              case 'c':
222                  result = (*playerBufferqueue)->Clear(playerBufferqueue);
223                  checkResult(result);
224                  putchar('\r');
225                  result = (*playerBufferqueue)->GetState(playerBufferqueue, &bufqstate);
226                  checkResult(result);
227                  if (bufqstate.count != 0)
228                      printf("\rcount=%u\r\n", (unsigned) bufqstate.count);
229  #if 0
230                  putchar('\r');
231                  putchar('\n');
232  #endif
233                  fflush(stdout);
234                  break;
235              case 'g':
236                  result = (*playerBufferqueue)->GetState(playerBufferqueue, &bufqstate);
237                  checkResult(result);
238                  printf("\rplayIndex=%u\r\n", (unsigned) bufqstate.INDEX);
239                  printf("count=%u\r\n", (unsigned) bufqstate.count);
240                  break;
241              case 'p':
242                  state = SL_PLAYSTATE_PAUSED;
243                  goto setplaystate;
244              case 's':
245                  state = SL_PLAYSTATE_STOPPED;
246                  goto setplaystate;
247              case 'P':
248                  state = SL_PLAYSTATE_PLAYING;
249  setplaystate:
250                  result = (*playerPlay)->SetPlayState(playerPlay, state);
251                  checkResult(result);
252                  SLuint32 newstate;
253                  result = (*playerPlay)->GetPlayState(playerPlay, &newstate);
254                  checkResult(result);
255                  if (newstate != state)
256                      printf("\rSetPlayState(%u) -> GetPlayState(%u)\r\n", (unsigned) state,
257                          (unsigned) newstate);
258  #if 0
259                  putchar('\r');
260                  putchar('\n');
261                  fflush(stdout);
262  #endif
263                  checkResult(result);
264                  break;
265              case 'x':
266                  goto out;
267              default:
268                  putchar('?');
269                  fflush(stdout);
270                  break;
271              }
272              in_count = 0;
273          }
274      }
275  
276  out:
277      (*playerObject)->Destroy(playerObject);
278      (*outputmixObject)->Destroy(outputmixObject);
279      (*engineObject)->Destroy(engineObject);
280      return EXIT_SUCCESS;
281  }
282