Initialize input AUHAL before using it

media/audio/mac/audio_low_latency_input_mac.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/mac/audio_low_latency_input_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
@@ skipping 61 matching lines @@
   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
                          kLinearPCMFormatFlagIsSignedInteger;
   format_.mBitsPerChannel = input_params.bits_per_sample();
   format_.mChannelsPerFrame = input_params.channels();
   format_.mFramesPerPacket = 1;  // uncompressed audio
   format_.mBytesPerPacket = (format_.mBitsPerChannel *
                              input_params.channels()) / 8;
   format_.mBytesPerFrame = format_.mBytesPerPacket;
   format_.mReserved = 0;
 
-  DVLOG(1) << "Desired ouput format: " << format_;
+  DVLOG(1) << "Desired output (client side) format: " << format_;
 
   // Derive size (in bytes) of the buffers that we will render to.
   UInt32 data_byte_size = number_of_frames_ * format_.mBytesPerFrame;
   DVLOG(1) << "Size of data buffer in bytes : " << data_byte_size;
 
   // Allocate AudioBuffers to be used as storage for the received audio.
   // The AudioBufferList structure works as a placeholder for the
   // AudioBuffer structure, which holds a pointer to the actual data buffer.
   audio_data_buffer_.reset(new uint8_t[data_byte_size]);
   audio_buffer_list_.mNumberBuffers = 1;
@@ skipping 34 matching lines @@
     result = kAudioUnitErr_FormatNotSupported;
     HandleError(result);
     return false;
   }
   DLOG_IF(WARNING, buffer_size_was_changed_) << "IO buffer size was changed to "
                                              << number_of_frames_;
 
   // Obtain an AudioOuputUnit using an AUHAL component description.
 
   // Description for the Audio Unit we want to use (AUHAL in this case).
+  // The kAudioUnitSubType_HALOutput audio unit interfaces to any audio device.
+  // The user specifies which  audio device to track. The audio unit can do

[tommi (sloooow) - chröme, 2015/12/28 18:49:50]

Nit:spacing

[henrika (OOO until Aug 14), 2015/12/29 09:32:25]

My bad; hope it is OK if I skip uploading a fix for it now but instead include
it in my next attempt to fix things in this area.

+  // input from the device as well as output to the device. Bus 0 is used for
+  // the output side, bus 1 is used to get audio input from the device.
   AudioComponentDescription desc = {
       kAudioUnitType_Output,
       kAudioUnitSubType_HALOutput,
       kAudioUnitManufacturer_Apple,
       0,
       0
   };
 
-  AudioComponent comp = AudioComponentFindNext(0, &desc);
+  AudioComponent comp = AudioComponentFindNext(NULL, &desc);
   DCHECK(comp);
 
   // Get access to the service provided by the specified Audio Unit.
   result = AudioComponentInstanceNew(comp, &audio_unit_);
   if (result) {
     HandleError(result);
     return false;
   }
 
+  // Initialize the AUHAL before making any changes or using it.
+  result = AudioUnitInitialize(audio_unit_);
+  if (result != noErr) {
+    HandleError(result);
+    return false;
+  }
+
   // Enable IO on the input scope of the Audio Unit.
 
   // After creating the AUHAL object, we must enable IO on the input scope
   // of the Audio Unit to obtain the device input. Input must be explicitly
   // enabled with the kAudioOutputUnitProperty_EnableIO property on Element 1
   // of the AUHAL. Beacause the AUHAL can be used for both input and output,
   // we must also disable IO on the output scope.
 
   UInt32 enableIO = 1;
 
@@ skipping 63 matching lines @@
                                 sizeof(callback));
   if (result != noErr) {
     HandleError(result);
     return false;
   }
 
   // Finally, initialize the audio unit and ensure that it is ready to render.
   // Allocates memory according to the maximum number of audio frames
   // it can produce in response to a single render call.
   result = AudioUnitInitialize(audio_unit_);
   if (result != noErr) {

[tommi (sloooow) - chröme, 2015/12/28 18:49:50]

Remove this call then?  Can it fail now that initialize has already been called?

[henrika (OOO until Aug 14), 2015/12/29 09:32:25]

No, that is the trick actually, to do it twice (and it does not fail the second
time). The first call is (I guess) more done as some sort of
reset-before-making-any-changes, or "flush" operation. I have seen it in a
widely spread (and maintained) Apple example and the exact comment is "AUHAL
needs to be initialized before anything is done to it". I can't find a
verification in any official API doc that it *needs* to be pre-initialized but
the fact that they say *needs* shows that it is worth a try. Hope you agree. 

     HandleError(result);
     return false;
   }
 
   // The hardware latency is fixed and will not change during the call.
   hardware_latency_frames_ = GetHardwareLatency();
 
   // The master channel is 0, Left and right are channels 1 and 2.
   // And the master channel is not counted in |number_of_channels_in_frame_|.
   number_of_channels_in_frame_ = GetNumberOfChannelsFromStream();
@@ skipping 555 matching lines @@
                             manager_->output_streams());
   UMA_HISTOGRAM_COUNTS_1000("Media.Audio.NumberOfLowLatencyInputStreamsMac",
                             manager_->low_latency_input_streams());
   UMA_HISTOGRAM_COUNTS_1000("Media.Audio.NumberOfBasicInputStreamsMac",
                             manager_->basic_input_streams());
   UMA_HISTOGRAM_BOOLEAN("Media.Audio.AutomaticGainControlMac",
                         GetAutomaticGainControl());
 }
 
 }  // namespace media