TheArchive/session-android
1
0
Fork 0
mirror of https://github.com/oxen-io/session-android.git synced 2025-12-02 23:01:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Support for Signal calls.

Browse Source 
Merge in RedPhone

// FREEBIE
This commit is contained in:
Moxie Marlinspike
2015-09-09 13:54:29 -07:00
parent 3d4ae60d81
commit d83a3d71bc
2585 changed files with 803492 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
jni/redphone/MicrophoneReader.cpp Normal file
View File

@@ -0,0 +1,124 @@
#include "MicrophoneReader.h"
#include "SampleRateUtil.h"
#include <jni.h>
#include <android/log.h>
#define TAG "MicrophoneReader"
#ifndef SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION
#define SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION ((SLuint32) 0x00000004)
#endif
MicrophoneReader::MicrophoneReader(int androidSdkVersion, AudioCodec &audioCodec, RtpAudioSender &rtpAudioSender, Clock &clock) :
androidSdkVersion(androidSdkVersion), muteEnabled(0),
audioCodec(audioCodec), rtpAudioSender(rtpAudioSender), clock(clock),
recorderObject(NULL), recorderRecord(NULL), recorderBufferQueue(NULL)
{
}
MicrophoneReader::~MicrophoneReader() {
}
void MicrophoneReader::recorderCallback(SLAndroidSimpleBufferQueueItf bufferQueue, void *context) {
MicrophoneReader* microphoneReader = static_cast<MicrophoneReader*>(context);
microphoneReader->recorderCallback(bufferQueue);
}
void MicrophoneReader::recorderCallback(SLAndroidSimpleBufferQueueItf bufferQueue)
{
if (muteEnabled) {
memset(inputBuffer, 0, FRAME_SIZE * 2 * sizeof(short));
}
int encodedAudioLen = audioCodec.encode(inputBuffer, encodedAudio, sizeof(encodedAudio));
encodedAudioLen += audioCodec.encode(inputBuffer + FRAME_SIZE, encodedAudio + encodedAudioLen, sizeof(encodedAudio) - encodedAudioLen);
rtpAudioSender.send(clock.tick(2), encodedAudio, encodedAudioLen);
(*bufferQueue)->Enqueue(bufferQueue, inputBuffer, FRAME_SIZE * 2 * sizeof(short));
}
void MicrophoneReader::setMute(int muteEnabled) {
this->muteEnabled = muteEnabled;
}
int MicrophoneReader::start(SLEngineItf *engineEnginePtr) {
SLEngineItf engineEngine = *engineEnginePtr;
SLDataLocator_AndroidSimpleBufferQueue loc_bq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 1};
SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM, 1, SL_SAMPLINGRATE_8,
SL_PCMSAMPLEFORMAT_FIXED_16, SL_PCMSAMPLEFORMAT_FIXED_16,
SL_SPEAKER_FRONT_CENTER, SL_BYTEORDER_LITTLEENDIAN};
SLDataLocator_IODevice loc_dev = {SL_DATALOCATOR_IODEVICE, SL_IODEVICE_AUDIOINPUT, SL_DEFAULTDEVICEID_AUDIOINPUT, NULL};
SLDataSource audioSrc = {&loc_dev, NULL};
SLDataSink audioSnk = {&loc_bq, &format_pcm};
const SLInterfaceID id[2] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE, SL_IID_ANDROIDCONFIGURATION};
const SLboolean req[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
if ((*engineEngine)->CreateAudioRecorder(engineEngine, &recorderObject, &audioSrc,
&audioSnk, 2, id, req) != SL_RESULT_SUCCESS)
{
return -1;
}
if ((*recorderObject)->GetInterface(recorderObject, SL_IID_ANDROIDCONFIGURATION, &androidConfig) == SL_RESULT_SUCCESS) {
SLint32 recordingPreset = SL_ANDROID_RECORDING_PRESET_GENERIC;
if (androidSdkVersion >= 14) {
__android_log_print(ANDROID_LOG_WARN, TAG, "Using voice communication Microphone preset...");
recordingPreset = SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION;
}
(*androidConfig)->SetConfiguration(androidConfig, SL_ANDROID_KEY_RECORDING_PRESET,
&recordingPreset, sizeof(SLint32));
}
if ((*recorderObject)->Realize(recorderObject, SL_BOOLEAN_FALSE) != SL_RESULT_SUCCESS) {
return -1;
}
if ((*recorderObject)->GetInterface(recorderObject, SL_IID_RECORD, &recorderRecord) != SL_RESULT_SUCCESS) {
return -1;
}
if ((*recorderObject)->GetInterface(recorderObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &recorderBufferQueue) != SL_RESULT_SUCCESS) {
return -1;
}
if ((*recorderBufferQueue)->RegisterCallback(recorderBufferQueue, &MicrophoneReader::recorderCallback, this) != SL_RESULT_SUCCESS) {
return -1;
}
if ((*recorderBufferQueue)->Enqueue(recorderBufferQueue, inputBuffer, FRAME_SIZE * 2 * sizeof(short)) != SL_RESULT_SUCCESS) {
return -1;
}
if ((*recorderRecord)->SetRecordState(recorderRecord, SL_RECORDSTATE_RECORDING) != SL_RESULT_SUCCESS) {
return -1;
}
return 0;
}
void MicrophoneReader::stop() {
if (recorderRecord != NULL) {
(*recorderRecord)->SetRecordState(recorderRecord, SL_RECORDSTATE_STOPPED);
}
if (recorderBufferQueue != NULL) {
(*recorderBufferQueue)->Clear(recorderBufferQueue);
}
if (recorderObject != NULL) {
(*recorderObject)->Destroy(recorderObject);
recorderRecord = NULL;
recorderObject = NULL;
recorderBufferQueue = NULL;
}
}