| /* |
| * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #if !defined(__has_feature) || !__has_feature(objc_arc) |
| #error "This file requires ARC support." |
| #endif |
| |
| #import <AVFoundation/AVFoundation.h> |
| #import <Foundation/Foundation.h> |
| |
| #include "webrtc/modules/audio_device/ios/audio_device_ios.h" |
| #include "webrtc/modules/utility/interface/helpers_ios.h" |
| |
| #include "webrtc/base/checks.h" |
| #include "webrtc/base/logging.h" |
| #include "webrtc/system_wrappers/interface/trace.h" |
| |
| namespace webrtc { |
| |
| #define LOGI() LOG(LS_INFO) << "AudioDeviceIOS::" |
| |
| using ios::CheckAndLogError; |
| |
| #if !defined(NDEBUG) |
| static void LogDeviceInfo() { |
| LOG(LS_INFO) << "LogDeviceInfo"; |
| @autoreleasepool { |
| LOG(LS_INFO) << " system name: " << ios::GetSystemName(); |
| LOG(LS_INFO) << " system version: " << ios::GetSystemVersion(); |
| LOG(LS_INFO) << " device type: " << ios::GetDeviceType(); |
| LOG(LS_INFO) << " device name: " << ios::GetDeviceName(); |
| } |
| } |
| #endif |
| |
| static void ActivateAudioSession(AVAudioSession* session, bool activate) { |
| LOG(LS_INFO) << "ActivateAudioSession(" << activate << ")"; |
| @autoreleasepool { |
| NSError* error = nil; |
| BOOL success = NO; |
| if (!activate) { |
| // Deactivate the audio session. |
| success = [session setActive:NO error:&error]; |
| DCHECK(CheckAndLogError(success, error)); |
| return; |
| } |
| // Activate an audio session and set category and mode. Only make changes |
| // if needed since setting them to the value they already have will clear |
| // transient properties (such as PortOverride) that some other component |
| // have set up. |
| if (session.category != AVAudioSessionCategoryPlayAndRecord) { |
| error = nil; |
| success = [session setCategory:AVAudioSessionCategoryPlayAndRecord |
| error:&error]; |
| DCHECK(CheckAndLogError(success, error)); |
| } |
| if (session.mode != AVAudioSessionModeVoiceChat) { |
| error = nil; |
| success = [session setMode:AVAudioSessionModeVoiceChat error:&error]; |
| DCHECK(CheckAndLogError(success, error)); |
| } |
| error = nil; |
| success = [session setActive:YES error:&error]; |
| DCHECK(CheckAndLogError(success, error)); |
| // Ensure that category and mode are actually activated. |
| DCHECK( |
| [session.category isEqualToString:AVAudioSessionCategoryPlayAndRecord]); |
| DCHECK([session.mode isEqualToString:AVAudioSessionModeVoiceChat]); |
| } |
| } |
| |
| // Query hardware characteristics, such as input and output latency, input and |
| // output channel count, hardware sample rate, hardware volume setting, and |
| // whether audio input is available. To obtain meaningful values for hardware |
| // characteristics,the audio session must be initialized and active before we |
| // query the values. |
| // TODO(henrika): Note that these characteristics can change at runtime. For |
| // instance, input sample rate may change when a user plugs in a headset. |
| static void GetHardwareAudioParameters(AudioParameters* playout_parameters, |
| AudioParameters* record_parameters) { |
| LOG(LS_INFO) << "GetHardwareAudioParameters"; |
| @autoreleasepool { |
| // Implicit initialization happens when we obtain a reference to the |
| // AVAudioSession object. |
| AVAudioSession* session = [AVAudioSession sharedInstance]; |
| // Always get values when the audio session is active. |
| ActivateAudioSession(session, true); |
| CHECK(session.isInputAvailable) << "No input path is available!"; |
| // Get current hardware parameters. |
| double sample_rate = (double)session.sampleRate; |
| double io_buffer_duration = (double)session.IOBufferDuration; |
| int output_channels = (int)session.outputNumberOfChannels; |
| int input_channels = (int)session.inputNumberOfChannels; |
| int frames_per_buffer = |
| static_cast<int>(sample_rate * io_buffer_duration + 0.5); |
| // Copy hardware parameters to output parameters. |
| playout_parameters->reset(sample_rate, output_channels, frames_per_buffer); |
| record_parameters->reset(sample_rate, input_channels, frames_per_buffer); |
| // Add logging for debugging purposes. |
| LOG(LS_INFO) << " sample rate: " << sample_rate; |
| LOG(LS_INFO) << " IO buffer duration: " << io_buffer_duration; |
| LOG(LS_INFO) << " frames_per_buffer: " << frames_per_buffer; |
| LOG(LS_INFO) << " output channels: " << output_channels; |
| LOG(LS_INFO) << " input channels: " << input_channels; |
| LOG(LS_INFO) << " output latency: " << (double)session.outputLatency; |
| LOG(LS_INFO) << " input latency: " << (double)session.inputLatency; |
| // Don't keep the audio session active. Instead, deactivate when needed. |
| ActivateAudioSession(session, false); |
| // TODO(henrika): to be extra safe, we can do more here. E.g., set |
| // preferred values for sample rate, channels etc., re-activate an audio |
| // session and verify the actual values again. Then we know for sure that |
| // the current values will in fact be correct. Or, we can skip all this |
| // and check setting when audio is started. Probably better. |
| } |
| } |
| |
| AudioDeviceIOS::AudioDeviceIOS() |
| : audio_device_buffer_(nullptr), |
| _critSect(*CriticalSectionWrapper::CreateCriticalSection()), |
| _auVoiceProcessing(nullptr), |
| _audioInterruptionObserver(nullptr), |
| _initialized(false), |
| _isShutDown(false), |
| _recording(false), |
| _playing(false), |
| _recIsInitialized(false), |
| _playIsInitialized(false), |
| _adbSampFreq(0), |
| _recordingDelay(0), |
| _playoutDelay(0), |
| _playoutDelayMeasurementCounter(9999), |
| _recordingDelayHWAndOS(0), |
| _recordingDelayMeasurementCounter(9999), |
| _playoutBufferUsed(0), |
| _recordingCurrentSeq(0), |
| _recordingBufferTotalSize(0) { |
| LOGI() << "ctor" << ios::GetCurrentThreadDescription(); |
| memset(_playoutBuffer, 0, sizeof(_playoutBuffer)); |
| memset(_recordingBuffer, 0, sizeof(_recordingBuffer)); |
| memset(_recordingLength, 0, sizeof(_recordingLength)); |
| memset(_recordingSeqNumber, 0, sizeof(_recordingSeqNumber)); |
| } |
| |
| AudioDeviceIOS::~AudioDeviceIOS() { |
| LOGI() << "~dtor"; |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| Terminate(); |
| delete &_critSect; |
| } |
| |
| void AudioDeviceIOS::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) { |
| LOGI() << "AttachAudioBuffer"; |
| DCHECK(audioBuffer); |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| audio_device_buffer_ = audioBuffer; |
| } |
| |
| int32_t AudioDeviceIOS::Init() { |
| LOGI() << "Init"; |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| if (_initialized) { |
| return 0; |
| } |
| #if !defined(NDEBUG) |
| LogDeviceInfo(); |
| #endif |
| // Query hardware audio parameters and cache the results. These parameters |
| // will be used as preferred values later when streaming starts. |
| // Note that I override these "optimal" value below since I don't want to |
| // modify the existing behavior yet. |
| GetHardwareAudioParameters(&playout_parameters_, &record_parameters_); |
| // TODO(henrika): these parameters are currently hard coded to match the |
| // existing implementation where we always use 16kHz as preferred sample |
| // rate and mono only. Goal is to improve this scheme and make it more |
| // flexible. In addition, a better native buffer size shall be derived. |
| // Using 10ms as default here (only used by unit test so far). |
| // We should also implemented observers for notification of any change in |
| // these parameters. |
| playout_parameters_.reset(16000, 1, 160); |
| record_parameters_.reset(16000, 1, 160); |
| |
| // AttachAudioBuffer() is called at construction by the main class but check |
| // just in case. |
| DCHECK(audio_device_buffer_) << "AttachAudioBuffer must be called first"; |
| // Inform the audio device buffer (ADB) about the new audio format. |
| // TODO(henrika): try to improve this section. |
| audio_device_buffer_->SetPlayoutSampleRate(playout_parameters_.sample_rate()); |
| audio_device_buffer_->SetPlayoutChannels(playout_parameters_.channels()); |
| audio_device_buffer_->SetRecordingSampleRate( |
| record_parameters_.sample_rate()); |
| audio_device_buffer_->SetRecordingChannels(record_parameters_.channels()); |
| |
| DCHECK(!_captureWorkerThread); |
| // Create and start the capture thread. |
| // TODO(henrika): do we need this thread? |
| _isShutDown = false; |
| _captureWorkerThread = |
| ThreadWrapper::CreateThread(RunCapture, this, "CaptureWorkerThread"); |
| if (!_captureWorkerThread->Start()) { |
| LOG_F(LS_ERROR) << "Failed to start CaptureWorkerThread!"; |
| return -1; |
| } |
| _captureWorkerThread->SetPriority(kRealtimePriority); |
| _initialized = true; |
| return 0; |
| } |
| |
| int32_t AudioDeviceIOS::Terminate() { |
| LOGI() << "Terminate"; |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| if (!_initialized) { |
| return 0; |
| } |
| // Stop the capture thread. |
| if (_captureWorkerThread) { |
| if (!_captureWorkerThread->Stop()) { |
| LOG_F(LS_ERROR) << "Failed to stop CaptureWorkerThread!"; |
| return -1; |
| } |
| _captureWorkerThread.reset(); |
| } |
| ShutdownPlayOrRecord(); |
| _isShutDown = true; |
| _initialized = false; |
| return 0; |
| } |
| |
| int32_t AudioDeviceIOS::InitPlayout() { |
| LOGI() << "InitPlayout"; |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| DCHECK(_initialized); |
| DCHECK(!_playIsInitialized); |
| DCHECK(!_playing); |
| if (!_recIsInitialized) { |
| if (InitPlayOrRecord() == -1) { |
| LOG_F(LS_ERROR) << "InitPlayOrRecord failed!"; |
| return -1; |
| } |
| } |
| _playIsInitialized = true; |
| return 0; |
| } |
| |
| int32_t AudioDeviceIOS::InitRecording() { |
| LOGI() << "InitPlayout"; |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| DCHECK(_initialized); |
| DCHECK(!_recIsInitialized); |
| DCHECK(!_recording); |
| if (!_playIsInitialized) { |
| if (InitPlayOrRecord() == -1) { |
| LOG_F(LS_ERROR) << "InitPlayOrRecord failed!"; |
| return -1; |
| } |
| } |
| _recIsInitialized = true; |
| return 0; |
| } |
| |
| int32_t AudioDeviceIOS::StartPlayout() { |
| LOGI() << "StartPlayout"; |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| DCHECK(_playIsInitialized); |
| DCHECK(!_playing); |
| |
| CriticalSectionScoped lock(&_critSect); |
| |
| memset(_playoutBuffer, 0, sizeof(_playoutBuffer)); |
| _playoutBufferUsed = 0; |
| _playoutDelay = 0; |
| // Make sure first call to update delay function will update delay |
| _playoutDelayMeasurementCounter = 9999; |
| |
| if (!_recording) { |
| OSStatus result = AudioOutputUnitStart(_auVoiceProcessing); |
| if (result != noErr) { |
| LOG_F(LS_ERROR) << "AudioOutputUnitStart failed: " << result; |
| return -1; |
| } |
| } |
| _playing = true; |
| return 0; |
| } |
| |
| int32_t AudioDeviceIOS::StopPlayout() { |
| LOGI() << "StopPlayout"; |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| if (!_playIsInitialized || !_playing) { |
| return 0; |
| } |
| |
| CriticalSectionScoped lock(&_critSect); |
| |
| if (!_recording) { |
| // Both playout and recording has stopped, shutdown the device. |
| ShutdownPlayOrRecord(); |
| } |
| _playIsInitialized = false; |
| _playing = false; |
| return 0; |
| } |
| |
| int32_t AudioDeviceIOS::StartRecording() { |
| LOGI() << "StartRecording"; |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| DCHECK(_recIsInitialized); |
| DCHECK(!_recording); |
| |
| CriticalSectionScoped lock(&_critSect); |
| |
| memset(_recordingBuffer, 0, sizeof(_recordingBuffer)); |
| memset(_recordingLength, 0, sizeof(_recordingLength)); |
| memset(_recordingSeqNumber, 0, sizeof(_recordingSeqNumber)); |
| |
| _recordingCurrentSeq = 0; |
| _recordingBufferTotalSize = 0; |
| _recordingDelay = 0; |
| _recordingDelayHWAndOS = 0; |
| // Make sure first call to update delay function will update delay |
| _recordingDelayMeasurementCounter = 9999; |
| |
| if (!_playing) { |
| OSStatus result = AudioOutputUnitStart(_auVoiceProcessing); |
| if (result != noErr) { |
| LOG_F(LS_ERROR) << "AudioOutputUnitStart failed: " << result; |
| return -1; |
| } |
| } |
| _recording = true; |
| return 0; |
| } |
| |
| int32_t AudioDeviceIOS::StopRecording() { |
| LOGI() << "StopRecording"; |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| if (!_recIsInitialized || !_recording) { |
| return 0; |
| } |
| |
| CriticalSectionScoped lock(&_critSect); |
| |
| if (!_playing) { |
| // Both playout and recording has stopped, shutdown the device. |
| ShutdownPlayOrRecord(); |
| } |
| _recIsInitialized = false; |
| _recording = false; |
| return 0; |
| } |
| |
| // Change the default receiver playout route to speaker. |
| int32_t AudioDeviceIOS::SetLoudspeakerStatus(bool enable) { |
| LOGI() << "SetLoudspeakerStatus(" << enable << ")"; |
| |
| AVAudioSession* session = [AVAudioSession sharedInstance]; |
| NSString* category = session.category; |
| AVAudioSessionCategoryOptions options = session.categoryOptions; |
| // Respect old category options if category is |
| // AVAudioSessionCategoryPlayAndRecord. Otherwise reset it since old options |
| // might not be valid for this category. |
| if ([category isEqualToString:AVAudioSessionCategoryPlayAndRecord]) { |
| if (enable) { |
| options |= AVAudioSessionCategoryOptionDefaultToSpeaker; |
| } else { |
| options &= ~AVAudioSessionCategoryOptionDefaultToSpeaker; |
| } |
| } else { |
| options = AVAudioSessionCategoryOptionDefaultToSpeaker; |
| } |
| NSError* error = nil; |
| BOOL success = [session setCategory:AVAudioSessionCategoryPlayAndRecord |
| withOptions:options |
| error:&error]; |
| ios::CheckAndLogError(success, error); |
| return (error == nil) ? 0 : -1; |
| } |
| |
| int32_t AudioDeviceIOS::GetLoudspeakerStatus(bool& enabled) const { |
| LOGI() << "GetLoudspeakerStatus"; |
| AVAudioSession* session = [AVAudioSession sharedInstance]; |
| AVAudioSessionCategoryOptions options = session.categoryOptions; |
| enabled = options & AVAudioSessionCategoryOptionDefaultToSpeaker; |
| return 0; |
| } |
| |
| int32_t AudioDeviceIOS::PlayoutDelay(uint16_t& delayMS) const { |
| delayMS = _playoutDelay; |
| return 0; |
| } |
| |
| int32_t AudioDeviceIOS::RecordingDelay(uint16_t& delayMS) const { |
| delayMS = _recordingDelay; |
| return 0; |
| } |
| |
| int32_t AudioDeviceIOS::PlayoutBuffer(AudioDeviceModule::BufferType& type, |
| uint16_t& sizeMS) const { |
| type = AudioDeviceModule::kAdaptiveBufferSize; |
| sizeMS = _playoutDelay; |
| return 0; |
| } |
| |
| int AudioDeviceIOS::GetPlayoutAudioParameters(AudioParameters* params) const { |
| CHECK(playout_parameters_.is_valid()); |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| *params = playout_parameters_; |
| return 0; |
| } |
| |
| int AudioDeviceIOS::GetRecordAudioParameters(AudioParameters* params) const { |
| CHECK(record_parameters_.is_valid()); |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| *params = record_parameters_; |
| return 0; |
| } |
| |
| // ============================================================================ |
| // Private Methods |
| // ============================================================================ |
| |
| int32_t AudioDeviceIOS::InitPlayOrRecord() { |
| LOGI() << "AudioDeviceIOS::InitPlayOrRecord"; |
| DCHECK(!_auVoiceProcessing); |
| |
| OSStatus result = -1; |
| |
| // Create Voice Processing Audio Unit |
| AudioComponentDescription desc; |
| AudioComponent comp; |
| |
| desc.componentType = kAudioUnitType_Output; |
| desc.componentSubType = kAudioUnitSubType_VoiceProcessingIO; |
| desc.componentManufacturer = kAudioUnitManufacturer_Apple; |
| desc.componentFlags = 0; |
| desc.componentFlagsMask = 0; |
| |
| comp = AudioComponentFindNext(nullptr, &desc); |
| if (nullptr == comp) { |
| LOG_F(LS_ERROR) << "Could not find audio component for Audio Unit"; |
| return -1; |
| } |
| |
| result = AudioComponentInstanceNew(comp, &_auVoiceProcessing); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "Failed to create Audio Unit instance: " << result; |
| return -1; |
| } |
| |
| // TODO(henrika): I think we should set the preferred channel configuration |
| // in both directions as well to be safe. |
| |
| // Set preferred hardware sample rate to 16 kHz. |
| // TODO(henrika): improve this selection of sample rate. Why do we currently |
| // use a hard coded value? How can we fail and still continue? |
| NSError* error = nil; |
| AVAudioSession* session = [AVAudioSession sharedInstance]; |
| Float64 preferredSampleRate(playout_parameters_.sample_rate()); |
| [session setPreferredSampleRate:preferredSampleRate error:&error]; |
| if (error != nil) { |
| const char* errorString = [[error localizedDescription] UTF8String]; |
| LOG_F(LS_ERROR) << "setPreferredSampleRate failed: " << errorString; |
| } |
| |
| // TODO(henrika): we can reduce latency by setting the IOBufferDuration |
| // here. Default size for 16kHz is 0.016 sec or 16 msec on an iPhone 6. |
| |
| // Activate the audio session. |
| ActivateAudioSession(session, true); |
| |
| UInt32 enableIO = 1; |
| result = AudioUnitSetProperty(_auVoiceProcessing, |
| kAudioOutputUnitProperty_EnableIO, |
| kAudioUnitScope_Input, |
| 1, // input bus |
| &enableIO, sizeof(enableIO)); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "Failed to enable IO on input: " << result; |
| } |
| |
| result = AudioUnitSetProperty(_auVoiceProcessing, |
| kAudioOutputUnitProperty_EnableIO, |
| kAudioUnitScope_Output, |
| 0, // output bus |
| &enableIO, sizeof(enableIO)); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "Failed to enable IO on output: " << result; |
| } |
| |
| // Disable AU buffer allocation for the recorder, we allocate our own. |
| // TODO(henrika): understand this part better. |
| UInt32 flag = 0; |
| result = AudioUnitSetProperty(_auVoiceProcessing, |
| kAudioUnitProperty_ShouldAllocateBuffer, |
| kAudioUnitScope_Output, 1, &flag, sizeof(flag)); |
| if (0 != result) { |
| LOG_F(LS_WARNING) << "Failed to disable AU buffer allocation: " << result; |
| // Should work anyway |
| } |
| |
| // Set recording callback. |
| AURenderCallbackStruct auCbS; |
| memset(&auCbS, 0, sizeof(auCbS)); |
| auCbS.inputProc = RecordProcess; |
| auCbS.inputProcRefCon = this; |
| result = AudioUnitSetProperty( |
| _auVoiceProcessing, kAudioOutputUnitProperty_SetInputCallback, |
| kAudioUnitScope_Global, 1, &auCbS, sizeof(auCbS)); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "Failed to set AU record callback: " << result; |
| } |
| |
| // Set playout callback. |
| memset(&auCbS, 0, sizeof(auCbS)); |
| auCbS.inputProc = PlayoutProcess; |
| auCbS.inputProcRefCon = this; |
| result = AudioUnitSetProperty( |
| _auVoiceProcessing, kAudioUnitProperty_SetRenderCallback, |
| kAudioUnitScope_Global, 0, &auCbS, sizeof(auCbS)); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "Failed to set AU output callback: " << result; |
| } |
| |
| // Get stream format for out/0 |
| AudioStreamBasicDescription playoutDesc; |
| UInt32 size = sizeof(playoutDesc); |
| result = |
| AudioUnitGetProperty(_auVoiceProcessing, kAudioUnitProperty_StreamFormat, |
| kAudioUnitScope_Output, 0, &playoutDesc, &size); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "Failed to get AU output stream format: " << result; |
| } |
| |
| playoutDesc.mSampleRate = preferredSampleRate; |
| LOG(LS_INFO) << "Audio Unit playout opened in sampling rate: " |
| << playoutDesc.mSampleRate; |
| |
| // Store the sampling frequency to use towards the Audio Device Buffer |
| // todo: Add 48 kHz (increase buffer sizes). Other fs? |
| // TODO(henrika): Figure out if we really need this complex handling. |
| if ((playoutDesc.mSampleRate > 44090.0) && |
| (playoutDesc.mSampleRate < 44110.0)) { |
| _adbSampFreq = 44100; |
| } else if ((playoutDesc.mSampleRate > 15990.0) && |
| (playoutDesc.mSampleRate < 16010.0)) { |
| _adbSampFreq = 16000; |
| } else if ((playoutDesc.mSampleRate > 7990.0) && |
| (playoutDesc.mSampleRate < 8010.0)) { |
| _adbSampFreq = 8000; |
| } else { |
| _adbSampFreq = 0; |
| FATAL() << "Invalid sample rate"; |
| } |
| |
| // Set the audio device buffer sampling rates (use same for play and record). |
| // TODO(henrika): this is not a good place to set these things up. |
| DCHECK(audio_device_buffer_); |
| DCHECK_EQ(_adbSampFreq, playout_parameters_.sample_rate()); |
| audio_device_buffer_->SetRecordingSampleRate(_adbSampFreq); |
| audio_device_buffer_->SetPlayoutSampleRate(_adbSampFreq); |
| |
| // Set stream format for out/0. |
| playoutDesc.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | |
| kLinearPCMFormatFlagIsPacked | |
| kLinearPCMFormatFlagIsNonInterleaved; |
| playoutDesc.mBytesPerPacket = 2; |
| playoutDesc.mFramesPerPacket = 1; |
| playoutDesc.mBytesPerFrame = 2; |
| playoutDesc.mChannelsPerFrame = 1; |
| playoutDesc.mBitsPerChannel = 16; |
| result = |
| AudioUnitSetProperty(_auVoiceProcessing, kAudioUnitProperty_StreamFormat, |
| kAudioUnitScope_Input, 0, &playoutDesc, size); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "Failed to set AU stream format for out/0"; |
| } |
| |
| // Get stream format for in/1. |
| AudioStreamBasicDescription recordingDesc; |
| size = sizeof(recordingDesc); |
| result = |
| AudioUnitGetProperty(_auVoiceProcessing, kAudioUnitProperty_StreamFormat, |
| kAudioUnitScope_Input, 1, &recordingDesc, &size); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "Failed to get AU stream format for in/1"; |
| } |
| |
| recordingDesc.mSampleRate = preferredSampleRate; |
| LOG(LS_INFO) << "Audio Unit recording opened in sampling rate: " |
| << recordingDesc.mSampleRate; |
| |
| // Set stream format for out/1 (use same sampling frequency as for in/1). |
| recordingDesc.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | |
| kLinearPCMFormatFlagIsPacked | |
| kLinearPCMFormatFlagIsNonInterleaved; |
| recordingDesc.mBytesPerPacket = 2; |
| recordingDesc.mFramesPerPacket = 1; |
| recordingDesc.mBytesPerFrame = 2; |
| recordingDesc.mChannelsPerFrame = 1; |
| recordingDesc.mBitsPerChannel = 16; |
| result = |
| AudioUnitSetProperty(_auVoiceProcessing, kAudioUnitProperty_StreamFormat, |
| kAudioUnitScope_Output, 1, &recordingDesc, size); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "Failed to set AU stream format for out/1"; |
| } |
| |
| // Initialize here already to be able to get/set stream properties. |
| result = AudioUnitInitialize(_auVoiceProcessing); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "AudioUnitInitialize failed: " << result; |
| } |
| |
| // Get hardware sample rate for logging (see if we get what we asked for). |
| // TODO(henrika): what if we don't get what we ask for? |
| double sampleRate = session.sampleRate; |
| LOG(LS_INFO) << "Current HW sample rate is: " << sampleRate |
| << ", ADB sample rate is: " << _adbSampFreq; |
| LOG(LS_INFO) << "Current HW IO buffer size is: " << |
| [session IOBufferDuration]; |
| |
| // Listen to audio interruptions. |
| // TODO(henrika): learn this area better. |
| NSNotificationCenter* center = [NSNotificationCenter defaultCenter]; |
| id observer = [center |
| addObserverForName:AVAudioSessionInterruptionNotification |
| object:nil |
| queue:[NSOperationQueue mainQueue] |
| usingBlock:^(NSNotification* notification) { |
| NSNumber* typeNumber = |
| [notification userInfo][AVAudioSessionInterruptionTypeKey]; |
| AVAudioSessionInterruptionType type = |
| (AVAudioSessionInterruptionType)[typeNumber |
| unsignedIntegerValue]; |
| switch (type) { |
| case AVAudioSessionInterruptionTypeBegan: |
| // At this point our audio session has been deactivated and |
| // the |
| // audio unit render callbacks no longer occur. Nothing to |
| // do. |
| break; |
| case AVAudioSessionInterruptionTypeEnded: { |
| NSError* error = nil; |
| AVAudioSession* session = [AVAudioSession sharedInstance]; |
| [session setActive:YES error:&error]; |
| if (error != nil) { |
| LOG_F(LS_ERROR) << "Failed to active audio session"; |
| } |
| // Post interruption the audio unit render callbacks don't |
| // automatically continue, so we restart the unit manually |
| // here. |
| AudioOutputUnitStop(_auVoiceProcessing); |
| AudioOutputUnitStart(_auVoiceProcessing); |
| break; |
| } |
| } |
| }]; |
| // Increment refcount on observer using ARC bridge. Instance variable is a |
| // void* instead of an id because header is included in other pure C++ |
| // files. |
| _audioInterruptionObserver = (__bridge_retained void*)observer; |
| |
| // Deactivate the audio session. |
| ActivateAudioSession(session, false); |
| |
| return 0; |
| } |
| |
| int32_t AudioDeviceIOS::ShutdownPlayOrRecord() { |
| LOGI() << "ShutdownPlayOrRecord"; |
| |
| if (_audioInterruptionObserver != nullptr) { |
| NSNotificationCenter* center = [NSNotificationCenter defaultCenter]; |
| // Transfer ownership of observer back to ARC, which will dealloc the |
| // observer once it exits this scope. |
| id observer = (__bridge_transfer id)_audioInterruptionObserver; |
| [center removeObserver:observer]; |
| _audioInterruptionObserver = nullptr; |
| } |
| |
| // Close and delete AU. |
| OSStatus result = -1; |
| if (nullptr != _auVoiceProcessing) { |
| result = AudioOutputUnitStop(_auVoiceProcessing); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "AudioOutputUnitStop failed: " << result; |
| } |
| result = AudioComponentInstanceDispose(_auVoiceProcessing); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "AudioComponentInstanceDispose failed: " << result; |
| } |
| _auVoiceProcessing = nullptr; |
| } |
| |
| return 0; |
| } |
| |
| // ============================================================================ |
| // Thread Methods |
| // ============================================================================ |
| |
| OSStatus AudioDeviceIOS::RecordProcess( |
| void* inRefCon, |
| AudioUnitRenderActionFlags* ioActionFlags, |
| const AudioTimeStamp* inTimeStamp, |
| UInt32 inBusNumber, |
| UInt32 inNumberFrames, |
| AudioBufferList* ioData) { |
| AudioDeviceIOS* ptrThis = static_cast<AudioDeviceIOS*>(inRefCon); |
| return ptrThis->RecordProcessImpl(ioActionFlags, inTimeStamp, inBusNumber, |
| inNumberFrames); |
| } |
| |
| OSStatus AudioDeviceIOS::RecordProcessImpl( |
| AudioUnitRenderActionFlags* ioActionFlags, |
| const AudioTimeStamp* inTimeStamp, |
| uint32_t inBusNumber, |
| uint32_t inNumberFrames) { |
| // Setup some basic stuff |
| // Use temp buffer not to lock up recording buffer more than necessary |
| // todo: Make dataTmp a member variable with static size that holds |
| // max possible frames? |
| int16_t* dataTmp = new int16_t[inNumberFrames]; |
| memset(dataTmp, 0, 2 * inNumberFrames); |
| |
| AudioBufferList abList; |
| abList.mNumberBuffers = 1; |
| abList.mBuffers[0].mData = dataTmp; |
| abList.mBuffers[0].mDataByteSize = 2 * inNumberFrames; // 2 bytes/sample |
| abList.mBuffers[0].mNumberChannels = 1; |
| |
| // Get data from mic |
| OSStatus res = AudioUnitRender(_auVoiceProcessing, ioActionFlags, inTimeStamp, |
| inBusNumber, inNumberFrames, &abList); |
| if (res != 0) { |
| // TODO(henrika): improve error handling. |
| delete[] dataTmp; |
| return 0; |
| } |
| |
| if (_recording) { |
| // Insert all data in temp buffer into recording buffers |
| // There is zero or one buffer partially full at any given time, |
| // all others are full or empty |
| // Full means filled with noSamp10ms samples. |
| |
| const unsigned int noSamp10ms = _adbSampFreq / 100; |
| unsigned int dataPos = 0; |
| uint16_t bufPos = 0; |
| int16_t insertPos = -1; |
| unsigned int nCopy = 0; // Number of samples to copy |
| |
| while (dataPos < inNumberFrames) { |
| // Loop over all recording buffers or |
| // until we find the partially full buffer |
| // First choice is to insert into partially full buffer, |
| // second choice is to insert into empty buffer |
| bufPos = 0; |
| insertPos = -1; |
| nCopy = 0; |
| while (bufPos < N_REC_BUFFERS) { |
| if ((_recordingLength[bufPos] > 0) && |
| (_recordingLength[bufPos] < noSamp10ms)) { |
| // Found the partially full buffer |
| insertPos = static_cast<int16_t>(bufPos); |
| // Don't need to search more, quit loop |
| bufPos = N_REC_BUFFERS; |
| } else if ((-1 == insertPos) && (0 == _recordingLength[bufPos])) { |
| // Found an empty buffer |
| insertPos = static_cast<int16_t>(bufPos); |
| } |
| ++bufPos; |
| } |
| |
| // Insert data into buffer |
| if (insertPos > -1) { |
| // We found a non-full buffer, copy data to it |
| unsigned int dataToCopy = inNumberFrames - dataPos; |
| unsigned int currentRecLen = _recordingLength[insertPos]; |
| unsigned int roomInBuffer = noSamp10ms - currentRecLen; |
| nCopy = (dataToCopy < roomInBuffer ? dataToCopy : roomInBuffer); |
| |
| memcpy(&_recordingBuffer[insertPos][currentRecLen], &dataTmp[dataPos], |
| nCopy * sizeof(int16_t)); |
| if (0 == currentRecLen) { |
| _recordingSeqNumber[insertPos] = _recordingCurrentSeq; |
| ++_recordingCurrentSeq; |
| } |
| _recordingBufferTotalSize += nCopy; |
| // Has to be done last to avoid interrupt problems between threads. |
| _recordingLength[insertPos] += nCopy; |
| dataPos += nCopy; |
| } else { |
| // Didn't find a non-full buffer |
| // TODO(henrika): improve error handling |
| dataPos = inNumberFrames; // Don't try to insert more |
| } |
| } |
| } |
| delete[] dataTmp; |
| return 0; |
| } |
| |
| OSStatus AudioDeviceIOS::PlayoutProcess( |
| void* inRefCon, |
| AudioUnitRenderActionFlags* ioActionFlags, |
| const AudioTimeStamp* inTimeStamp, |
| UInt32 inBusNumber, |
| UInt32 inNumberFrames, |
| AudioBufferList* ioData) { |
| AudioDeviceIOS* ptrThis = static_cast<AudioDeviceIOS*>(inRefCon); |
| return ptrThis->PlayoutProcessImpl(inNumberFrames, ioData); |
| } |
| |
| OSStatus AudioDeviceIOS::PlayoutProcessImpl(uint32_t inNumberFrames, |
| AudioBufferList* ioData) { |
| int16_t* data = static_cast<int16_t*>(ioData->mBuffers[0].mData); |
| unsigned int dataSizeBytes = ioData->mBuffers[0].mDataByteSize; |
| unsigned int dataSize = dataSizeBytes / 2; // Number of samples |
| CHECK_EQ(dataSize, inNumberFrames); |
| memset(data, 0, dataSizeBytes); // Start with empty buffer |
| |
| // Get playout data from Audio Device Buffer |
| |
| if (_playing) { |
| unsigned int noSamp10ms = _adbSampFreq / 100; |
| // todo: Member variable and allocate when samp freq is determined |
| int16_t* dataTmp = new int16_t[noSamp10ms]; |
| memset(dataTmp, 0, 2 * noSamp10ms); |
| unsigned int dataPos = 0; |
| int noSamplesOut = 0; |
| unsigned int nCopy = 0; |
| |
| // First insert data from playout buffer if any |
| if (_playoutBufferUsed > 0) { |
| nCopy = (dataSize < _playoutBufferUsed) ? dataSize : _playoutBufferUsed; |
| DCHECK_EQ(nCopy, _playoutBufferUsed); |
| memcpy(data, _playoutBuffer, 2 * nCopy); |
| dataPos = nCopy; |
| memset(_playoutBuffer, 0, sizeof(_playoutBuffer)); |
| _playoutBufferUsed = 0; |
| } |
| |
| // Now get the rest from Audio Device Buffer. |
| while (dataPos < dataSize) { |
| // Update playout delay |
| UpdatePlayoutDelay(); |
| |
| // Ask for new PCM data to be played out using the AudioDeviceBuffer |
| noSamplesOut = audio_device_buffer_->RequestPlayoutData(noSamp10ms); |
| |
| // Get data from Audio Device Buffer |
| noSamplesOut = audio_device_buffer_->GetPlayoutData( |
| reinterpret_cast<int8_t*>(dataTmp)); |
| CHECK_EQ(noSamp10ms, (unsigned int)noSamplesOut); |
| |
| // Insert as much as fits in data buffer |
| nCopy = |
| (dataSize - dataPos) > noSamp10ms ? noSamp10ms : (dataSize - dataPos); |
| memcpy(&data[dataPos], dataTmp, 2 * nCopy); |
| |
| // Save rest in playout buffer if any |
| if (nCopy < noSamp10ms) { |
| memcpy(_playoutBuffer, &dataTmp[nCopy], 2 * (noSamp10ms - nCopy)); |
| _playoutBufferUsed = noSamp10ms - nCopy; |
| } |
| |
| // Update loop/index counter, if we copied less than noSamp10ms |
| // samples we shall quit loop anyway |
| dataPos += noSamp10ms; |
| } |
| delete[] dataTmp; |
| } |
| return 0; |
| } |
| |
| // TODO(henrika): can either be removed or simplified. |
| void AudioDeviceIOS::UpdatePlayoutDelay() { |
| ++_playoutDelayMeasurementCounter; |
| |
| if (_playoutDelayMeasurementCounter >= 100) { |
| // Update HW and OS delay every second, unlikely to change |
| |
| // Since this is eventually rounded to integral ms, add 0.5ms |
| // here to get round-to-nearest-int behavior instead of |
| // truncation. |
| double totalDelaySeconds = 0.0005; |
| |
| // HW output latency |
| AVAudioSession* session = [AVAudioSession sharedInstance]; |
| double latency = session.outputLatency; |
| assert(latency >= 0); |
| totalDelaySeconds += latency; |
| |
| // HW buffer duration |
| double ioBufferDuration = session.IOBufferDuration; |
| assert(ioBufferDuration >= 0); |
| totalDelaySeconds += ioBufferDuration; |
| |
| // AU latency |
| Float64 f64(0); |
| UInt32 size = sizeof(f64); |
| OSStatus result = |
| AudioUnitGetProperty(_auVoiceProcessing, kAudioUnitProperty_Latency, |
| kAudioUnitScope_Global, 0, &f64, &size); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "AU latency error: " << result; |
| } |
| assert(f64 >= 0); |
| totalDelaySeconds += f64; |
| |
| // To ms |
| _playoutDelay = static_cast<uint32_t>(totalDelaySeconds / 1000); |
| |
| // Reset counter |
| _playoutDelayMeasurementCounter = 0; |
| } |
| |
| // todo: Add playout buffer? |
| } |
| |
| void AudioDeviceIOS::UpdateRecordingDelay() { |
| ++_recordingDelayMeasurementCounter; |
| |
| if (_recordingDelayMeasurementCounter >= 100) { |
| // Update HW and OS delay every second, unlikely to change |
| |
| // Since this is eventually rounded to integral ms, add 0.5ms |
| // here to get round-to-nearest-int behavior instead of |
| // truncation. |
| double totalDelaySeconds = 0.0005; |
| |
| // HW input latency |
| AVAudioSession* session = [AVAudioSession sharedInstance]; |
| double latency = session.inputLatency; |
| assert(latency >= 0); |
| totalDelaySeconds += latency; |
| |
| // HW buffer duration |
| double ioBufferDuration = session.IOBufferDuration; |
| assert(ioBufferDuration >= 0); |
| totalDelaySeconds += ioBufferDuration; |
| |
| // AU latency |
| Float64 f64(0); |
| UInt32 size = sizeof(f64); |
| OSStatus result = |
| AudioUnitGetProperty(_auVoiceProcessing, kAudioUnitProperty_Latency, |
| kAudioUnitScope_Global, 0, &f64, &size); |
| if (0 != result) { |
| LOG_F(LS_ERROR) << "AU latency error: " << result; |
| } |
| assert(f64 >= 0); |
| totalDelaySeconds += f64; |
| |
| // To ms |
| _recordingDelayHWAndOS = static_cast<uint32_t>(totalDelaySeconds / 1000); |
| |
| // Reset counter |
| _recordingDelayMeasurementCounter = 0; |
| } |
| |
| _recordingDelay = _recordingDelayHWAndOS; |
| |
| // ADB recording buffer size, update every time |
| // Don't count the one next 10 ms to be sent, then convert samples => ms |
| const uint32_t noSamp10ms = _adbSampFreq / 100; |
| if (_recordingBufferTotalSize > noSamp10ms) { |
| _recordingDelay += |
| (_recordingBufferTotalSize - noSamp10ms) / (_adbSampFreq / 1000); |
| } |
| } |
| |
| bool AudioDeviceIOS::RunCapture(void* ptrThis) { |
| return static_cast<AudioDeviceIOS*>(ptrThis)->CaptureWorkerThread(); |
| } |
| |
| bool AudioDeviceIOS::CaptureWorkerThread() { |
| if (_recording) { |
| int bufPos = 0; |
| unsigned int lowestSeq = 0; |
| int lowestSeqBufPos = 0; |
| bool foundBuf = true; |
| const unsigned int noSamp10ms = _adbSampFreq / 100; |
| |
| while (foundBuf) { |
| // Check if we have any buffer with data to insert |
| // into the Audio Device Buffer, |
| // and find the one with the lowest seq number |
| foundBuf = false; |
| for (bufPos = 0; bufPos < N_REC_BUFFERS; ++bufPos) { |
| if (noSamp10ms == _recordingLength[bufPos]) { |
| if (!foundBuf) { |
| lowestSeq = _recordingSeqNumber[bufPos]; |
| lowestSeqBufPos = bufPos; |
| foundBuf = true; |
| } else if (_recordingSeqNumber[bufPos] < lowestSeq) { |
| lowestSeq = _recordingSeqNumber[bufPos]; |
| lowestSeqBufPos = bufPos; |
| } |
| } |
| } |
| |
| // Insert data into the Audio Device Buffer if found any |
| if (foundBuf) { |
| // Update recording delay |
| UpdateRecordingDelay(); |
| |
| // Set the recorded buffer |
| audio_device_buffer_->SetRecordedBuffer( |
| reinterpret_cast<int8_t*>(_recordingBuffer[lowestSeqBufPos]), |
| _recordingLength[lowestSeqBufPos]); |
| |
| // Don't need to set the current mic level in ADB since we only |
| // support digital AGC, |
| // and besides we cannot get or set the IOS mic level anyway. |
| |
| // Set VQE info, use clockdrift == 0 |
| audio_device_buffer_->SetVQEData(_playoutDelay, _recordingDelay, 0); |
| |
| // Deliver recorded samples at specified sample rate, mic level |
| // etc. to the observer using callback |
| audio_device_buffer_->DeliverRecordedData(); |
| |
| // Make buffer available |
| _recordingSeqNumber[lowestSeqBufPos] = 0; |
| _recordingBufferTotalSize -= _recordingLength[lowestSeqBufPos]; |
| // Must be done last to avoid interrupt problems between threads |
| _recordingLength[lowestSeqBufPos] = 0; |
| } |
| } |
| } |
| |
| { |
| // Normal case |
| // Sleep thread (5ms) to let other threads get to work |
| // todo: Is 5 ms optimal? Sleep shorter if inserted into the Audio |
| // Device Buffer? |
| timespec t; |
| t.tv_sec = 0; |
| t.tv_nsec = 5 * 1000 * 1000; |
| nanosleep(&t, nullptr); |
| } |
| return true; |
| } |
| |
| } // namespace webrtc |
