Prevent AudioLowLatencyInputMac from changing frame sizes.

media/audio/mac/audio_low_latency_output_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_output_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 136 matching lines @@
       kAudioUnitProperty_StreamFormat,
       kAudioUnitScope_Input,
       0,
       &format_,
       sizeof(format_));
   OSSTATUS_DCHECK(result == noErr, result);
   if (result)
     return false;
 
   // Set the buffer frame size.
+  // WARNING: Setting this value changes the frame size for all audio units in
+  // the current process.  It's imperative that the input and output frame sizes
+  // be the same as audio_util::GetAudioHardwareBufferSize().
+  // TODO(henrika): Due to http://crrev.com/159666 this is currently not true
+  // and should be fixed, a CHECK() should be added at that time.
   UInt32 buffer_size = number_of_frames_;
   result = AudioUnitSetProperty(
       output_unit_,
       kAudioDevicePropertyBufferFrameSize,
       kAudioUnitScope_Output,
       0,
       &buffer_size,
       sizeof(buffer_size));
   OSSTATUS_DCHECK(result == noErr, result);
   if (result)
@@ skipping 60 matching lines @@
           switches::kDisableAudioOutputResampler);
 
   // Update the playout latency.
   double playout_latency_frames = GetPlayoutLatency(output_time_stamp);
 
   AudioBuffer& buffer = io_data->mBuffers[0];
   uint8* audio_data = reinterpret_cast<uint8*>(buffer.mData);
   uint32 hardware_pending_bytes = static_cast<uint32>
       ((playout_latency_frames + 0.5) * format_.mBytesPerFrame);
 
-  // If we specify a buffer size which is too low, the OS will ask for more data
-  // to fulfill the hardware request, so resize the AudioBus as appropriate.
-  // This change requires AudioOutputResampler to prevent buffer size mismatches
-  // downstream, so glitch if it's not enabled.
-  if (!kDisableAudioOutputResampler &&
-      static_cast<UInt32>(audio_bus_->frames()) != number_of_frames) {
-    audio_bus_ = AudioBus::Create(audio_bus_->channels(), number_of_frames);
-  }
-
+  // Unfortunately AUAudioInputStream and AUAudioOutputStream share the frame
+  // size set by kAudioDevicePropertyBufferFrameSize above on a per process
+  // process basis.  What this means is that the |number_of_frames| value may be
+  // larger or smaller than the value set during Configure().  The downstream
+  // audio pipeline does not support dynamic frame size changes, as such we must
+  // clip |frames_filled| as necessary, this will result in bad audio, but the
+  // alternative is a browser crash.
+  // TODO(henrika): This should never happen so long as we're always using the
+  // hardware sample rate and the input/output streams configure the same frame
+  // size.  This is currently not true.  See http://crbug.com/154352.  Once
+  // fixed, a CHECK() should be added and the clipping + wall of text removed.
   int frames_filled = std::min(source_->OnMoreData(
       audio_bus_.get(), AudioBuffersState(0, hardware_pending_bytes)),
       static_cast<int>(number_of_frames));
+
   // Note: If this ever changes to output raw float the data must be clipped and
   // sanitized since it may come from an untrusted source such as NaCl.
   audio_bus_->ToInterleaved(
       frames_filled, format_.mBitsPerChannel / 8, audio_data);

[Chris Rogers, 2012/10/08 21:29:57]

It looks like the ToInterleaved() call might write too much data to |audio_data|
if audio_bus_->frames()) != number_of_frames

[DaleCurtis, 2012/10/08 21:48:04]

It will only write frames_filled which is clipped above.

   uint32 filled = frames_filled * format_.mBytesPerFrame;
 
   // Handle channel order for 5.1 audio.
   // TODO(dalecurtis): Channel downmixing, upmixing, should be done in mixer;
   // volume adjust should use SSE optimized vector_fmul() prior to interleave.
   if (format_.mChannelsPerFrame == 6) {
     if (format_.mBitsPerChannel == 8) {
       SwizzleCoreAudioLayout5_1(reinterpret_cast<uint8*>(audio_data), filled);
     } else if (format_.mBitsPerChannel == 16) {
       SwizzleCoreAudioLayout5_1(reinterpret_cast<int16*>(audio_data), filled);
@@ skipping 108 matching lines @@
   UInt64 output_time_ns = AudioConvertHostTimeToNanos(
       output_time_stamp->mHostTime);
   UInt64 now_ns = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
   double delay_frames = static_cast<double>
       (1e-9 * (output_time_ns - now_ns) * format_.mSampleRate);
 
   return (delay_frames + hardware_latency_frames_);
 }
 
 }  // namespace media