Support delayed AudioUnit initialization.

webrtc/modules/audio_device/ios/voice_processing_audio_unit.mm

 /*
  *  Copyright 2016 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.
  */
 
@@ skipping 38 matching lines @@
 // with as small delay between each. This factor sets the max number of allowed
 // initialization attempts.
 static const int kMaxNumberOfAudioUnitInitializeAttempts = 5;
 // A VP I/O unit's bus 1 connects to input hardware (microphone).
 static const AudioUnitElement kInputBus = 1;
 // A VP I/O unit's bus 0 connects to output hardware (speaker).
 static const AudioUnitElement kOutputBus = 0;
 
 VoiceProcessingAudioUnit::VoiceProcessingAudioUnit(
     VoiceProcessingAudioUnitObserver* observer)
-    : observer_(observer), vpio_unit_(nullptr) {
+    : observer_(observer), vpio_unit_(nullptr), state_(kInitRequired) {
   RTC_DCHECK(observer);
 }
 
 VoiceProcessingAudioUnit::~VoiceProcessingAudioUnit() {
   DisposeAudioUnit();
 }
 
 const UInt32 VoiceProcessingAudioUnit::kBytesPerSample = 2;
 
 bool VoiceProcessingAudioUnit::Init() {
-  RTC_DCHECK(!vpio_unit_) << "Already called Init().";
+  RTC_DCHECK_EQ(state_, kInitRequired);
 
   // Create an audio component description to identify the Voice Processing
   // I/O audio unit.
   AudioComponentDescription vpio_unit_description;
   vpio_unit_description.componentType = kAudioUnitType_Output;
   vpio_unit_description.componentSubType = kAudioUnitSubType_VoiceProcessingIO;
   vpio_unit_description.componentManufacturer = kAudioUnitManufacturer_Apple;
   vpio_unit_description.componentFlags = 0;
   vpio_unit_description.componentFlagsMask = 0;
 
@@ skipping 77 matching lines @@
                                 kAudioUnitScope_Global, kInputBus,
                                 &input_callback, sizeof(input_callback));
   if (result != noErr) {
     DisposeAudioUnit();
     RTCLogError(@"Failed to specify the input callback on the input bus. "
                  "Error=%ld.",
                 (long)result);
     return false;
   }
 
+  state_ = kUninitialized;
   return true;
 }
 
+VoiceProcessingAudioUnit::State VoiceProcessingAudioUnit::GetState() const {
+  return state_;
+}
+
 bool VoiceProcessingAudioUnit::Initialize(Float64 sample_rate) {
-  RTC_DCHECK(vpio_unit_) << "Init() not called.";
+  RTC_DCHECK_GE(state_, kUninitialized);
   RTCLog(@"Initializing audio unit.");
 
   OSStatus result = noErr;
   AudioStreamBasicDescription format = GetFormat(sample_rate);
   UInt32 size = sizeof(format);
 #if !defined(NDEBUG)
   LogStreamDescription(format);
 #endif
 
   // Set the format on the output scope of the input element/bus.
@@ skipping 34 matching lines @@
     if (failed_initalize_attempts == kMaxNumberOfAudioUnitInitializeAttempts) {
       // Max number of initialization attempts exceeded, hence abort.
       RTCLogError(@"Too many initialization attempts.");
       return false;
     }
     RTCLog(@"Pause 100ms and try audio unit initialization again...");
     [NSThread sleepForTimeInterval:0.1f];
     result = AudioUnitInitialize(vpio_unit_);
   }
   RTCLog(@"Voice Processing I/O unit is now initialized.");
+  state_ = kInitialized;
   return true;
 }
 
 bool VoiceProcessingAudioUnit::Start() {
-  RTC_DCHECK(vpio_unit_) << "Init() not called.";
+  RTC_DCHECK_GE(state_, kUninitialized);
   RTCLog(@"Starting audio unit.");
 
   OSStatus result = AudioOutputUnitStart(vpio_unit_);
   if (result != noErr) {
     RTCLogError(@"Failed to start audio unit. Error=%ld", (long)result);
     return false;
   }
+  state_ = kStarted;
   return true;
 }
 
 bool VoiceProcessingAudioUnit::Stop() {
-  RTC_DCHECK(vpio_unit_) << "Init() not called.";
+  RTC_DCHECK_GE(state_, kUninitialized);
   RTCLog(@"Stopping audio unit.");
 
   OSStatus result = AudioOutputUnitStop(vpio_unit_);
   if (result != noErr) {
     RTCLogError(@"Failed to stop audio unit. Error=%ld", (long)result);
     return false;
   }
+  state_ = kInitialized;
   return true;
 }
 
 bool VoiceProcessingAudioUnit::Uninitialize() {
-  RTC_DCHECK(vpio_unit_) << "Init() not called.";
+  RTC_DCHECK_GE(state_, kUninitialized);
   RTCLog(@"Unintializing audio unit.");
 
   OSStatus result = AudioUnitUninitialize(vpio_unit_);
   if (result != noErr) {
     RTCLogError(@"Failed to uninitialize audio unit. Error=%ld", (long)result);
     return false;
   }
   return true;
 }
 
@@ skipping 74 matching lines @@
   format.mBytesPerPacket = kBytesPerSample;
   format.mFramesPerPacket = 1;  // uncompressed.
   format.mBytesPerFrame = kBytesPerSample;
   format.mChannelsPerFrame = kRTCAudioSessionPreferredNumberOfChannels;
   format.mBitsPerChannel = 8 * kBytesPerSample;
   return format;
 }
 
 void VoiceProcessingAudioUnit::DisposeAudioUnit() {
   if (vpio_unit_) {
+    switch (state_) {
+      case kStarted:
+        Stop();
+        // Fall through.
+      case kInitialized:
+        Uninitialize();
+        break;
+      case kUninitialized:
+      case kInitRequired:
+        break;
+    }
+
     OSStatus result = AudioComponentInstanceDispose(vpio_unit_);
     if (result != noErr) {
       RTCLogError(@"AudioComponentInstanceDispose failed. Error=%ld.",
                   (long)result);
     }
     vpio_unit_ = nullptr;
   }
 }
 
 }  // namespace webrtc