OpenSL ES Android вход микрофон зашифрован

Я использую сверхмощные библиотека на Android, и она основана на OpenSL. Я хочу получить звук с микрофона или гарнитуры моего телефона, и я могу активировать входную запись, но звук зашифрован (я слышу только шум).

У вас есть идеи, что может вызвать это? Если это поможет, я запускаю Android 5.1 на Nexus 5.

Заранее спасибо !

Образец кода :

#include "SuperpoweredAndroidAudioIO.h" #include android / log.h
#include SLES / OpenSLES.h
#include SLES / OpenSLES_Android.h
#include pthread.h

typedef struct SuperpoweredAndroidAudioIOInternals {
pthread_mutex_t mutex;
void * clientdata;
audioProcessingCallback callback;
SLObjectItf openSLEngine, outputMix, outputBufferQueue, inputBufferQueue;
SLAndroidSimpleBufferQueueItf outputBufferQueueInterface, inputBufferQueueInterface;
короткий int * fifobuffer, * тишину;
int samplerate, размер буфера, fifoCapacity, fifoFirstSample, fifoLastSample, latencySamples;
bool hasOutput, hasInput;
SuperpoweredResampler * resampler;
} SuperpoweredAndroidAudioIOInternals;

static inline void checkRoom (SuperpoweredAndroidAudioIOInternals * innerals) {
if (internals-> fifoLastSample + internals-> buffersize> = internals-> fifoCapacity) {// Если в конце буфера fifo нет места, переместите все в начало.
int samplesInFifo = internals-> fifoLastSample - internals-> fifoFirstSample;
if (samplesInFifo> 0) memmove (внутреннее-> fifobuffer, внутреннее-> fifobuffer + внутреннее-> fifoFirstSample * 2, samplesInFifo * 8);
internals-> fifoFirstSample = 0;
internals-> fifoLastSample = samplesInFifo;
};
}

static void SuperpoweredAndroidAudioIO_InputCallback (SLAndroidSimpleBufferQueueItf caller, void * pContext) {// Сюда поступает аудиовход.
SuperpoweredAndroidAudioIOInternals * internals = (SuperpoweredAndroidAudioIOInternals *) pContext;
pthread_mutex_lock (internals-> мьютекс);
Столик (внутренние);

short int * input = internals-> fifobuffer + internals-> fifoLastSample * 2;
internals-> fifoLastSample + = internals-> buffersize;

if (internals-> hasOutput) {
pthread_mutex_unlock (internals-> мьютекс);
(* caller) -> Enqueue (caller, input, innerals-> buffersize * 4);
} еще {
short int * process = internals-> fifobuffer + internals-> fifoFirstSample * 2;
internals-> fifoFirstSample + = internals-> buffersize;
pthread_mutex_unlock (internals-> мьютекс);

(* caller) -> Enqueue (caller, input, innerals-> buffersize * 4);
internals-> callback (internals-> clientdata, процесс, internals-> buffersize, internals-> samplerate);
};
}

static void SuperpoweredAndroidAudioIO_OutputCallback (SLAndroidSimpleBufferQueueItf вызывающий, void * pContext) {
SuperpoweredAndroidAudioIOInternals * internals = (SuperpoweredAndroidAudioIOInternals *) pContext;
pthread_mutex_lock (internals-> мьютекс);

if (! internals-> hasInput) {
Столик (внутренние);
short int * process = internals-> fifobuffer + internals-> fifoLastSample * 2;
internals-> fifoLastSample + = internals-> buffersize;
short int * output = internals-> fifobuffer + internals-> fifoFirstSample * 2;
internals-> fifoFirstSample + = internals-> buffersize;
pthread_mutex_unlock (internals-> мьютекс);

if (! internals-> callback (internals-> clientdata, process, internals-> buffersize, internals-> samplerate)) memset (process, 0, internals-> buffersize * 4);
(* caller) -> Enqueue (caller, output, internals-> buffersize * 4);
} еще {
if (internals-> fifoLastSample - internals-> fifoFirstSample> = internals-> latencySamples) {
short int * output = internals-> fifobuffer + internals-> fifoFirstSample * 2;
internals-> fifoFirstSample + = internals-> buffersize;
pthread_mutex_unlock (internals-> мьютекс);

if (! internals-> callback (internals-> clientdata, output, internals-> buffersize, internals-> samplerate)) memset (output, 0, internals-> buffersize * 4);
(* caller) -> Enqueue (caller, output, internals-> buffersize * 4);
} еще {
pthread_mutex_unlock (internals-> мьютекс);
(* caller) -> Enqueue (звонящий, внутренняя часть-> тишина, внутренняя часть-> размер буфера * 4); // выпадает, не хватает аудиовхода
};
};
}

SuperpoweredAndroidAudioIO :: SuperpoweredAndroidAudioIO (int samplerate, int, размер буфера, bool enableInput, bool enableOutput, обратный вызов audioProcessingCallback, void * clientdata, int latencySamples) {
static const SLboolean requireds [2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};

внутренности = новый SuperpoweredAndroidAudioIOInternals;
memset (внутренние, 0, sizeof (SuperpoweredAndroidAudioIOInternals));
pthread_mutex_init (internals-> mutex, NULL);
внутренние -> частота дискретизации = частота дискретизации;
internals-> buffersize = buffersize;
internals-> clientdata = clientdata;
internals-> callback = callback;
internals-> hasInput = enableInput;
internals-> hasOutput = enableOutput;
internals-> silence = (short int *) malloc (buffersize * 4);
internals-> latencySamples = latencySamples resampler = new SuperpoweredResampler ();

memset (внутреннее-> тишина, 0, размер буфера * 4);

internals-> fifoCapacity = buffersize * 100;
int fifoBufferSizeBytes = internals-> fifoCapacity * 4 + buffersize * 4;
internals-> fifobuffer = (short int *) malloc (fifoBufferSizeBytes);
memset (internals-> fifobuffer, 0, fifoBufferSizeBytes);

// Создать движок OpenSL ES.
slCreateEngine (innerals-> openSLEngine, 0, NULL, 0, NULL, NULL);
(* internals-> openSLEngine) -> Реализовать (internals-> openSLEngine, SL_BOOLEAN_FALSE);
SLEngineItf openSLEngineInterface = NULL;
(* internals-> openSLEngine) -> GetInterface (internals-> openSLEngine, SL_IID_ENGINE, openSLEngineInterface);
// Создать выходной микс.
(* OpenSLEngineInterface) -> CreateOutputMix (openSLEngineInterface, internals-> outputMix, 0, NULL, NULL);
(* internals-> outputMix) -> Realize (internals-> outputMix, SL_BOOLEAN_FALSE);
SLDataLocator_OutputMix outputMixLocator = {SL_DATALOCATOR_OUTPUTMIX, internals-> outputMix};

if (enableInput) {// Создать очередь входного буфера.
SLDataLocator_IODevice deviceInputLocator = {SL_DATALOCATOR_IODEVICE, SL_IODEVICE_AUDIOINPUT, SL_DEFAULTDEVICEID_AUDIOINPUT, NULL};
SLDataSource inputSource = { deviceInputLocator, NULL};
SLDataLocator_AndroidSimpleBufferQueue inputLocator = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 1};
SLDataFormat_PCM inputFormat = {SL_DATAFORMAT_PCM, 2, частота дискретизации * 1000, SL_PCMSAMPLEFORMAT_FIXED_16, SL_PCMSAMPLEFORMAT_FIXED_16, SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT, SL_BYTEORDER_LITTLEENDIAN};
SLDataSink inputSink = { inputLocator, inputFormat};
const SLInterfaceID inputInterfaces [1] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE};
(* OpenSLEngineInterface) -> CreateAudioRecorder (openSLEngineInterface, internals-> inputBufferQueue, InputSource, inputSink, 1, inputInterfaces, обязательно);
(* internals-> inputBufferQueue) -> Realize (internals-> inputBufferQueue, SL_BOOLEAN_FALSE);
};

if (enableOutput) {// Создать очередь выходного буфера.
SLDataLocator_AndroidSimpleBufferQueue outputLocator = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 1};
SLDataFormat_PCM outputFormat = {SL_DATAFORMAT_PCM, 2, частота дискретизации * 1000, SL_PCMSAMPLEFORMAT_FIXED_16, SL_PCMSAMPLEFORMAT_FIXED_16, SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT, SL_BYTEORDER_LITTLEENDIAN};
SLDataSource outputSource = { outputLocator, Выходной формат };
const SLInterfaceID outputInterfaces [1] = {SL_IID_BUFFERQUEUE};
SLDataSink outputSink = { outputMixLocator, NULL};
(* OpenSLEngineInterface) -> CreateAudioPlayer (openSLEngineInterface, internals-> outputBufferQueue, outputSource, outputSink, 1, outputInterfaces, обязательно);
(* internals-> outputBufferQueue) -> Realize (internals-> outputBufferQueue, SL_BOOLEAN_FALSE);
};

if (enableInput) {// Инициализировать и запустить очередь входного буфера.
(* internals-> inputBufferQueue) -> GetInterface (internals-> inputBufferQueue, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, internals-> inputBufferQueueInterface);
(* internals-> inputBufferQueueInterface) -> RegisterCallback (internals-> inputBufferQueueInterface, SuperpoweredAndroidAudioIO_InputCallback, internals);
SLRecordItf recordInterface;
(* internals-> inputBufferQueue) -> GetInterface (internals-> inputBufferQueue, SL_IID_RECORD, recordInterface);
(* internals-> inputBufferQueueInterface) -> Enqueue (internals-> inputBufferQueueInterface, internals-> fifobuffer, buffersize * 4);
(* recordInterface) -> SetRecordState (recordInterface, SL_RECORDSTATE_RECORDING);
};

if (enableOutput) {// Инициализировать и запустить очередь выходного буфера.
(* internals-> outputBufferQueue) -> GetInterface (internals-> outputBufferQueue, SL_IID_BUFFERQUEUE, internals-> outputBufferQueueInterface);
(* internals-> outputBufferQueueInterface) -> RegisterCallback (internals-> outputBufferQueueInterface, SuperpoweredAndroidAudioIO_OutputCallback, internals);
(* internals-> outputBufferQueueInterface) -> Enqueue (internals-> outputBufferQueueInterface, internals-> fifobuffer, buffersize * 4);
SLPlayItf outputPlayInterface;
(* internals-> outputBufferQueue) -> GetInterface (internals-> outputBufferQueue, SL_IID_PLAY, outputPlayInterface);
(* outputPlayInterface) -> SetPlayState (outputPlayInterface, SL_PLAYSTATE_PLAYING);
};
}

SuperpoweredAndroidAudioIO :: ~ SuperpoweredAndroidAudioIO () {
бесплатно (internals-> fifobuffer);
бесплатно (internals-> молчание);
pthread_mutex_destroy (internals-> мьютекс);
удалить внутренности;
}