1 /* 2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #ifndef WEBRTC_MODULES_AUDIO_DEVICE_ANDROID_OPENSLES_INPUT_H_ 12 #define WEBRTC_MODULES_AUDIO_DEVICE_ANDROID_OPENSLES_INPUT_H_ 13 14 #include <SLES/OpenSLES.h> 15 #include <SLES/OpenSLES_Android.h> 16 #include <SLES/OpenSLES_AndroidConfiguration.h> 17 18 #include "webrtc/modules/audio_device/android/audio_manager_jni.h" 19 #include "webrtc/modules/audio_device/android/low_latency_event.h" 20 #include "webrtc/modules/audio_device/include/audio_device.h" 21 #include "webrtc/modules/audio_device/include/audio_device_defines.h" 22 #include "webrtc/system_wrappers/interface/scoped_ptr.h" 23 24 namespace webrtc { 25 26 class AudioDeviceBuffer; 27 class CriticalSectionWrapper; 28 class PlayoutDelayProvider; 29 class SingleRwFifo; 30 class ThreadWrapper; 31 32 // OpenSL implementation that facilitate capturing PCM data from an android 33 // device's microphone. 34 // This class is Thread-compatible. I.e. Given an instance of this class, calls 35 // to non-const methods require exclusive access to the object. 36 class OpenSlesInput { 37 public: 38 OpenSlesInput(const int32_t id, PlayoutDelayProvider* delay_provider); 39 ~OpenSlesInput(); 40 41 static int32_t SetAndroidAudioDeviceObjects(void* javaVM, 42 void* env, 43 void* context); 44 static void ClearAndroidAudioDeviceObjects(); 45 46 // Main initializaton and termination 47 int32_t Init(); 48 int32_t Terminate(); Initialized()49 bool Initialized() const { return initialized_; } 50 51 // Device enumeration RecordingDevices()52 int16_t RecordingDevices() { return 1; } 53 int32_t RecordingDeviceName(uint16_t index, 54 char name[kAdmMaxDeviceNameSize], 55 char guid[kAdmMaxGuidSize]); 56 57 // Device selection 58 int32_t SetRecordingDevice(uint16_t index); SetRecordingDevice(AudioDeviceModule::WindowsDeviceType device)59 int32_t SetRecordingDevice( 60 AudioDeviceModule::WindowsDeviceType device) { return -1; } 61 62 // No-op SetRecordingSampleRate(uint32_t sample_rate_hz)63 int32_t SetRecordingSampleRate(uint32_t sample_rate_hz) { return 0; } 64 65 // Audio transport initialization 66 int32_t RecordingIsAvailable(bool& available); // NOLINT 67 int32_t InitRecording(); RecordingIsInitialized()68 bool RecordingIsInitialized() const { return rec_initialized_; } 69 70 // Audio transport control 71 int32_t StartRecording(); 72 int32_t StopRecording(); Recording()73 bool Recording() const { return recording_; } 74 75 // Microphone Automatic Gain Control (AGC) 76 int32_t SetAGC(bool enable); AGC()77 bool AGC() const { return agc_enabled_; } 78 79 // Audio mixer initialization 80 int32_t InitMicrophone(); MicrophoneIsInitialized()81 bool MicrophoneIsInitialized() const { return mic_initialized_; } 82 83 // Microphone volume controls 84 int32_t MicrophoneVolumeIsAvailable(bool& available); // NOLINT 85 // TODO(leozwang): Add microphone volume control when OpenSL APIs 86 // are available. SetMicrophoneVolume(uint32_t volume)87 int32_t SetMicrophoneVolume(uint32_t volume) { return 0; } MicrophoneVolume(uint32_t & volume)88 int32_t MicrophoneVolume(uint32_t& volume) const { return -1; } // NOLINT MaxMicrophoneVolume(uint32_t & maxVolume)89 int32_t MaxMicrophoneVolume( 90 uint32_t& maxVolume) const { return 0; } // NOLINT 91 int32_t MinMicrophoneVolume(uint32_t& minVolume) const; // NOLINT 92 int32_t MicrophoneVolumeStepSize( 93 uint16_t& stepSize) const; // NOLINT 94 95 // Microphone mute control 96 int32_t MicrophoneMuteIsAvailable(bool& available); // NOLINT SetMicrophoneMute(bool enable)97 int32_t SetMicrophoneMute(bool enable) { return -1; } MicrophoneMute(bool & enabled)98 int32_t MicrophoneMute(bool& enabled) const { return -1; } // NOLINT 99 100 // Microphone boost control 101 int32_t MicrophoneBoostIsAvailable(bool& available); // NOLINT 102 int32_t SetMicrophoneBoost(bool enable); 103 int32_t MicrophoneBoost(bool& enabled) const; // NOLINT 104 105 // Stereo support 106 int32_t StereoRecordingIsAvailable(bool& available); // NOLINT SetStereoRecording(bool enable)107 int32_t SetStereoRecording(bool enable) { return -1; } 108 int32_t StereoRecording(bool& enabled) const; // NOLINT 109 110 // Delay information and control 111 int32_t RecordingDelay(uint16_t& delayMS) const; // NOLINT 112 RecordingWarning()113 bool RecordingWarning() const { return false; } RecordingError()114 bool RecordingError() const { return false; } ClearRecordingWarning()115 void ClearRecordingWarning() {} ClearRecordingError()116 void ClearRecordingError() {} 117 118 // Attach audio buffer 119 void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer); 120 121 private: 122 enum { 123 kNumInterfaces = 2, 124 // Keep as few OpenSL buffers as possible to avoid wasting memory. 2 is 125 // minimum for playout. Keep 2 for recording as well. 126 kNumOpenSlBuffers = 2, 127 kNum10MsToBuffer = 3, 128 }; 129 130 int InitSampleRate(); 131 int buffer_size_samples() const; 132 int buffer_size_bytes() const; 133 void UpdateRecordingDelay(); 134 void UpdateSampleRate(); 135 void CalculateNumFifoBuffersNeeded(); 136 void AllocateBuffers(); 137 int TotalBuffersUsed() const; 138 bool EnqueueAllBuffers(); 139 // This function also configures the audio recorder, e.g. sample rate to use 140 // etc, so it should be called when starting recording. 141 bool CreateAudioRecorder(); 142 void DestroyAudioRecorder(); 143 144 // When overrun happens there will be more frames received from OpenSL than 145 // the desired number of buffers. It is possible to expand the number of 146 // buffers as you go but that would greatly increase the complexity of this 147 // code. HandleOverrun gracefully handles the scenario by restarting playout, 148 // throwing away all pending audio data. This will sound like a click. This 149 // is also logged to identify these types of clicks. 150 // This function returns true if there has been overrun. Further processing 151 // of audio data should be avoided until this function returns false again. 152 // The function needs to be protected by |crit_sect_|. 153 bool HandleOverrun(int event_id, int event_msg); 154 155 static void RecorderSimpleBufferQueueCallback( 156 SLAndroidSimpleBufferQueueItf queueItf, 157 void* pContext); 158 // This function must not take any locks or do any heavy work. It is a 159 // requirement for the OpenSL implementation to work as intended. The reason 160 // for this is that taking locks exposes the OpenSL thread to the risk of 161 // priority inversion. 162 void RecorderSimpleBufferQueueCallbackHandler( 163 SLAndroidSimpleBufferQueueItf queueItf); 164 165 bool StartCbThreads(); 166 void StopCbThreads(); 167 static bool CbThread(void* context); 168 // This function must be protected against data race with threads calling this 169 // class' public functions. It is a requirement for this class to be 170 // Thread-compatible. 171 bool CbThreadImpl(); 172 173 // Java API handle 174 AudioManagerJni audio_manager_; 175 176 int id_; 177 PlayoutDelayProvider* delay_provider_; 178 bool initialized_; 179 bool mic_initialized_; 180 bool rec_initialized_; 181 182 // Members that are read/write accessed concurrently by the process thread and 183 // threads calling public functions of this class. 184 scoped_ptr<ThreadWrapper> rec_thread_; // Processing thread 185 scoped_ptr<CriticalSectionWrapper> crit_sect_; 186 // This member controls the starting and stopping of recording audio to the 187 // the device. 188 bool recording_; 189 190 // Only one thread, T1, may push and only one thread, T2, may pull. T1 may or 191 // may not be the same thread as T2. T2 is the process thread and T1 is the 192 // OpenSL thread. 193 scoped_ptr<SingleRwFifo> fifo_; 194 int num_fifo_buffers_needed_; 195 LowLatencyEvent event_; 196 int number_overruns_; 197 198 // OpenSL handles 199 SLObjectItf sles_engine_; 200 SLEngineItf sles_engine_itf_; 201 SLObjectItf sles_recorder_; 202 SLRecordItf sles_recorder_itf_; 203 SLAndroidSimpleBufferQueueItf sles_recorder_sbq_itf_; 204 205 // Audio buffers 206 AudioDeviceBuffer* audio_buffer_; 207 // Holds all allocated memory such that it is deallocated properly. 208 scoped_ptr<scoped_ptr<int8_t[]>[]> rec_buf_; 209 // Index in |rec_buf_| pointing to the audio buffer that will be ready the 210 // next time RecorderSimpleBufferQueueCallbackHandler is invoked. 211 // Ready means buffer contains audio data from the device. 212 int active_queue_; 213 214 // Audio settings 215 uint32_t rec_sampling_rate_; 216 bool agc_enabled_; 217 218 // Audio status 219 uint16_t recording_delay_; 220 }; 221 222 } // namespace webrtc 223 224 #endif // WEBRTC_MODULES_AUDIO_DEVICE_ANDROID_OPENSLES_INPUT_H_ 225