Fixes crash in media::AudioBlockFifo::Push for Apple Thundebolt Displays

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/basictypes.h"
 #include "base/logging.h"
@@ skipping 448 matching lines @@
       reinterpret_cast<AUAudioInputStream*>(user_data);
   DCHECK(audio_input);
   if (!audio_input)
     return kAudioUnitErr_InvalidElement;
 
   // Update the |mDataByteSize| value in the audio_buffer_list() since
   // |number_of_frames| can be changed on the fly.
   // |mDataByteSize| needs to be exactly mapping to |number_of_frames|,
   // otherwise it will put CoreAudio into bad state and results in
   // AudioUnitRender() returning -50 for the new created stream.
+  // We have also seen kAudioUnitErr_TooManyFramesToProcess (-10874) and
+  // kAudioUnitErr_CannotDoInCurrentContext (-10863) as error codes.
   // See crbug/428706 for details.
   UInt32 new_size = number_of_frames * audio_input->format_.mBytesPerFrame;
   AudioBuffer* audio_buffer = audio_input->audio_buffer_list()->mBuffers;
   if (new_size != audio_buffer->mDataByteSize) {
     if (new_size > audio_buffer->mDataByteSize) {
-      // This can happen iff the device is unpluged during recording. In such
-      // case the buffer will not be used anymore since |audio_unit_| becomes
-      // invalid. We allocate enough memory here to avoid depending on
-      // how CoreAudio handles it.
+      // This can happen if the device is unpluged during recording. We
+      // allocate enough memory here to avoid depending on how CoreAudio
+      // handles it.
+      // See See http://www.crbug.com/434681 for one example when we can enter
+      // this scope.
       audio_input->audio_data_buffer_.reset(new uint8[new_size]);
       audio_buffer->mData = audio_input->audio_data_buffer_.get();
     }
 
     // Update the |mDataByteSize| to match |number_of_frames|.
     audio_buffer->mDataByteSize = new_size;
   }
 
   // Receive audio from the AUHAL from the output scope of the Audio Unit.
   OSStatus result = AudioUnitRender(audio_input->audio_unit(),
                                     flags,
                                     time_stamp,
                                     bus_number,
                                     number_of_frames,
                                     audio_input->audio_buffer_list());
   if (result) {
     UMA_HISTOGRAM_SPARSE_SLOWLY("Media.AudioInputCbErrorMac", result);
-    OSSTATUS_DLOG(ERROR, result) << "AudioUnitRender() failed.";
+    OSSTATUS_DLOG(ERROR, result) << "AudioUnitRender() failed ";
     return result;
   }
 
   // Deliver recorded data to the consumer as a callback.
   return audio_input->Provide(number_of_frames,
                               audio_input->audio_buffer_list(),
                               time_stamp);
 }
 
 OSStatus AUAudioInputStream::Provide(UInt32 number_of_frames,
                                      AudioBufferList* io_data,
                                      const AudioTimeStamp* time_stamp) {
   // Update the capture latency.
   double capture_latency_frames = GetCaptureLatency(time_stamp);
 
   // The AGC volume level is updated once every second on a separate thread.
   // Note that, |volume| is also updated each time SetVolume() is called
   // through IPC by the render-side AGC.
   double normalized_volume = 0.0;
   GetAgcVolume(&normalized_volume);
 
   AudioBuffer& buffer = io_data->mBuffers[0];
   uint8* audio_data = reinterpret_cast<uint8*>(buffer.mData);
   uint32 capture_delay_bytes = static_cast<uint32>
       ((capture_latency_frames + 0.5) * format_.mBytesPerFrame);
   DCHECK(audio_data);
   if (!audio_data)
     return kAudioUnitErr_InvalidElement;
 
+  // Dynamically increase capacity of the FIFO to handle larger buffers from
+  // CoreAudio. This can happen in combination with Apple Thunderbolt Displays
+  // when the Display Audio is used as capture source and the cable is first
+  // remove and then inserted again.
+  // See http://www.crbug.com/434681 for details.
+  if (static_cast<int>(number_of_frames) > fifo_.GetUnfilledFrames()) {
+    // Derive required increase in number of FIFO blocks. The increase is
+    // typically one block.
+    const int blocks =
+        static_cast<int>((number_of_frames - fifo_.GetUnfilledFrames()) /
+                         number_of_frames_) + 1;
+    DLOG(WARNING) << "Increasing FIFO capacity by " << blocks << " blocks";
+    fifo_.IncreaseCapacity(blocks);
+  }
+
   // Copy captured (and interleaved) data into FIFO.
   fifo_.Push(audio_data, number_of_frames, format_.mBitsPerChannel / 8);
 
   // Consume and deliver the data when the FIFO has a block of available data.
   while (fifo_.available_blocks()) {
     const AudioBus* audio_bus = fifo_.Consume();
     DCHECK_EQ(audio_bus->frames(), static_cast<int>(number_of_frames_));
 
     // Compensate the audio delay caused by the FIFO.
     capture_delay_bytes += fifo_.GetAvailableFrames() * format_.mBytesPerFrame;
@@ skipping 132 matching lines @@
     kAudioDevicePropertyScopeInput,
     static_cast<UInt32>(channel)
   };
   OSStatus result = AudioObjectIsPropertySettable(input_device_id_,
                                                   &property_address,
                                                   &is_settable);
   return (result == noErr) ? is_settable : false;
 }
 
 }  // namespace media