/* * 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. */ #import #import #include "webrtc/modules/audio_device/ios/audio_device_ios.h" #include "webrtc/system_wrappers/interface/thread_wrapper.h" #include "webrtc/system_wrappers/interface/trace.h" namespace webrtc { AudioDeviceIOS::AudioDeviceIOS(const int32_t id) : _ptrAudioBuffer(NULL), _critSect(*CriticalSectionWrapper::CreateCriticalSection()), _captureWorkerThread(NULL), _captureWorkerThreadId(0), _id(id), _auVoiceProcessing(NULL), _audioInterruptionObserver(NULL), _initialized(false), _isShutDown(false), _recording(false), _playing(false), _recIsInitialized(false), _playIsInitialized(false), _recordingDeviceIsSpecified(false), _playoutDeviceIsSpecified(false), _micIsInitialized(false), _speakerIsInitialized(false), _AGC(false), _adbSampFreq(0), _recordingDelay(0), _playoutDelay(0), _playoutDelayMeasurementCounter(9999), _recordingDelayHWAndOS(0), _recordingDelayMeasurementCounter(9999), _playWarning(0), _playError(0), _recWarning(0), _recError(0), _playoutBufferUsed(0), _recordingCurrentSeq(0), _recordingBufferTotalSize(0) { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, "%s created", __FUNCTION__); memset(_playoutBuffer, 0, sizeof(_playoutBuffer)); memset(_recordingBuffer, 0, sizeof(_recordingBuffer)); memset(_recordingLength, 0, sizeof(_recordingLength)); memset(_recordingSeqNumber, 0, sizeof(_recordingSeqNumber)); } AudioDeviceIOS::~AudioDeviceIOS() { WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s destroyed", __FUNCTION__); Terminate(); delete &_critSect; } // ============================================================================ // API // ============================================================================ void AudioDeviceIOS::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); _ptrAudioBuffer = audioBuffer; // inform the AudioBuffer about default settings for this implementation _ptrAudioBuffer->SetRecordingSampleRate(ENGINE_REC_BUF_SIZE_IN_SAMPLES); _ptrAudioBuffer->SetPlayoutSampleRate(ENGINE_PLAY_BUF_SIZE_IN_SAMPLES); _ptrAudioBuffer->SetRecordingChannels(N_REC_CHANNELS); _ptrAudioBuffer->SetPlayoutChannels(N_PLAY_CHANNELS); } int32_t AudioDeviceIOS::ActiveAudioLayer( AudioDeviceModule::AudioLayer& audioLayer) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); audioLayer = AudioDeviceModule::kPlatformDefaultAudio; return 0; } int32_t AudioDeviceIOS::Init() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); if (_initialized) { return 0; } _isShutDown = false; // Create and start capture thread if (_captureWorkerThread == NULL) { _captureWorkerThread = ThreadWrapper::CreateThread(RunCapture, this, kRealtimePriority, "CaptureWorkerThread"); if (_captureWorkerThread == NULL) { WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, "CreateThread() error"); return -1; } unsigned int threadID(0); bool res = _captureWorkerThread->Start(threadID); _captureWorkerThreadId = static_cast(threadID); WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "CaptureWorkerThread started (res=%d)", res); } else { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "Thread already created"); } _playWarning = 0; _playError = 0; _recWarning = 0; _recError = 0; _initialized = true; return 0; } int32_t AudioDeviceIOS::Terminate() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); if (!_initialized) { return 0; } // Stop capture thread if (_captureWorkerThread != NULL) { WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "Stopping CaptureWorkerThread"); bool res = _captureWorkerThread->Stop(); WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "CaptureWorkerThread stopped (res=%d)", res); delete _captureWorkerThread; _captureWorkerThread = NULL; } // Shut down Audio Unit ShutdownPlayOrRecord(); _isShutDown = true; _initialized = false; _speakerIsInitialized = false; _micIsInitialized = false; _playoutDeviceIsSpecified = false; _recordingDeviceIsSpecified = false; return 0; } bool AudioDeviceIOS::Initialized() const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); return (_initialized); } int32_t AudioDeviceIOS::InitSpeaker() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); if (!_initialized) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Not initialized"); return -1; } if (_playing) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Cannot init speaker when playing"); return -1; } if (!_playoutDeviceIsSpecified) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Playout device is not specified"); return -1; } // Do nothing _speakerIsInitialized = true; return 0; } int32_t AudioDeviceIOS::InitMicrophone() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); if (!_initialized) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Not initialized"); return -1; } if (_recording) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Cannot init mic when recording"); return -1; } if (!_recordingDeviceIsSpecified) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Recording device is not specified"); return -1; } // Do nothing _micIsInitialized = true; return 0; } bool AudioDeviceIOS::SpeakerIsInitialized() const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); return _speakerIsInitialized; } bool AudioDeviceIOS::MicrophoneIsInitialized() const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); return _micIsInitialized; } int32_t AudioDeviceIOS::SpeakerVolumeIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); available = false; // Speaker volume not supported on iOS return 0; } int32_t AudioDeviceIOS::SetSpeakerVolume(uint32_t volume) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::SetSpeakerVolume(volume=%u)", volume); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::SpeakerVolume(uint32_t& volume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight) { WEBRTC_TRACE( kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::SetWaveOutVolume(volumeLeft=%u, volumeRight=%u)", volumeLeft, volumeRight); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::WaveOutVolume(uint16_t& /*volumeLeft*/, uint16_t& /*volumeRight*/) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::MaxSpeakerVolume(uint32_t& maxVolume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::MinSpeakerVolume( uint32_t& minVolume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::SpeakerVolumeStepSize(uint16_t& stepSize) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::SpeakerMuteIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); available = false; // Speaker mute not supported on iOS return 0; } int32_t AudioDeviceIOS::SetSpeakerMute(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::SpeakerMute(bool& enabled) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::MicrophoneMuteIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); available = false; // Mic mute not supported on iOS return 0; } int32_t AudioDeviceIOS::SetMicrophoneMute(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::MicrophoneMute(bool& enabled) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::MicrophoneBoostIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); available = false; // Mic boost not supported on iOS return 0; } int32_t AudioDeviceIOS::SetMicrophoneBoost(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::SetMicrophoneBoost(enable=%u)", enable); if (!_micIsInitialized) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Microphone not initialized"); return -1; } if (enable) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " SetMicrophoneBoost cannot be enabled on this platform"); return -1; } return 0; } int32_t AudioDeviceIOS::MicrophoneBoost(bool& enabled) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); if (!_micIsInitialized) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Microphone not initialized"); return -1; } enabled = false; return 0; } int32_t AudioDeviceIOS::StereoRecordingIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); available = false; // Stereo recording not supported on iOS return 0; } int32_t AudioDeviceIOS::SetStereoRecording(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::SetStereoRecording(enable=%u)", enable); if (enable) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Stereo recording is not supported on this platform"); return -1; } return 0; } int32_t AudioDeviceIOS::StereoRecording(bool& enabled) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); enabled = false; return 0; } int32_t AudioDeviceIOS::StereoPlayoutIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); available = false; // Stereo playout not supported on iOS return 0; } int32_t AudioDeviceIOS::SetStereoPlayout(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::SetStereoPlayout(enable=%u)", enable); if (enable) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Stereo playout is not supported on this platform"); return -1; } return 0; } int32_t AudioDeviceIOS::StereoPlayout(bool& enabled) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); enabled = false; return 0; } int32_t AudioDeviceIOS::SetAGC(bool enable) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::SetAGC(enable=%d)", enable); _AGC = enable; return 0; } bool AudioDeviceIOS::AGC() const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); return _AGC; } int32_t AudioDeviceIOS::MicrophoneVolumeIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); available = false; // Mic volume not supported on IOS return 0; } int32_t AudioDeviceIOS::SetMicrophoneVolume(uint32_t volume) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::SetMicrophoneVolume(volume=%u)", volume); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::MicrophoneVolume(uint32_t& volume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::MaxMicrophoneVolume(uint32_t& maxVolume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::MinMicrophoneVolume(uint32_t& minVolume) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::MicrophoneVolumeStepSize( uint16_t& stepSize) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int16_t AudioDeviceIOS::PlayoutDevices() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); return (int16_t)1; } int32_t AudioDeviceIOS::SetPlayoutDevice(uint16_t index) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::SetPlayoutDevice(index=%u)", index); if (_playIsInitialized) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Playout already initialized"); return -1; } if (index !=0) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " SetPlayoutDevice invalid index"); return -1; } _playoutDeviceIsSpecified = true; return 0; } int32_t AudioDeviceIOS::SetPlayoutDevice(AudioDeviceModule::WindowsDeviceType) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "WindowsDeviceType not supported"); return -1; } int32_t AudioDeviceIOS::PlayoutDeviceName(uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::PlayoutDeviceName(index=%u)", index); if (index != 0) { return -1; } // return empty strings memset(name, 0, kAdmMaxDeviceNameSize); if (guid != NULL) { memset(guid, 0, kAdmMaxGuidSize); } return 0; } int32_t AudioDeviceIOS::RecordingDeviceName(uint16_t index, char name[kAdmMaxDeviceNameSize], char guid[kAdmMaxGuidSize]) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::RecordingDeviceName(index=%u)", index); if (index != 0) { return -1; } // return empty strings memset(name, 0, kAdmMaxDeviceNameSize); if (guid != NULL) { memset(guid, 0, kAdmMaxGuidSize); } return 0; } int16_t AudioDeviceIOS::RecordingDevices() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); return (int16_t)1; } int32_t AudioDeviceIOS::SetRecordingDevice(uint16_t index) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::SetRecordingDevice(index=%u)", index); if (_recIsInitialized) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Recording already initialized"); return -1; } if (index !=0) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " SetRecordingDevice invalid index"); return -1; } _recordingDeviceIsSpecified = true; return 0; } int32_t AudioDeviceIOS::SetRecordingDevice( AudioDeviceModule::WindowsDeviceType) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WindowsDeviceType not supported"); return -1; } // ---------------------------------------------------------------------------- // SetLoudspeakerStatus // // Change the default receiver playout route to speaker. // // ---------------------------------------------------------------------------- int32_t AudioDeviceIOS::SetLoudspeakerStatus(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioDeviceIOS::SetLoudspeakerStatus(enable=%d)", 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; [session setCategory:AVAudioSessionCategoryPlayAndRecord withOptions:options error:&error]; if (error != nil) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "Error changing default output route "); return -1; } return 0; } int32_t AudioDeviceIOS::GetLoudspeakerStatus(bool &enabled) const { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioDeviceIOS::SetLoudspeakerStatus(enabled=?)"); AVAudioSession* session = [AVAudioSession sharedInstance]; AVAudioSessionCategoryOptions options = session.categoryOptions; enabled = options & AVAudioSessionCategoryOptionDefaultToSpeaker; return 0; } int32_t AudioDeviceIOS::PlayoutIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); available = false; // Try to initialize the playout side int32_t res = InitPlayout(); // Cancel effect of initialization StopPlayout(); if (res != -1) { available = true; } return 0; } int32_t AudioDeviceIOS::RecordingIsAvailable(bool& available) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); available = false; // Try to initialize the recording side int32_t res = InitRecording(); // Cancel effect of initialization StopRecording(); if (res != -1) { available = true; } return 0; } int32_t AudioDeviceIOS::InitPlayout() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); if (!_initialized) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Not initialized"); return -1; } if (_playing) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Playout already started"); return -1; } if (_playIsInitialized) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Playout already initialized"); return 0; } if (!_playoutDeviceIsSpecified) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Playout device is not specified"); return -1; } // Initialize the speaker if (InitSpeaker() == -1) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " InitSpeaker() failed"); } _playIsInitialized = true; if (!_recIsInitialized) { // Audio init if (InitPlayOrRecord() == -1) { // todo: Handle error WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " InitPlayOrRecord() failed"); } } else { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Recording already initialized - InitPlayOrRecord() not called"); } return 0; } bool AudioDeviceIOS::PlayoutIsInitialized() const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); return (_playIsInitialized); } int32_t AudioDeviceIOS::InitRecording() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); if (!_initialized) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Not initialized"); return -1; } if (_recording) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Recording already started"); return -1; } if (_recIsInitialized) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Recording already initialized"); return 0; } if (!_recordingDeviceIsSpecified) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Recording device is not specified"); return -1; } // Initialize the microphone if (InitMicrophone() == -1) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " InitMicrophone() failed"); } _recIsInitialized = true; if (!_playIsInitialized) { // Audio init if (InitPlayOrRecord() == -1) { // todo: Handle error WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " InitPlayOrRecord() failed"); } } else { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Playout already initialized - InitPlayOrRecord() " \ "not called"); } return 0; } bool AudioDeviceIOS::RecordingIsInitialized() const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); return (_recIsInitialized); } int32_t AudioDeviceIOS::StartRecording() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); if (!_recIsInitialized) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Recording not initialized"); return -1; } if (_recording) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Recording already started"); return 0; } // Reset recording buffer 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; _recWarning = 0; _recError = 0; if (!_playing) { // Start Audio Unit WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, " Starting Audio Unit"); OSStatus result = AudioOutputUnitStart(_auVoiceProcessing); if (0 != result) { WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, " Error starting Audio Unit (result=%d)", result); return -1; } } _recording = true; return 0; } int32_t AudioDeviceIOS::StopRecording() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); if (!_recIsInitialized) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Recording is not initialized"); return 0; } _recording = false; if (!_playing) { // Both playout and recording has stopped, shutdown the device ShutdownPlayOrRecord(); } _recIsInitialized = false; _micIsInitialized = false; return 0; } bool AudioDeviceIOS::Recording() const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); return (_recording); } int32_t AudioDeviceIOS::StartPlayout() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); // This lock is (among other things) needed to avoid concurrency issues // with capture thread // shutting down Audio Unit CriticalSectionScoped lock(&_critSect); if (!_playIsInitialized) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Playout not initialized"); return -1; } if (_playing) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Playing already started"); return 0; } // Reset playout buffer memset(_playoutBuffer, 0, sizeof(_playoutBuffer)); _playoutBufferUsed = 0; _playoutDelay = 0; // Make sure first call to update delay function will update delay _playoutDelayMeasurementCounter = 9999; _playWarning = 0; _playError = 0; if (!_recording) { // Start Audio Unit WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, " Starting Audio Unit"); OSStatus result = AudioOutputUnitStart(_auVoiceProcessing); if (0 != result) { WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id, " Error starting Audio Unit (result=%d)", result); return -1; } } _playing = true; return 0; } int32_t AudioDeviceIOS::StopPlayout() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); if (!_playIsInitialized) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Playout is not initialized"); return 0; } _playing = false; if (!_recording) { // Both playout and recording has stopped, signal shutdown the device ShutdownPlayOrRecord(); } _playIsInitialized = false; _speakerIsInitialized = false; return 0; } bool AudioDeviceIOS::Playing() const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); return (_playing); } // ---------------------------------------------------------------------------- // ResetAudioDevice // // Disable playout and recording, signal to capture thread to shutdown, // and set enable states after shutdown to same as current. // In capture thread audio device will be shutdown, then started again. // ---------------------------------------------------------------------------- int32_t AudioDeviceIOS::ResetAudioDevice() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); CriticalSectionScoped lock(&_critSect); if (!_playIsInitialized && !_recIsInitialized) { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Playout or recording not initialized, doing nothing"); return 0; // Nothing to reset } // Store the states we have before stopping to restart below bool initPlay = _playIsInitialized; bool play = _playing; bool initRec = _recIsInitialized; bool rec = _recording; int res(0); // Stop playout and recording WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, " Stopping playout and recording"); res += StopPlayout(); res += StopRecording(); // Restart WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, " Restarting playout and recording (%d, %d, %d, %d)", initPlay, play, initRec, rec); if (initPlay) res += InitPlayout(); if (initRec) res += InitRecording(); if (play) res += StartPlayout(); if (rec) res += StartRecording(); if (0 != res) { // Logging is done in init/start/stop calls above return -1; } 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::SetPlayoutBuffer(const AudioDeviceModule::BufferType type, uint16_t sizeMS) { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "AudioDeviceIOS::SetPlayoutBuffer(type=%u, sizeMS=%u)", type, sizeMS); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } int32_t AudioDeviceIOS::PlayoutBuffer(AudioDeviceModule::BufferType& type, uint16_t& sizeMS) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); type = AudioDeviceModule::kAdaptiveBufferSize; sizeMS = _playoutDelay; return 0; } int32_t AudioDeviceIOS::CPULoad(uint16_t& /*load*/) const { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " API call not supported on this platform"); return -1; } bool AudioDeviceIOS::PlayoutWarning() const { return (_playWarning > 0); } bool AudioDeviceIOS::PlayoutError() const { return (_playError > 0); } bool AudioDeviceIOS::RecordingWarning() const { return (_recWarning > 0); } bool AudioDeviceIOS::RecordingError() const { return (_recError > 0); } void AudioDeviceIOS::ClearPlayoutWarning() { _playWarning = 0; } void AudioDeviceIOS::ClearPlayoutError() { _playError = 0; } void AudioDeviceIOS::ClearRecordingWarning() { _recWarning = 0; } void AudioDeviceIOS::ClearRecordingError() { _recError = 0; } // ============================================================================ // Private Methods // ============================================================================ int32_t AudioDeviceIOS::InitPlayOrRecord() { WEBRTC_TRACE(kTraceModuleCall, kTraceAudioDevice, _id, "%s", __FUNCTION__); OSStatus result = -1; // Check if already initialized if (NULL != _auVoiceProcessing) { // We already have initialized before and created any of the audio unit, // check that all exist WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Already initialized"); // todo: Call AudioUnitReset() here and empty all buffers? return 0; } // 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(NULL, &desc); if (NULL == comp) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not find audio component for Audio Unit"); return -1; } result = AudioComponentInstanceNew(comp, &_auVoiceProcessing); if (0 != result) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not create Audio Unit instance (result=%d)", result); return -1; } // Set preferred hardware sample rate to 16 kHz NSError* error = nil; AVAudioSession* session = [AVAudioSession sharedInstance]; Float64 preferredSampleRate(16000.0); [session setPreferredSampleRate:preferredSampleRate error:&error]; if (error != nil) { const char* errorString = [[error localizedDescription] UTF8String]; WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Could not set preferred sample rate: %s", errorString); } error = nil; [session setMode:AVAudioSessionModeVoiceChat error:&error]; if (error != nil) { const char* errorString = [[error localizedDescription] UTF8String]; WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Could not set mode: %s", errorString); } error = nil; [session setCategory:AVAudioSessionCategoryPlayAndRecord error:&error]; if (error != nil) { const char* errorString = [[error localizedDescription] UTF8String]; WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Could not set category: %s", errorString); } ////////////////////// // Setup Voice Processing Audio Unit // Note: For Signal Processing AU element 0 is output bus, element 1 is // input bus for global scope element is irrelevant (always use // element 0) // Enable IO on both elements // todo: Below we just log and continue upon error. We might want // to close AU and return error for some cases. // todo: Log info about setup. UInt32 enableIO = 1; result = AudioUnitSetProperty(_auVoiceProcessing, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, // input bus &enableIO, sizeof(enableIO)); if (0 != result) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not enable IO on input (result=%d)", result); } result = AudioUnitSetProperty(_auVoiceProcessing, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, // output bus &enableIO, sizeof(enableIO)); if (0 != result) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not enable IO on output (result=%d)", result); } // Disable AU buffer allocation for the recorder, we allocate our own UInt32 flag = 0; result = AudioUnitSetProperty( _auVoiceProcessing, kAudioUnitProperty_ShouldAllocateBuffer, kAudioUnitScope_Output, 1, &flag, sizeof(flag)); if (0 != result) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Could not disable AU buffer allocation (result=%d)", 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) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not set record callback for Audio Unit (result=%d)", 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) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not set play callback for Audio Unit (result=%d)", 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) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not get stream format Audio Unit out/0 (result=%d)", result); } WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Audio Unit playout opened in sampling rate %f", playoutDesc.mSampleRate); playoutDesc.mSampleRate = preferredSampleRate; // Store the sampling frequency to use towards the Audio Device Buffer // todo: Add 48 kHz (increase buffer sizes). Other fs? 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; WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Audio Unit out/0 opened in unknown sampling rate (%f)", playoutDesc.mSampleRate); // todo: We should bail out here. } // Set the audio device buffer sampling rate, // we assume we get the same for play and record if (_ptrAudioBuffer->SetRecordingSampleRate(_adbSampFreq) < 0) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not set audio device buffer recording sampling rate (%d)", _adbSampFreq); } if (_ptrAudioBuffer->SetPlayoutSampleRate(_adbSampFreq) < 0) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not set audio device buffer playout sampling rate (%d)", _adbSampFreq); } // Set stream format for in/0 (use same sampling frequency as 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) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not set stream format Audio Unit in/0 (result=%d)", result); } // Get stream format for in/1 AudioStreamBasicDescription recordingDesc; size = sizeof(recordingDesc); result = AudioUnitGetProperty(_auVoiceProcessing, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 1, &recordingDesc, &size); if (0 != result) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not get stream format Audio Unit in/1 (result=%d)", result); } WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Audio Unit recording opened in sampling rate %f", recordingDesc.mSampleRate); recordingDesc.mSampleRate = preferredSampleRate; // 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) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not set stream format Audio Unit out/1 (result=%d)", result); } // Initialize here already to be able to get/set stream properties. result = AudioUnitInitialize(_auVoiceProcessing); if (0 != result) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, " Could not init Audio Unit (result=%d)", result); } // Get hardware sample rate for logging (see if we get what we asked for) double sampleRate = session.sampleRate; WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, " Current HW sample rate is %f, ADB sample rate is %d", sampleRate, _adbSampFreq); // Listen to audio interruptions. 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) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "Error activating 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; // Activate audio session. error = nil; [session setActive:YES error:&error]; if (error != nil) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "Error activating audio session"); } return 0; } int32_t AudioDeviceIOS::ShutdownPlayOrRecord() { WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__); if (_audioInterruptionObserver != NULL) { 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 = NULL; } // Close and delete AU OSStatus result = -1; if (NULL != _auVoiceProcessing) { result = AudioOutputUnitStop(_auVoiceProcessing); if (0 != result) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Error stopping Audio Unit (result=%d)", result); } result = AudioComponentInstanceDispose(_auVoiceProcessing); if (0 != result) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Error disposing Audio Unit (result=%d)", result); } _auVoiceProcessing = NULL; } return 0; } // ============================================================================ // Thread Methods // ============================================================================ OSStatus AudioDeviceIOS::RecordProcess(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData) { AudioDeviceIOS* ptrThis = static_cast(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) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Error getting rec data, error = %d", res); if (_recWarning > 0) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Pending rec warning exists"); } _recWarning = 1; 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(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(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 WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Could not insert into recording buffer"); if (_recWarning > 0) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Pending rec warning exists"); } _recWarning = 1; 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(inRefCon); return ptrThis->PlayoutProcessImpl(inNumberFrames, ioData); } OSStatus AudioDeviceIOS::PlayoutProcessImpl(uint32_t inNumberFrames, AudioBufferList *ioData) { // Setup some basic stuff // assert(sizeof(short) == 2); // Assumption for implementation int16_t* data = static_cast(ioData->mBuffers[0].mData); unsigned int dataSizeBytes = ioData->mBuffers[0].mDataByteSize; unsigned int dataSize = dataSizeBytes/2; // Number of samples if (dataSize != inNumberFrames) { // Should always be the same WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "dataSize (%u) != inNumberFrames (%u)", dataSize, (unsigned int)inNumberFrames); if (_playWarning > 0) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Pending play warning exists"); } _playWarning = 1; } 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; if (nCopy != _playoutBufferUsed) { // todo: If dataSize < _playoutBufferUsed // (should normally never be) // we must move the remaining data WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "nCopy (%u) != _playoutBufferUsed (%u)", nCopy, _playoutBufferUsed); if (_playWarning > 0) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Pending play warning exists"); } _playWarning = 1; } 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 = _ptrAudioBuffer->RequestPlayoutData(noSamp10ms); // Get data from Audio Device Buffer noSamplesOut = _ptrAudioBuffer->GetPlayoutData( reinterpret_cast(dataTmp)); // Cast OK since only equality comparison if (noSamp10ms != (unsigned int)noSamplesOut) { // Should never happen WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "noSamp10ms (%u) != noSamplesOut (%d)", noSamp10ms, noSamplesOut); if (_playWarning > 0) { WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, " Pending play warning exists"); } _playWarning = 1; } // 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; } 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) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "error AU latency (result=%d)", result); } assert(f64 >= 0); totalDelaySeconds += f64; // To ms _playoutDelay = static_cast(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) { WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "error AU latency (result=%d)", result); } assert(f64 >= 0); totalDelaySeconds += f64; // To ms _recordingDelayHWAndOS = static_cast(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(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; } } } // for // Insert data into the Audio Device Buffer if found any if (foundBuf) { // Update recording delay UpdateRecordingDelay(); // Set the recorded buffer _ptrAudioBuffer->SetRecordedBuffer( reinterpret_cast( _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 _ptrAudioBuffer->SetVQEData(_playoutDelay, _recordingDelay, 0); // Deliver recorded samples at specified sample rate, mic level // etc. to the observer using callback _ptrAudioBuffer->DeliverRecordedData(); // Make buffer available _recordingSeqNumber[lowestSeqBufPos] = 0; _recordingBufferTotalSize -= _recordingLength[lowestSeqBufPos]; // Must be done last to avoid interrupt problems between threads _recordingLength[lowestSeqBufPos] = 0; } } // while (foundBuf) } // if (_recording) { // 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, NULL); } return true; } } // namespace webrtc