| /* |
| * Copyright (C) 2015 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. |
| */ |
| |
| |
| //////////////////////////////////////////// |
| /// Actual sles functions. |
| |
| |
| // 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.h" |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stddef.h> |
| |
| #include <assert.h> |
| #include <pthread.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| int slesInit(sles_data ** ppSles, int samplingRate, int frameCount, int micSource) { |
| int status = SLES_FAIL; |
| if (ppSles != NULL) { |
| sles_data * pSles = (sles_data*) calloc(1, sizeof (sles_data)); |
| |
| SLES_PRINTF("malloc %d bytes at %p",sizeof(sles_data), pSles); |
| *ppSles = pSles; |
| if (pSles != NULL) |
| { |
| SLES_PRINTF("creating server. Sampling rate =%d, frame count = %d",samplingRate, |
| frameCount); |
| status = slesCreateServer(pSles, samplingRate, frameCount, micSource); |
| SLES_PRINTF("slesCreateServer =%d",status); |
| } |
| } |
| return status; |
| } |
| int slesDestroy(sles_data ** ppSles) { |
| int status = SLES_FAIL; |
| if (ppSles != NULL) { |
| slesDestroyServer(*ppSles); |
| |
| if (*ppSles != NULL) |
| { |
| free(*ppSles); |
| *ppSles = 0; |
| } |
| status = SLES_SUCCESS; |
| } |
| return status; |
| } |
| |
| #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) |
| |
| |
| // Called after audio recorder fills a buffer with data |
| static void recorderCallback(SLAndroidSimpleBufferQueueItf caller __unused, void *context) { |
| sles_data *pSles = (sles_data*) context; |
| if (pSles != NULL) { |
| |
| |
| |
| SLresult result; |
| |
| pthread_mutex_lock(&(pSles->mutex)); |
| //ee SLES_PRINTF("<R"); |
| |
| // We should only be called when a recording buffer is done |
| assert(pSles->rxFront <= pSles->rxBufCount); |
| assert(pSles->rxRear <= pSles->rxBufCount); |
| assert(pSles->rxFront != pSles->rxRear); |
| char *buffer = pSles->rxBuffers[pSles->rxFront]; |
| |
| // Remove buffer from record queue |
| if (++pSles->rxFront > pSles->rxBufCount) { |
| pSles->rxFront = 0; |
| } |
| |
| ssize_t actual = audio_utils_fifo_write(&(pSles->fifo), buffer, |
| (size_t) pSles->bufSizeInFrames); |
| if (actual != (ssize_t) pSles->bufSizeInFrames) { |
| write(1, "?", 1); |
| } |
| |
| // This is called by a realtime (SCHED_FIFO) thread, |
| // and it is unsafe to do I/O as it could block for unbounded time. |
| // Flash filesystem is especially notorious for blocking. |
| if (pSles->fifo2Buffer != NULL) { |
| actual = audio_utils_fifo_write(&(pSles->fifo2), buffer, |
| (size_t) pSles->bufSizeInFrames); |
| if (actual != (ssize_t) pSles->bufSizeInFrames) { |
| write(1, "?", 1); |
| } |
| } |
| |
| // Enqueue this same buffer for the recorder to fill again. |
| result = (*(pSles->recorderBufferQueue))->Enqueue(pSles->recorderBufferQueue, buffer, |
| pSles->bufSizeInBytes); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| |
| // Update our model of the record queue |
| SLuint32 rxRearNext = pSles->rxRear+1; |
| if (rxRearNext > pSles->rxBufCount) { |
| rxRearNext = 0; |
| } |
| assert(rxRearNext != pSles->rxFront); |
| pSles->rxBuffers[pSles->rxRear] = buffer; |
| pSles->rxRear = rxRearNext; |
| |
| |
| |
| //ee SLES_PRINTF("r>"); |
| pthread_mutex_unlock(&(pSles->mutex)); |
| |
| } //pSles not null |
| } |
| |
| |
| // Called after audio player empties a buffer of data |
| static void playerCallback(SLBufferQueueItf caller __unused, void *context) { |
| sles_data *pSles = (sles_data*) context; |
| if (pSles != NULL) { |
| |
| SLresult result; |
| |
| pthread_mutex_lock(&(pSles->mutex)); |
| //ee SLES_PRINTF("<P"); |
| |
| // Get the buffer that just finished playing |
| assert(pSles->txFront <= pSles->txBufCount); |
| assert(pSles->txRear <= pSles->txBufCount); |
| assert(pSles->txFront != pSles->txRear); |
| char *buffer = pSles->txBuffers[pSles->txFront]; |
| if (++pSles->txFront > pSles->txBufCount) { |
| pSles->txFront = 0; |
| } |
| |
| |
| ssize_t actual = audio_utils_fifo_read(&(pSles->fifo), buffer, pSles->bufSizeInFrames); |
| if (actual != (ssize_t) pSles->bufSizeInFrames) { |
| write(1, "/", 1); |
| // on underrun from pipe, substitute silence |
| memset(buffer, 0, pSles->bufSizeInFrames * pSles->channels * sizeof(short)); |
| } |
| |
| if (pSles->injectImpulse == -1) { |
| // Experimentally, a single frame impulse was insufficient to trigger feedback. |
| // Also a Nyquist frequency signal was also insufficient, probably because |
| // the response of output and/or input path was not adequate at high frequencies. |
| // This short burst of a few cycles of square wave at Nyquist/4 was found to work well. |
| for (unsigned i = 0; i < pSles->bufSizeInFrames / 8; i += 8) { |
| for (int j = 0; j < 8; j++) { |
| for (unsigned k = 0; k < pSles->channels; k++) { |
| ((short *)buffer)[(i+j)*pSles->channels+k] = j < 4 ? 0x7FFF : 0x8000; |
| } |
| } |
| } |
| pSles->injectImpulse = 0; |
| } |
| |
| // Enqueue the filled buffer for playing |
| result = (*(pSles->playerBufferQueue))->Enqueue(pSles->playerBufferQueue, buffer, |
| pSles->bufSizeInBytes); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| |
| // Update our model of the player queue |
| assert(pSles->txFront <= pSles->txBufCount); |
| assert(pSles->txRear <= pSles->txBufCount); |
| SLuint32 txRearNext = pSles->txRear+1; |
| if (txRearNext > pSles->txBufCount) { |
| txRearNext = 0; |
| } |
| assert(txRearNext != pSles->txFront); |
| pSles->txBuffers[pSles->txRear] = buffer; |
| pSles->txRear = txRearNext; |
| |
| |
| //ee SLES_PRINTF("p>"); |
| pthread_mutex_unlock(&(pSles->mutex)); |
| |
| } //pSles not null |
| } |
| |
| int slesCreateServer(sles_data *pSles, int samplingRate, int frameCount, int micSource) { |
| int status = SLES_FAIL; |
| |
| if (pSles == NULL) { |
| return status; |
| } |
| |
| // adb shell slesTest_feedback -r1 -t1 -s48000 -f240 -i300 -e3 -o/sdcard/log.wav |
| // r1 and t1 are the receive and transmit buffer counts, typically 1 |
| // s is the sample rate, typically 48000 or 44100 |
| // f is the frame count per buffer, typically 240 or 256 |
| // i is the number of milliseconds before impulse. You may need to adjust this. |
| // e is number of seconds to record |
| // o is output .wav file name |
| |
| |
| // // default values |
| // SLuint32 rxBufCount = 1; // -r# |
| // SLuint32 txBufCount = 1; // -t# |
| // SLuint32 bufSizeInFrames = 240; // -f# |
| // SLuint32 channels = 1; // -c# |
| // SLuint32 sampleRate = 48000; // -s# |
| // SLuint32 exitAfterSeconds = 3; // -e# |
| // SLuint32 freeBufCount = 0; // calculated |
| // SLuint32 bufSizeInBytes = 0; // calculated |
| // int injectImpulse = 300; // -i#i |
| // |
| // // Storage area for the buffer queues |
| // char **rxBuffers; |
| // char **txBuffers; |
| // char **freeBuffers; |
| // |
| // // Buffer indices |
| // SLuint32 rxFront; // oldest recording |
| // SLuint32 rxRear; // next to be recorded |
| // SLuint32 txFront; // oldest playing |
| // SLuint32 txRear; // next to be played |
| // SLuint32 freeFront; // oldest free |
| // SLuint32 freeRear; // next to be freed |
| // |
| // audio_utils_fifo fifo; //(*) |
| // SLAndroidSimpleBufferQueueItf recorderBufferQueue; |
| // SLBufferQueueItf playerBufferQueue; |
| |
| // default values |
| pSles->rxBufCount = 1; // -r# |
| pSles->txBufCount = 1; // -t# |
| pSles->bufSizeInFrames = frameCount;//240; // -f# |
| pSles->channels = 1; // -c# |
| pSles->sampleRate = samplingRate;//48000; // -s# |
| pSles->exitAfterSeconds = 3; // -e# |
| pSles->freeBufCount = 0; // calculated |
| pSles->bufSizeInBytes = 0; // calculated |
| pSles->injectImpulse = 300; // -i#i |
| |
| // Storage area for the buffer queues |
| // char **rxBuffers; |
| // char **txBuffers; |
| // char **freeBuffers; |
| |
| // Buffer indices |
| pSles->rxFront; // oldest recording |
| pSles->rxRear; // next to be recorded |
| pSles->txFront; // oldest playing |
| pSles->txRear; // next to be played |
| pSles->freeFront; // oldest free |
| pSles->freeRear; // next to be freed |
| |
| pSles->fifo; //(*) |
| pSles->fifo2Buffer = NULL; |
| pSles->recorderBufferQueue; |
| pSles->playerBufferQueue; |
| |
| // compute total free buffers as -r plus -t |
| pSles->freeBufCount = pSles->rxBufCount + pSles->txBufCount; |
| // compute buffer size |
| pSles->bufSizeInBytes = pSles->channels * pSles->bufSizeInFrames * sizeof(short); |
| |
| // Initialize free buffers |
| pSles->freeBuffers = (char **) calloc(pSles->freeBufCount+1, sizeof(char *)); |
| unsigned j; |
| for (j = 0; j < pSles->freeBufCount; ++j) { |
| pSles->freeBuffers[j] = (char *) malloc(pSles->bufSizeInBytes); |
| } |
| pSles->freeFront = 0; |
| pSles->freeRear = pSles->freeBufCount; |
| pSles->freeBuffers[j] = NULL; |
| |
| // Initialize record queue |
| pSles->rxBuffers = (char **) calloc(pSles->rxBufCount+1, sizeof(char *)); |
| pSles->rxFront = 0; |
| pSles->rxRear = 0; |
| |
| // Initialize play queue |
| pSles->txBuffers = (char **) calloc(pSles->txBufCount+1, sizeof(char *)); |
| pSles->txFront = 0; |
| pSles->txRear = 0; |
| |
| size_t frameSize = pSles->channels * sizeof(short); |
| #define FIFO_FRAMES 1024 |
| pSles->fifoBuffer = new short[FIFO_FRAMES * pSles->channels]; |
| audio_utils_fifo_init(&(pSles->fifo), FIFO_FRAMES, frameSize, pSles->fifoBuffer); |
| |
| // SNDFILE *sndfile; |
| // if (outFileName != NULL) { |
| // create .wav writer |
| // SF_INFO info; |
| // info.frames = 0; |
| // info.samplerate = sampleRate; |
| // info.channels = channels; |
| // info.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16; |
| // sndfile = sf_open(outFileName, SFM_WRITE, &info); |
| // if (sndfile != NULL) { |
| #define FIFO2_FRAMES 65536 |
| pSles->fifo2Buffer = new short[FIFO2_FRAMES * pSles->channels]; |
| audio_utils_fifo_init(&(pSles->fifo2), FIFO2_FRAMES, frameSize, pSles->fifo2Buffer); |
| // } else { |
| // fprintf(stderr, "sf_open failed\n"); |
| // } |
| // } else { |
| // sndfile = NULL; |
| // } |
| |
| SLresult result; |
| |
| // create engine |
| pSles->engineObject; |
| result = slCreateEngine(&(pSles->engineObject), 0, NULL, 0, NULL, NULL); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| result = (*(pSles->engineObject))->Realize(pSles->engineObject, SL_BOOLEAN_FALSE); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| SLEngineItf engineEngine; |
| result = (*(pSles->engineObject))->GetInterface(pSles->engineObject, SL_IID_ENGINE, |
| &engineEngine); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| |
| // create output mix |
| pSles->outputmixObject; |
| result = (*engineEngine)->CreateOutputMix(engineEngine, &(pSles->outputmixObject), 0, NULL, |
| NULL); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| result = (*(pSles->outputmixObject))->Realize(pSles->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 = pSles->txBufCount; |
| locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX; |
| locator_outputmix.outputMix = pSles->outputmixObject; |
| pcm.formatType = SL_DATAFORMAT_PCM; |
| pcm.numChannels = pSles->channels; |
| pcm.samplesPerSec = pSles->sampleRate * 1000; |
| pcm.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16; |
| pcm.containerSize = 16; |
| pcm.channelMask = pSles->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; |
| pSles->playerObject = NULL; |
| pSles->recorderObject = NULL; |
| SLInterfaceID ids_tx[1] = {SL_IID_BUFFERQUEUE}; |
| SLboolean flags_tx[1] = {SL_BOOLEAN_TRUE}; |
| result = (*engineEngine)->CreateAudioPlayer(engineEngine, &(pSles->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); |
| SLES_PRINTF("ERROR: Could not create audio player (result %x), check sample rate\n", |
| result); |
| goto cleanup; |
| } |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| result = (*(pSles->playerObject))->Realize(pSles->playerObject, SL_BOOLEAN_FALSE); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| SLPlayItf playerPlay; |
| result = (*(pSles->playerObject))->GetInterface(pSles->playerObject, SL_IID_PLAY, |
| &playerPlay); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| result = (*(pSles->playerObject))->GetInterface(pSles->playerObject, SL_IID_BUFFERQUEUE, |
| &(pSles->playerBufferQueue)); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| result = (*(pSles->playerBufferQueue))->RegisterCallback(pSles->playerBufferQueue, |
| playerCallback, pSles); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| |
| // Enqueue some zero buffers for the player |
| for (j = 0; j < pSles->txBufCount; ++j) { |
| |
| // allocate a free buffer |
| assert(pSles->freeFront != pSles->freeRear); |
| char *buffer = pSles->freeBuffers[pSles->freeFront]; |
| if (++pSles->freeFront > pSles->freeBufCount) { |
| pSles->freeFront = 0; |
| } |
| |
| // put on play queue |
| SLuint32 txRearNext = pSles->txRear + 1; |
| if (txRearNext > pSles->txBufCount) { |
| txRearNext = 0; |
| } |
| assert(txRearNext != pSles->txFront); |
| pSles->txBuffers[pSles->txRear] = buffer; |
| pSles->txRear = txRearNext; |
| result = (*(pSles->playerBufferQueue))->Enqueue(pSles->playerBufferQueue, |
| buffer, pSles->bufSizeInBytes); |
| 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 = pSles->rxBufCount; |
| audiosnk.pLocator = &locator_bufferqueue_rx; |
| audiosnk.pFormat = &pcm; |
| { |
| SLInterfaceID ids_rx[2] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE, |
| SL_IID_ANDROIDCONFIGURATION}; |
| SLboolean flags_rx[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE}; |
| result = (*engineEngine)->CreateAudioRecorder(engineEngine, &(pSles->recorderObject), |
| &audiosrc, &audiosnk, 2, 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); |
| status = SLES_FAIL; |
| |
| SLES_PRINTF("ERROR: Could not create audio recorder (result %x), " |
| "check sample rate and channel count\n", result); |
| goto cleanup; |
| } |
| } |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| |
| { |
| /* Get the Android configuration interface which is explicit */ |
| SLAndroidConfigurationItf configItf; |
| result = (*(pSles->recorderObject))->GetInterface(pSles->recorderObject, |
| SL_IID_ANDROIDCONFIGURATION, (void*)&configItf); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| SLuint32 presetValue = micSource; |
| /* Use the configuration interface to configure the recorder before it's realized */ |
| if (presetValue != SL_ANDROID_RECORDING_PRESET_NONE) { |
| result = (*configItf)->SetConfiguration(configItf, SL_ANDROID_KEY_RECORDING_PRESET, |
| &presetValue, sizeof(SLuint32)); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| } |
| |
| } |
| |
| result = (*(pSles->recorderObject))->Realize(pSles->recorderObject, SL_BOOLEAN_FALSE); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| SLRecordItf recorderRecord; |
| result = (*(pSles->recorderObject))->GetInterface(pSles->recorderObject, SL_IID_RECORD, |
| &recorderRecord); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| result = (*(pSles->recorderObject))->GetInterface(pSles->recorderObject, |
| SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &(pSles->recorderBufferQueue)); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| result = (*(pSles->recorderBufferQueue))->RegisterCallback(pSles->recorderBufferQueue, |
| recorderCallback, pSles); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| |
| // Enqueue some empty buffers for the recorder |
| for (j = 0; j < pSles->rxBufCount; ++j) { |
| |
| // allocate a free buffer |
| assert(pSles->freeFront != pSles->freeRear); |
| char *buffer = pSles->freeBuffers[pSles->freeFront]; |
| if (++pSles->freeFront > pSles->freeBufCount) { |
| pSles->freeFront = 0; |
| } |
| |
| // put on record queue |
| SLuint32 rxRearNext = pSles->rxRear + 1; |
| if (rxRearNext > pSles->rxBufCount) { |
| rxRearNext = 0; |
| } |
| assert(rxRearNext != pSles->rxFront); |
| pSles->rxBuffers[pSles->rxRear] = buffer; |
| pSles->rxRear = rxRearNext; |
| result = (*(pSles->recorderBufferQueue))->Enqueue(pSles->recorderBufferQueue, |
| buffer, pSles->bufSizeInBytes); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| } |
| |
| // Kick off the recorder |
| result = (*recorderRecord)->SetRecordState(recorderRecord, SL_RECORDSTATE_RECORDING); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| |
| // Tear down the objects and exit |
| status = SLES_SUCCESS; |
| cleanup: |
| SLES_PRINTF("Finished initialization with status: %d", status); |
| |
| return status; |
| } |
| |
| int slesProcessNext(sles_data *pSles, double *pSamples, long maxSamples) { |
| //int status = SLES_FAIL; |
| |
| SLES_PRINTF("slesProcessNext: pSles = %p, currentSample: %p, maxSamples = %ld", pSles, |
| pSamples, maxSamples); |
| |
| int samplesRead = 0; |
| |
| int currentSample = 0; |
| double *pCurrentSample = pSamples; |
| int maxValue = 32768; |
| |
| if (pSles == NULL) { |
| return samplesRead; |
| } |
| |
| SLresult result; |
| for (int i = 0; i < 10; i++) { |
| usleep(100000); |
| if (pSles->fifo2Buffer != NULL) { |
| for (;;) { |
| short buffer[pSles->bufSizeInFrames * pSles->channels]; |
| ssize_t actual = audio_utils_fifo_read(&(pSles->fifo2), buffer, |
| pSles->bufSizeInFrames); |
| if (actual <= 0) |
| break; |
| { |
| for (int jj =0; jj<actual && currentSample < maxSamples; jj++) { |
| *(pCurrentSample++) = ((double)buffer[jj])/maxValue; |
| currentSample++; |
| } |
| } |
| samplesRead +=actual; |
| } |
| } |
| if (pSles->injectImpulse > 0) { |
| if (pSles->injectImpulse <= 100) { |
| pSles->injectImpulse = -1; |
| write(1, "I", 1); |
| } else { |
| if ((pSles->injectImpulse % 1000) < 100) { |
| write(1, "i", 1); |
| } |
| pSles->injectImpulse -= 100; |
| } |
| } else if (i == 9) { |
| write(1, ".", 1); |
| } |
| } |
| SLBufferQueueState playerBQState; |
| result = (*(pSles->playerBufferQueue))->GetState(pSles->playerBufferQueue, |
| &playerBQState); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| SLAndroidSimpleBufferQueueState recorderBQState; |
| result = (*(pSles->recorderBufferQueue))->GetState(pSles->recorderBufferQueue, |
| &recorderBQState); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| |
| SLES_PRINTF("End of slesProcessNext: pSles = %p, samplesRead = %d, maxSamples= %ld", pSles, |
| samplesRead, maxSamples); |
| |
| return samplesRead; |
| } |
| |
| int slesDestroyServer(sles_data *pSles) { |
| int status = SLES_FAIL; |
| |
| SLES_PRINTF("Start slesDestroyServer: pSles = %p", pSles); |
| if (pSles == NULL) { |
| return status; |
| } |
| |
| if (NULL != pSles->playerObject) { |
| |
| SLES_PRINTF("stopping player..."); |
| SLPlayItf playerPlay; |
| SLresult result = (*(pSles->playerObject))->GetInterface(pSles->playerObject, |
| SL_IID_PLAY, &playerPlay); |
| |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| |
| //stop player and recorder if they exist |
| result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_STOPPED); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| } |
| |
| if (NULL != pSles->recorderObject) { |
| SLES_PRINTF("stopping recorder..."); |
| SLRecordItf recorderRecord; |
| SLresult result = (*(pSles->recorderObject))->GetInterface(pSles->recorderObject, |
| SL_IID_RECORD, &recorderRecord); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| |
| result = (*recorderRecord)->SetRecordState(recorderRecord, SL_RECORDSTATE_STOPPED); |
| ASSERT_EQ(SL_RESULT_SUCCESS, result); |
| } |
| |
| usleep(1000); |
| |
| audio_utils_fifo_deinit(&(pSles->fifo)); |
| delete[] pSles->fifoBuffer; |
| |
| SLES_PRINTF("slesDestroyServer 2"); |
| |
| // if (sndfile != NULL) { |
| audio_utils_fifo_deinit(&(pSles->fifo2)); |
| delete[] pSles->fifo2Buffer; |
| |
| SLES_PRINTF("slesDestroyServer 3"); |
| |
| // sf_close(sndfile); |
| // } |
| if (NULL != pSles->playerObject) { |
| (*(pSles->playerObject))->Destroy(pSles->playerObject); |
| } |
| |
| SLES_PRINTF("slesDestroyServer 4"); |
| |
| if (NULL != pSles->recorderObject) { |
| (*(pSles->recorderObject))->Destroy(pSles->recorderObject); |
| } |
| |
| SLES_PRINTF("slesDestroyServer 5"); |
| |
| (*(pSles->outputmixObject))->Destroy(pSles->outputmixObject); |
| SLES_PRINTF("slesDestroyServer 6"); |
| (*(pSles->engineObject))->Destroy(pSles->engineObject); |
| SLES_PRINTF("slesDestroyServer 7"); |
| |
| // free(pSles); |
| // pSles=NULL; |
| |
| status = SLES_SUCCESS; |
| |
| SLES_PRINTF("End slesDestroyServer: status = %d", status); |
| return status; |
| } |
| |