tests/examples/slesTestFeedback.cpp - platform/frameworks/wilhelm - Git at Google

 /*
  * 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 program to record from default audio input and playback to default audio output.
 // It will generate feedback (Larsen effect) if played through on-device speakers,
 // or acts as a delay if played through headset.

 #include <SLES/OpenSLES.h>
 #include <SLES/OpenSLES_Android.h>
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>

 #define ASSERT_EQ(x, y) do { if ((x) == (y)) ; else { fprintf(stderr, "0x%x != 0x%x\n", \
     (unsigned) (x), (unsigned) (y)); assert((x) == (y)); } } while (0)

 // default values
 static SLuint32 rxBufCount = 2;     // -r#
 static SLuint32 txBufCount = 2;     // -t#
 static SLuint32 bufSizeInFrames = 512;  // -f#
 static SLuint32 channels = 1;       // -c#
 static SLuint32 sampleRate = 44100; // -s#
 static SLuint32 exitAfterSeconds = 60; // -e#
 static SLuint32 freeBufCount = 0;   // calculated
 static SLuint32 bufSizeInBytes = 0; // calculated

 // Storage area for the buffer queues
 static char **rxBuffers;
 static char **txBuffers;
 static char **freeBuffers;

 // Buffer indices
 static SLuint32 rxFront;    // oldest recording
 static SLuint32 rxRear;     // next to be recorded
 static SLuint32 txFront;    // oldest playing
 static SLuint32 txRear;     // next to be played
 static SLuint32 freeFront;  // oldest free
 static SLuint32 freeRear;   // next to be freed

 static SLAndroidSimpleBufferQueueItf recorderBufferQueue;
 static SLBufferQueueItf playerBufferQueue;

 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

 // Called after audio recorder fills a buffer with data
 static void recorderCallback(SLAndroidSimpleBufferQueueItf caller, void *context)
 {
     SLresult result;

     pthread_mutex_lock(&mutex);

     // We should only be called when a recording buffer is done
     assert(rxFront <= rxBufCount);
     assert(rxRear <= rxBufCount);
     assert(rxFront != rxRear);
     char *buffer = rxBuffers[rxFront];

     // Remove buffer from record queue
     if (++rxFront > rxBufCount) {
         rxFront = 0;
     }

     // Enqueue the just-filled buffer for the player
     result = (*playerBufferQueue)->Enqueue(playerBufferQueue, buffer, bufSizeInBytes);
     if (SL_RESULT_SUCCESS == result) {

         // There was room in the play queue, update our model of it
         assert(txFront <= txBufCount);
         assert(txRear <= txBufCount);
         SLuint32 txRearNext = txRear+1;
         if (txRearNext > txBufCount) {
             txRearNext = 0;
         }
         assert(txRearNext != txFront);
         txBuffers[txRear] = buffer;
         txRear = txRearNext;

     } else {

         // Here if record has a filled buffer to play, but play queue is full.
         assert(SL_RESULT_BUFFER_INSUFFICIENT == result);
         write(1, "?", 1);

         // We could either try again later, or discard. For now we discard and re-use buffer.
         // Enqueue this same buffer for the recorder to fill again.
         result = (*recorderBufferQueue)->Enqueue(recorderBufferQueue, buffer, bufSizeInBytes);
         ASSERT_EQ(SL_RESULT_SUCCESS, result);

         // Update our model of the record queue
         SLuint32 rxRearNext = rxRear+1;
         if (rxRearNext > rxBufCount) {
             rxRearNext = 0;
         }
         assert(rxRearNext != rxFront);
         rxBuffers[rxRear] = buffer;
         rxRear = rxRearNext;

     }

     pthread_mutex_unlock(&mutex);
 }


 // Called after audio player empties a buffer of data
 static void playerCallback(SLBufferQueueItf caller, void *context)
 {
     SLresult result;

     pthread_mutex_lock(&mutex);

     // Get the buffer that just finished playing
     assert(txFront <= txBufCount);
     assert(txRear <= txBufCount);
     assert(txFront != txRear);
     char *buffer = txBuffers[txFront];
     if (++txFront > txBufCount) {
         txFront = 0;
     }

     // First try to enqueue the free buffer for recording
     result = (*recorderBufferQueue)->Enqueue(recorderBufferQueue, buffer, bufSizeInBytes);
     if (SL_RESULT_SUCCESS == result) {

         // There was room in the record queue, update our model of it
         assert(rxFront <= rxBufCount);
         assert(rxRear <= rxBufCount);
         SLuint32 rxRearNext = rxRear+1;
         if (rxRearNext > rxBufCount) {
             rxRearNext = 0;
         }
         assert(rxRearNext != rxFront);
         rxBuffers[rxRear] = buffer;
         rxRear = rxRearNext;

     } else {

         // Here if record queue is full
         assert(SL_RESULT_BUFFER_INSUFFICIENT == result);

         // Instead enqueue the free buffer on the free queue
         assert(freeFront <= freeBufCount);
         assert(freeRear <= freeBufCount);
         SLuint32 freeRearNext = freeRear+1;
         if (freeRearNext > freeBufCount) {
             freeRearNext = 0;
         }
         // There must always be room in the free queue
         assert(freeRearNext != freeFront);
         freeBuffers[freeRear] = buffer;
         freeRear = freeRearNext;

     }

     pthread_mutex_unlock(&mutex);
 }

 // Main program
 int main(int argc, char **argv)
 {
     // process command-line options
     int i;
     for (i = 1; i < argc; ++i) {
         char *arg = argv[i];
         if (arg[0] != '-') {
             break;
         }
         // -r# number of slots in receive buffer queue
         if (!strncmp(arg, "-r", 2)) {
             rxBufCount = atoi(&arg[2]);
             if (rxBufCount < 1 || rxBufCount > 16) {
                 fprintf(stderr, "%s: unusual receive buffer queue size (%u buffers)\n", argv[0],
                     (unsigned) rxBufCount);
             }
         // -t# number of slots in transmit buffer queue
         } else if (!strncmp(arg, "-t", 2)) {
             txBufCount = atoi(&arg[2]);
             if (txBufCount < 1 || txBufCount > 16) {
                 fprintf(stderr, "%s: unusual transmit buffer queue size (%u buffers)\n", argv[0],
                     (unsigned) txBufCount);
             }
         // -f# size of each buffer in frames
         } else if (!strncmp(arg, "-f", 2)) {
             bufSizeInFrames = atoi(&arg[2]);
             if (bufSizeInFrames == 0) {
                 fprintf(stderr, "%s: unusual buffer size (%u frames)\n", argv[0],
                     (unsigned) bufSizeInFrames);
             }
         // -c1 mono or -c2 stereo
         } else if (!strncmp(arg, "-c", 2)) {
             channels = atoi(&arg[2]);
             if (channels < 1 || channels > 2) {
                 fprintf(stderr, "%s: unusual channel count ignored (%u)\n", argv[0],
                     (unsigned) channels);
                 channels = 2;
             }
         // -s# sample rate in Hz
         } else if (!strncmp(arg, "-s", 2)) {
             sampleRate = atoi(&arg[2]);
             switch (sampleRate) {
             case 8000:
             case 11025:
             case 12000:
             case 16000:
             case 22050:
             case 24000:
             case 32000:
             case 44100:
             case 48000:
                 break;
             default:
                 fprintf(stderr, "%s: unusual sample rate (%u Hz)\n", argv[0],
                     (unsigned) sampleRate);
                 break;
             }
         // -e# exit after this many seconds
         } else if (!strncmp(arg, "-e", 2)) {
             exitAfterSeconds = atoi(&arg[2]);
         } else
             fprintf(stderr, "%s: unknown option %s\n", argv[0], arg);
     }
     // no other arguments allowed
     if (i < argc) {
         fprintf(stderr, "usage: %s -r# -t# -f# -s# -c#\n", argv[0]);
         fprintf(stderr, "  -r# receive buffer queue count for microphone input, default 1\n");
         fprintf(stderr, "  -t# transmit buffer queue count for speaker output, default 2\n");
         fprintf(stderr, "  -f# number of frames per buffer, default 512\n");
         fprintf(stderr, "  -s# sample rate in Hz, default 44100\n");
         fprintf(stderr, "  -c1 mono\n");
         fprintf(stderr, "  -c2 stereo, default\n");
     }
     // compute total free buffers as -r plus -t
     freeBufCount = rxBufCount + txBufCount;
     // compute buffer size
     bufSizeInBytes = channels * bufSizeInFrames * sizeof(short);

     // Initialize free buffers
     freeBuffers = (char **) calloc(freeBufCount+1, sizeof(char *));
     unsigned j;
     for (j = 0; j < freeBufCount; ++j) {
         freeBuffers[j] = (char *) malloc(bufSizeInBytes);
     }
     freeFront = 0;
     freeRear = freeBufCount;
     freeBuffers[j] = NULL;

     // Initialize record queue
     rxBuffers = (char **) calloc(rxBufCount+1, sizeof(char *));
     rxFront = 0;
     rxRear = 0;

     // Initialize play queue
     txBuffers = (char **) calloc(txBufCount+1, sizeof(char *));
     txFront = 0;
     txRear = 0;

     SLresult result;

     // create engine
     SLObjectItf engineObject;
     result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     SLEngineItf engineEngine;
     result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);

     // create output mix
     SLObjectItf outputmixObject;
     result = (*engineEngine)->CreateOutputMix(engineEngine, &outputmixObject, 0, NULL, NULL);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     result = (*outputmixObject)->Realize(outputmixObject, SL_BOOLEAN_FALSE);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);

     // create an audio player with buffer queue source and output mix sink
     SLDataSource audiosrc;
     SLDataSink audiosnk;
     SLDataFormat_PCM pcm;
     SLDataLocator_OutputMix locator_outputmix;
     SLDataLocator_BufferQueue locator_bufferqueue_tx;
     locator_bufferqueue_tx.locatorType = SL_DATALOCATOR_BUFFERQUEUE;
     locator_bufferqueue_tx.numBuffers = txBufCount;
     locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
     locator_outputmix.outputMix = outputmixObject;
     pcm.formatType = SL_DATAFORMAT_PCM;
     pcm.numChannels = channels;
     pcm.samplesPerSec = sampleRate * 1000;
     pcm.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
     pcm.containerSize = 16;
     pcm.channelMask = channels == 1 ? SL_SPEAKER_FRONT_CENTER :
         (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT);
     pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
     audiosrc.pLocator = &locator_bufferqueue_tx;
     audiosrc.pFormat = &pcm;
     audiosnk.pLocator = &locator_outputmix;
     audiosnk.pFormat = NULL;
     SLObjectItf playerObject = NULL;
     SLObjectItf recorderObject = NULL;
     SLInterfaceID ids_tx[1] = {SL_IID_BUFFERQUEUE};
     SLboolean flags_tx[1] = {SL_BOOLEAN_TRUE};
     result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audiosrc, &audiosnk,
         1, ids_tx, flags_tx);
     if (SL_RESULT_CONTENT_UNSUPPORTED == result) {
         fprintf(stderr, "Could not create audio player (result %x), check sample rate\n", result);
         goto cleanup;
     }
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     SLPlayItf playerPlay;
     result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     result = (*playerObject)->GetInterface(playerObject, SL_IID_BUFFERQUEUE, &playerBufferQueue);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     result = (*playerBufferQueue)->RegisterCallback(playerBufferQueue, playerCallback, NULL);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PLAYING);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);

     // Create an audio recorder with microphone device source and buffer queue sink.
     // The buffer queue as sink is an Android-specific extension.

     SLDataLocator_IODevice locator_iodevice;
     SLDataLocator_AndroidSimpleBufferQueue locator_bufferqueue_rx;
     locator_iodevice.locatorType = SL_DATALOCATOR_IODEVICE;
     locator_iodevice.deviceType = SL_IODEVICE_AUDIOINPUT;
     locator_iodevice.deviceID = SL_DEFAULTDEVICEID_AUDIOINPUT;
     locator_iodevice.device = NULL;
     audiosrc.pLocator = &locator_iodevice;
     audiosrc.pFormat = NULL;
     locator_bufferqueue_rx.locatorType = SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE;
     locator_bufferqueue_rx.numBuffers = rxBufCount;
     audiosnk.pLocator = &locator_bufferqueue_rx;
     audiosnk.pFormat = &pcm;
     {
     SLInterfaceID ids_rx[1] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE};
     SLboolean flags_rx[1] = {SL_BOOLEAN_TRUE};
     result = (*engineEngine)->CreateAudioRecorder(engineEngine, &recorderObject, &audiosrc,
         &audiosnk, 1, ids_rx, flags_rx);
     if (SL_RESULT_SUCCESS != result) {
         fprintf(stderr, "Could not create audio recorder (result %x), "
                 "check sample rate and channel count\n", result);
         goto cleanup;
     }
     }
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     result = (*recorderObject)->Realize(recorderObject, SL_BOOLEAN_FALSE);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     SLRecordItf recorderRecord;
     result = (*recorderObject)->GetInterface(recorderObject, SL_IID_RECORD, &recorderRecord);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     result = (*recorderObject)->GetInterface(recorderObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
         &recorderBufferQueue);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);
     result = (*recorderBufferQueue)->RegisterCallback(recorderBufferQueue, recorderCallback, NULL);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);

     // Enqueue some empty buffers for the recorder
     for (j = 0; j < rxBufCount; ++j) {

         // allocate a free buffer
         assert(freeFront != freeRear);
         char *buffer = freeBuffers[freeFront];
         if (++freeFront > freeBufCount) {
             freeFront = 0;
         }

         // put on record queue
         SLuint32 rxRearNext = rxRear + 1;
         if (rxRearNext > rxBufCount) {
             rxRearNext = 0;
         }
         assert(rxRearNext != rxFront);
         rxBuffers[rxRear] = buffer;
         rxRear = rxRearNext;
         result = (*recorderBufferQueue)->Enqueue(recorderBufferQueue,
             buffer, bufSizeInBytes);
         ASSERT_EQ(SL_RESULT_SUCCESS, result);
     }

     // Kick off the recorder
     result = (*recorderRecord)->SetRecordState(recorderRecord, SL_RECORDSTATE_RECORDING);
     ASSERT_EQ(SL_RESULT_SUCCESS, result);

     // Wait patiently
     do {
         usleep(1000000);
         write(1, ".", 1);
         SLBufferQueueState playerBQState;
         result = (*playerBufferQueue)->GetState(playerBufferQueue, &playerBQState);
         ASSERT_EQ(SL_RESULT_SUCCESS, result);
         SLAndroidSimpleBufferQueueState recorderBQState;
         result = (*recorderBufferQueue)->GetState(recorderBufferQueue, &recorderBQState);
         ASSERT_EQ(SL_RESULT_SUCCESS, result);
     } while (--exitAfterSeconds);

     // Tear down the objects and exit
 cleanup:
     if (NULL != playerObject) {
         (*playerObject)->Destroy(playerObject);
     }
     if (NULL != recorderObject) {
         (*recorderObject)->Destroy(recorderObject);
     }
     (*outputmixObject)->Destroy(outputmixObject);
     (*engineObject)->Destroy(engineObject);

     return EXIT_SUCCESS;
 }
	/*
	* 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 program to record from default audio input and playback to default audio output.
	// It will generate feedback (Larsen effect) if played through on-device speakers,
	// or acts as a delay if played through headset.

	#include <SLES/OpenSLES.h>
	#include <SLES/OpenSLES_Android.h>
	#include <assert.h>
	#include <pthread.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>

	#define ASSERT_EQ(x, y) do { if ((x) == (y)) ; else { fprintf(stderr, "0x%x != 0x%x\n", \
	(unsigned) (x), (unsigned) (y)); assert((x) == (y)); } } while (0)

	// default values
	static SLuint32 rxBufCount = 2; // -r#
	static SLuint32 txBufCount = 2; // -t#
	static SLuint32 bufSizeInFrames = 512; // -f#
	static SLuint32 channels = 1; // -c#
	static SLuint32 sampleRate = 44100; // -s#
	static SLuint32 exitAfterSeconds = 60; // -e#
	static SLuint32 freeBufCount = 0; // calculated
	static SLuint32 bufSizeInBytes = 0; // calculated

	// Storage area for the buffer queues
	static char **rxBuffers;
	static char **txBuffers;
	static char **freeBuffers;

	// Buffer indices
	static SLuint32 rxFront; // oldest recording
	static SLuint32 rxRear; // next to be recorded
	static SLuint32 txFront; // oldest playing
	static SLuint32 txRear; // next to be played
	static SLuint32 freeFront; // oldest free
	static SLuint32 freeRear; // next to be freed

	static SLAndroidSimpleBufferQueueItf recorderBufferQueue;
	static SLBufferQueueItf playerBufferQueue;

	static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

	// Called after audio recorder fills a buffer with data
	static void recorderCallback(SLAndroidSimpleBufferQueueItf caller, void *context)
	{
	SLresult result;

	pthread_mutex_lock(&mutex);

	// We should only be called when a recording buffer is done
	assert(rxFront <= rxBufCount);
	assert(rxRear <= rxBufCount);
	assert(rxFront != rxRear);
	char *buffer = rxBuffers[rxFront];

	// Remove buffer from record queue
	if (++rxFront > rxBufCount) {
	rxFront = 0;
	}

	// Enqueue the just-filled buffer for the player
	result = (*playerBufferQueue)->Enqueue(playerBufferQueue, buffer, bufSizeInBytes);
	if (SL_RESULT_SUCCESS == result) {

	// There was room in the play queue, update our model of it
	assert(txFront <= txBufCount);
	assert(txRear <= txBufCount);
	SLuint32 txRearNext = txRear+1;
	if (txRearNext > txBufCount) {
	txRearNext = 0;
	}
	assert(txRearNext != txFront);
	txBuffers[txRear] = buffer;
	txRear = txRearNext;

	} else {

	// Here if record has a filled buffer to play, but play queue is full.
	assert(SL_RESULT_BUFFER_INSUFFICIENT == result);
	write(1, "?", 1);

	// We could either try again later, or discard. For now we discard and re-use buffer.
	// Enqueue this same buffer for the recorder to fill again.
	result = (*recorderBufferQueue)->Enqueue(recorderBufferQueue, buffer, bufSizeInBytes);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);

	// Update our model of the record queue
	SLuint32 rxRearNext = rxRear+1;
	if (rxRearNext > rxBufCount) {
	rxRearNext = 0;
	}
	assert(rxRearNext != rxFront);
	rxBuffers[rxRear] = buffer;
	rxRear = rxRearNext;

	}

	pthread_mutex_unlock(&mutex);
	}


	// Called after audio player empties a buffer of data
	static void playerCallback(SLBufferQueueItf caller, void *context)
	{
	SLresult result;

	pthread_mutex_lock(&mutex);

	// Get the buffer that just finished playing
	assert(txFront <= txBufCount);
	assert(txRear <= txBufCount);
	assert(txFront != txRear);
	char *buffer = txBuffers[txFront];
	if (++txFront > txBufCount) {
	txFront = 0;
	}

	// First try to enqueue the free buffer for recording
	result = (*recorderBufferQueue)->Enqueue(recorderBufferQueue, buffer, bufSizeInBytes);
	if (SL_RESULT_SUCCESS == result) {

	// There was room in the record queue, update our model of it
	assert(rxFront <= rxBufCount);
	assert(rxRear <= rxBufCount);
	SLuint32 rxRearNext = rxRear+1;
	if (rxRearNext > rxBufCount) {
	rxRearNext = 0;
	}
	assert(rxRearNext != rxFront);
	rxBuffers[rxRear] = buffer;
	rxRear = rxRearNext;

	} else {

	// Here if record queue is full
	assert(SL_RESULT_BUFFER_INSUFFICIENT == result);

	// Instead enqueue the free buffer on the free queue
	assert(freeFront <= freeBufCount);
	assert(freeRear <= freeBufCount);
	SLuint32 freeRearNext = freeRear+1;
	if (freeRearNext > freeBufCount) {
	freeRearNext = 0;
	}
	// There must always be room in the free queue
	assert(freeRearNext != freeFront);
	freeBuffers[freeRear] = buffer;
	freeRear = freeRearNext;

	}

	pthread_mutex_unlock(&mutex);
	}

	// Main program
	int main(int argc, char **argv)
	{
	// process command-line options
	int i;
	for (i = 1; i < argc; ++i) {
	char *arg = argv[i];
	if (arg[0] != '-') {
	break;
	}
	// -r# number of slots in receive buffer queue
	if (!strncmp(arg, "-r", 2)) {
	rxBufCount = atoi(&arg[2]);
	if (rxBufCount < 1 \|\| rxBufCount > 16) {
	fprintf(stderr, "%s: unusual receive buffer queue size (%u buffers)\n", argv[0],
	(unsigned) rxBufCount);
	}
	// -t# number of slots in transmit buffer queue
	} else if (!strncmp(arg, "-t", 2)) {
	txBufCount = atoi(&arg[2]);
	if (txBufCount < 1 \|\| txBufCount > 16) {
	fprintf(stderr, "%s: unusual transmit buffer queue size (%u buffers)\n", argv[0],
	(unsigned) txBufCount);
	}
	// -f# size of each buffer in frames
	} else if (!strncmp(arg, "-f", 2)) {
	bufSizeInFrames = atoi(&arg[2]);
	if (bufSizeInFrames == 0) {
	fprintf(stderr, "%s: unusual buffer size (%u frames)\n", argv[0],
	(unsigned) bufSizeInFrames);
	}
	// -c1 mono or -c2 stereo
	} else if (!strncmp(arg, "-c", 2)) {
	channels = atoi(&arg[2]);
	if (channels < 1 \|\| channels > 2) {
	fprintf(stderr, "%s: unusual channel count ignored (%u)\n", argv[0],
	(unsigned) channels);
	channels = 2;
	}
	// -s# sample rate in Hz
	} else if (!strncmp(arg, "-s", 2)) {
	sampleRate = atoi(&arg[2]);
	switch (sampleRate) {
	case 8000:
	case 11025:
	case 12000:
	case 16000:
	case 22050:
	case 24000:
	case 32000:
	case 44100:
	case 48000:
	break;
	default:
	fprintf(stderr, "%s: unusual sample rate (%u Hz)\n", argv[0],
	(unsigned) sampleRate);
	break;
	}
	// -e# exit after this many seconds
	} else if (!strncmp(arg, "-e", 2)) {
	exitAfterSeconds = atoi(&arg[2]);
	} else
	fprintf(stderr, "%s: unknown option %s\n", argv[0], arg);
	}
	// no other arguments allowed
	if (i < argc) {
	fprintf(stderr, "usage: %s -r# -t# -f# -s# -c#\n", argv[0]);
	fprintf(stderr, " -r# receive buffer queue count for microphone input, default 1\n");
	fprintf(stderr, " -t# transmit buffer queue count for speaker output, default 2\n");
	fprintf(stderr, " -f# number of frames per buffer, default 512\n");
	fprintf(stderr, " -s# sample rate in Hz, default 44100\n");
	fprintf(stderr, " -c1 mono\n");
	fprintf(stderr, " -c2 stereo, default\n");
	}
	// compute total free buffers as -r plus -t
	freeBufCount = rxBufCount + txBufCount;
	// compute buffer size
	bufSizeInBytes = channels * bufSizeInFrames * sizeof(short);

	// Initialize free buffers
	freeBuffers = (char *) calloc(freeBufCount+1, sizeof(char ));
	unsigned j;
	for (j = 0; j < freeBufCount; ++j) {
	freeBuffers[j] = (char *) malloc(bufSizeInBytes);
	}
	freeFront = 0;
	freeRear = freeBufCount;
	freeBuffers[j] = NULL;

	// Initialize record queue
	rxBuffers = (char *) calloc(rxBufCount+1, sizeof(char ));
	rxFront = 0;
	rxRear = 0;

	// Initialize play queue
	txBuffers = (char *) calloc(txBufCount+1, sizeof(char ));
	txFront = 0;
	txRear = 0;

	SLresult result;

	// create engine
	SLObjectItf engineObject;
	result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	SLEngineItf engineEngine;
	result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);

	// create output mix
	SLObjectItf outputmixObject;
	result = (*engineEngine)->CreateOutputMix(engineEngine, &outputmixObject, 0, NULL, NULL);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	result = (*outputmixObject)->Realize(outputmixObject, SL_BOOLEAN_FALSE);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);

	// create an audio player with buffer queue source and output mix sink
	SLDataSource audiosrc;
	SLDataSink audiosnk;
	SLDataFormat_PCM pcm;
	SLDataLocator_OutputMix locator_outputmix;
	SLDataLocator_BufferQueue locator_bufferqueue_tx;
	locator_bufferqueue_tx.locatorType = SL_DATALOCATOR_BUFFERQUEUE;
	locator_bufferqueue_tx.numBuffers = txBufCount;
	locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
	locator_outputmix.outputMix = outputmixObject;
	pcm.formatType = SL_DATAFORMAT_PCM;
	pcm.numChannels = channels;
	pcm.samplesPerSec = sampleRate * 1000;
	pcm.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
	pcm.containerSize = 16;
	pcm.channelMask = channels == 1 ? SL_SPEAKER_FRONT_CENTER :
	(SL_SPEAKER_FRONT_LEFT \| SL_SPEAKER_FRONT_RIGHT);
	pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
	audiosrc.pLocator = &locator_bufferqueue_tx;
	audiosrc.pFormat = &pcm;
	audiosnk.pLocator = &locator_outputmix;
	audiosnk.pFormat = NULL;
	SLObjectItf playerObject = NULL;
	SLObjectItf recorderObject = NULL;
	SLInterfaceID ids_tx[1] = {SL_IID_BUFFERQUEUE};
	SLboolean flags_tx[1] = {SL_BOOLEAN_TRUE};
	result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audiosrc, &audiosnk,
	1, ids_tx, flags_tx);
	if (SL_RESULT_CONTENT_UNSUPPORTED == result) {
	fprintf(stderr, "Could not create audio player (result %x), check sample rate\n", result);
	goto cleanup;
	}
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	SLPlayItf playerPlay;
	result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	result = (*playerObject)->GetInterface(playerObject, SL_IID_BUFFERQUEUE, &playerBufferQueue);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	result = (*playerBufferQueue)->RegisterCallback(playerBufferQueue, playerCallback, NULL);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PLAYING);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);

	// Create an audio recorder with microphone device source and buffer queue sink.
	// The buffer queue as sink is an Android-specific extension.

	SLDataLocator_IODevice locator_iodevice;
	SLDataLocator_AndroidSimpleBufferQueue locator_bufferqueue_rx;
	locator_iodevice.locatorType = SL_DATALOCATOR_IODEVICE;
	locator_iodevice.deviceType = SL_IODEVICE_AUDIOINPUT;
	locator_iodevice.deviceID = SL_DEFAULTDEVICEID_AUDIOINPUT;
	locator_iodevice.device = NULL;
	audiosrc.pLocator = &locator_iodevice;
	audiosrc.pFormat = NULL;
	locator_bufferqueue_rx.locatorType = SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE;
	locator_bufferqueue_rx.numBuffers = rxBufCount;
	audiosnk.pLocator = &locator_bufferqueue_rx;
	audiosnk.pFormat = &pcm;
	{
	SLInterfaceID ids_rx[1] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE};
	SLboolean flags_rx[1] = {SL_BOOLEAN_TRUE};
	result = (*engineEngine)->CreateAudioRecorder(engineEngine, &recorderObject, &audiosrc,
	&audiosnk, 1, ids_rx, flags_rx);
	if (SL_RESULT_SUCCESS != result) {
	fprintf(stderr, "Could not create audio recorder (result %x), "
	"check sample rate and channel count\n", result);
	goto cleanup;
	}
	}
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	result = (*recorderObject)->Realize(recorderObject, SL_BOOLEAN_FALSE);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	SLRecordItf recorderRecord;
	result = (*recorderObject)->GetInterface(recorderObject, SL_IID_RECORD, &recorderRecord);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	result = (*recorderObject)->GetInterface(recorderObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
	&recorderBufferQueue);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	result = (*recorderBufferQueue)->RegisterCallback(recorderBufferQueue, recorderCallback, NULL);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);

	// Enqueue some empty buffers for the recorder
	for (j = 0; j < rxBufCount; ++j) {

	// allocate a free buffer
	assert(freeFront != freeRear);
	char *buffer = freeBuffers[freeFront];
	if (++freeFront > freeBufCount) {
	freeFront = 0;
	}

	// put on record queue
	SLuint32 rxRearNext = rxRear + 1;
	if (rxRearNext > rxBufCount) {
	rxRearNext = 0;
	}
	assert(rxRearNext != rxFront);
	rxBuffers[rxRear] = buffer;
	rxRear = rxRearNext;
	result = (*recorderBufferQueue)->Enqueue(recorderBufferQueue,
	buffer, bufSizeInBytes);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	}

	// Kick off the recorder
	result = (*recorderRecord)->SetRecordState(recorderRecord, SL_RECORDSTATE_RECORDING);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);

	// Wait patiently
	do {
	usleep(1000000);
	write(1, ".", 1);
	SLBufferQueueState playerBQState;
	result = (*playerBufferQueue)->GetState(playerBufferQueue, &playerBQState);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	SLAndroidSimpleBufferQueueState recorderBQState;
	result = (*recorderBufferQueue)->GetState(recorderBufferQueue, &recorderBQState);
	ASSERT_EQ(SL_RESULT_SUCCESS, result);
	} while (--exitAfterSeconds);

	// Tear down the objects and exit
	cleanup:
	if (NULL != playerObject) {
	(*playerObject)->Destroy(playerObject);
	}
	if (NULL != recorderObject) {
	(*recorderObject)->Destroy(recorderObject);
	}
	(*outputmixObject)->Destroy(outputmixObject);
	(*engineObject)->Destroy(engineObject);

	return EXIT_SUCCESS;
	}