Switch the input code to use AudioBlockFifo

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"
 #include "base/mac/mac_logging.h"
 #include "media/audio/mac/audio_manager_mac.h"
+#include "media/base/audio_block_fifo.h"
 #include "media/base/audio_bus.h"
-#include "media/base/audio_fifo.h"
 #include "media/base/data_buffer.h"
 
 namespace media {
 
+// Number of blocks of buffers used in the |fifo_|.
+const int kNumberOfBlocksBufferInFifo = 2;
+
 static std::ostream& operator<<(std::ostream& os,
                                 const AudioStreamBasicDescription& format) {
   os << "sample rate       : " << format.mSampleRate << std::endl
      << "format ID         : " << format.mFormatID << std::endl
      << "format flags      : " << format.mFormatFlags << std::endl
      << "bytes per packet  : " << format.mBytesPerPacket << std::endl
      << "frames per packet : " << format.mFramesPerPacket << std::endl
      << "bytes per frame   : " << format.mBytesPerFrame << std::endl
      << "channels per frame: " << format.mChannelsPerFrame << std::endl
      << "bits per channel  : " << format.mBitsPerChannel;
   return os;
 }
 
 // See "Technical Note TN2091 - Device input using the HAL Output Audio Unit"
 // http://developer.apple.com/library/mac/#technotes/tn2091/_index.html
 // for more details and background regarding this implementation.
 
 AUAudioInputStream::AUAudioInputStream(AudioManagerMac* manager,
                                        const AudioParameters& input_params,
                                        AudioDeviceID audio_device_id)
     : manager_(manager),
       number_of_frames_(input_params.frames_per_buffer()),
       sink_(NULL),
       audio_unit_(0),
       input_device_id_(audio_device_id),
       started_(false),
       hardware_latency_frames_(0),
       number_of_channels_in_frame_(0),
-      audio_bus_(media::AudioBus::Create(input_params)),
-      audio_wrapper_(media::AudioBus::Create(input_params)) {
+      fifo_(new AudioBlockFifo(input_params.channels(), number_of_frames_,

[DaleCurtis, 2014/07/18 18:21:54]

No need for dynamic allocation.

[no longer working on chromium, 2014/07/21 15:13:30]

Done.

+                               kNumberOfBlocksBufferInFifo)) {
   DCHECK(manager_);
 
   // Set up the desired (output) format specified by the client.
   format_.mSampleRate = input_params.sample_rate();
   format_.mFormatID = kAudioFormatLinearPCM;
   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
                          kLinearPCMFormatFlagIsSignedInteger;
   format_.mBitsPerChannel = input_params.bits_per_sample();
   format_.mChannelsPerFrame = input_params.channels();
   format_.mFramesPerPacket = 1;  // uncompressed audio
@@ skipping 428 matching lines @@
   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;
 
-  if (number_of_frames != number_of_frames_) {
-    // Create a FIFO on the fly to handle any discrepancies in callback rates.
-    if (!fifo_) {
-      VLOG(1) << "Audio frame size changed from " << number_of_frames_ << " to "
-              << number_of_frames << "; adding FIFO to compensate.";
-      fifo_.reset(new AudioFifo(
-          format_.mChannelsPerFrame, number_of_frames_ + number_of_frames));
-    }
+  // Copy captured (and interleaved) data into FIFO.
+  fifo_->Push(audio_data, number_of_frames, format_.mBitsPerChannel / 8);
 
-    if (audio_wrapper_->frames() != static_cast<int>(number_of_frames)) {
-      audio_wrapper_ = media::AudioBus::Create(format_.mChannelsPerFrame,
-                                               number_of_frames);
-    }
-  }
+  // Consume and deliver the data when the FIFO has a block of available data.
+  while (fifo_->available_blocks()) {
+    const AudioBus* audio_bus = fifo_->Consume();
+    CHECK_EQ(audio_bus->frames(), static_cast<int>(number_of_frames_));

[DaleCurtis, 2014/07/18 18:21:54]

DCHECK? shouldn't ever be wrong since you're no longer reallocating.

[no longer working on chromium, 2014/07/21 15:13:30]

Done. DCHECK is helping to make sure we deliver what the clients request.

 
-  // Copy captured (and interleaved) data into deinterleaved audio bus.
-  audio_wrapper_->FromInterleaved(
-      audio_data, audio_wrapper_->frames(), format_.mBitsPerChannel / 8);
-
-  // When FIFO does not kick in, data will be directly passed to the callback.
-  if (!fifo_) {
-    CHECK_EQ(audio_wrapper_->frames(), static_cast<int>(number_of_frames_));
+    // Compensate the audio delay caused by the FIFO.
+    capture_delay_bytes += fifo_->available_frames() * format_.mBytesPerFrame;
     sink_->OnData(
-        this, audio_wrapper_.get(), capture_delay_bytes, normalized_volume);
-    return noErr;
-  }
-
-  // Compensate the audio delay caused by the FIFO.
-  capture_delay_bytes += fifo_->frames() * format_.mBytesPerFrame;
-  fifo_->Push(audio_wrapper_.get());
-  if (fifo_->frames() >= static_cast<int>(number_of_frames_)) {
-    // Consume the audio from the FIFO.
-    fifo_->Consume(audio_bus_.get(), 0, audio_bus_->frames());
-    DCHECK(fifo_->frames() < static_cast<int>(number_of_frames_));
-
-    sink_->OnData(
-        this, audio_bus_.get(), capture_delay_bytes, normalized_volume);
+        this, audio_bus, capture_delay_bytes, normalized_volume);
   }
 
   return noErr;
 }
 
 int AUAudioInputStream::HardwareSampleRate() {
   // Determine the default input device's sample-rate.
   AudioDeviceID device_id = kAudioObjectUnknown;
   UInt32 info_size = sizeof(device_id);
 
@@ skipping 121 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