changed the input low latency input impl to use client's requested buffer size on Mac

media/audio/mac/audio_low_latency_input_mac.cc

Index: media/audio/mac/audio_low_latency_input_mac.cc
diff --git a/media/audio/mac/audio_low_latency_input_mac.cc b/media/audio/mac/audio_low_latency_input_mac.cc
index d7a3430f6d85edfcdf8d9ad9fa9d35effec6fe90..6eeaeeb811788e9e375f88c7390f6b7987b70aea 100644
--- a/media/audio/mac/audio_low_latency_input_mac.cc
+++ b/media/audio/mac/audio_low_latency_input_mac.cc
@@ -11,6 +11,7 @@
 #include "base/mac/mac_logging.h"
 #include "media/audio/mac/audio_manager_mac.h"
 #include "media/base/audio_bus.h"
+#include "media/base/audio_fifo.h"
 #include "media/base/data_buffer.h"
 
 namespace media {
@@ -34,17 +35,17 @@ static std::ostream& operator<<(std::ostream& os,
 
 AUAudioInputStream::AUAudioInputStream(AudioManagerMac* manager,
                                        const AudioParameters& input_params,
-                                       const AudioParameters& output_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),
-      fifo_delay_bytes_(0),
       number_of_channels_in_frame_(0),
-      audio_bus_(media::AudioBus::Create(input_params)) {
+      audio_bus_(media::AudioBus::Create(input_params)),
+      audio_wrapper_(media::AudioBus::Create(input_params)) {
   DCHECK(manager_);
 
   // Set up the desired (output) format specified by the client.
@@ -62,12 +63,6 @@ AUAudioInputStream::AUAudioInputStream(AudioManagerMac* manager,
 
   DVLOG(1) << "Desired ouput format: " << format_;
 
-  // Set number of sample frames per callback used by the internal audio layer.
-  // An internal FIFO is then utilized to adapt the internal size to the size
-  // requested by the client.
-  number_of_frames_ = output_params.frames_per_buffer();
-  DVLOG(1) << "Size of data buffer in frames : " << number_of_frames_;
-
   // 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;
@@ -82,38 +77,6 @@ AUAudioInputStream::AUAudioInputStream(AudioManagerMac* manager,
   audio_buffer->mNumberChannels = input_params.channels();
   audio_buffer->mDataByteSize = data_byte_size;
   audio_buffer->mData = audio_data_buffer_.get();
-
-  // Set up an internal FIFO buffer that will accumulate recorded audio frames
-  // until a requested size is ready to be sent to the client.
-  // It is not possible to ask for less than |kAudioFramesPerCallback| number of
-  // audio frames.
-  size_t requested_size_frames =
-      input_params.GetBytesPerBuffer() / format_.mBytesPerPacket;
-  if (requested_size_frames < number_of_frames_) {
-    // For devices that only support a low sample rate like 8kHz, we adjust the
-    // buffer size to match number_of_frames_.  The value of number_of_frames_
-    // in this case has not been calculated based on hardware settings but
-    // rather our hardcoded defaults (see ChooseBufferSize).
-    requested_size_frames = number_of_frames_;
-  }
-
-  requested_size_bytes_ = requested_size_frames * format_.mBytesPerFrame;
-  DVLOG(1) << "Requested buffer size in bytes : " << requested_size_bytes_;
-  DVLOG_IF(0, requested_size_frames > number_of_frames_) << "FIFO is used";
-
-  const int number_of_bytes = number_of_frames_ * format_.mBytesPerFrame;
-  fifo_delay_bytes_ = requested_size_bytes_ - number_of_bytes;
-
-  // Allocate some extra memory to avoid memory reallocations.
-  // Ensure that the size is an even multiple of |number_of_frames_ and
-  // larger than |requested_size_frames|.
-  // Example: number_of_frames_=128, requested_size_frames=480 =>
-  // allocated space equals 4*128=512 audio frames
-  const int max_forward_capacity = number_of_bytes *
-      ((requested_size_frames / number_of_frames_) + 1);
-  fifo_.reset(new media::SeekableBuffer(0, max_forward_capacity));
-
-  data_ = new media::DataBuffer(requested_size_bytes_);
 }
 
 AUAudioInputStream::~AUAudioInputStream() {}
@@ -132,20 +95,20 @@ bool AUAudioInputStream::Open() {
 
   // Start by obtaining an AudioOuputUnit using an AUHAL component description.
 
-  Component comp;
-  ComponentDescription desc;
-
   // Description for the Audio Unit we want to use (AUHAL in this case).
-  desc.componentType = kAudioUnitType_Output;
-  desc.componentSubType = kAudioUnitSubType_HALOutput;
-  desc.componentManufacturer = kAudioUnitManufacturer_Apple;
-  desc.componentFlags = 0;
-  desc.componentFlagsMask = 0;
-  comp = FindNextComponent(0, &desc);
+  AudioComponentDescription desc = {
+      kAudioUnitType_Output,
+      kAudioUnitSubType_HALOutput,
+      kAudioUnitManufacturer_Apple,
+      0,
+      0
+  };
+
+  AudioComponent comp = AudioComponentFindNext(0, &desc);
   DCHECK(comp);
 
   // Get access to the service provided by the specified Audio Unit.
-  OSStatus result = OpenAComponent(comp, &audio_unit_);
+  OSStatus result = AudioComponentInstanceNew(comp, &audio_unit_);
   if (result) {
     HandleError(result);
     return false;
@@ -527,29 +490,47 @@ OSStatus AUAudioInputStream::Provide(UInt32 number_of_frames,
   uint8* audio_data = reinterpret_cast<uint8*>(buffer.mData);
   uint32 capture_delay_bytes = static_cast<uint32>
       ((capture_latency_frames + 0.5) * format_.mBytesPerFrame);
-  // Account for the extra delay added by the FIFO.
-  capture_delay_bytes += fifo_delay_bytes_;
   DCHECK(audio_data);
   if (!audio_data)
     return kAudioUnitErr_InvalidElement;
 
-  // Accumulate captured audio in FIFO until we can match the output size
-  // requested by the client.
-  fifo_->Append(audio_data, buffer.mDataByteSize);
+  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));
+    }
+
+    if (audio_wrapper_->frames() != static_cast<int>(number_of_frames)) {
+      audio_wrapper_ = media::AudioBus::Create(format_.mChannelsPerFrame,
+                                               number_of_frames);
+    }
+  }
 
-  // Deliver recorded data to the client as soon as the FIFO contains a
-  // sufficient amount.
-  if (fifo_->forward_bytes() >= requested_size_bytes_) {
-    // Read from FIFO into temporary data buffer.
-    fifo_->Read(data_->writable_data(), requested_size_bytes_);
+  // Copy captured (and interleaved) data into deinterleaved audio bus.
+  audio_wrapper_->FromInterleaved(

[DaleCurtis, 2014/06/27 00:00:42]

You should be able to set it up such that the AUHAL is capturing Float planar
data, which will allow you to avoid AudioBus construction and deinterleaving. 
You could just use a wrapper w/ channel pointers that you push into  the FIFO.

[no longer working on chromium, 2014/06/27 20:25:37]

I guess you meant opening the device with format:
kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;
As how it is for the output.

It is actually my first attempt, but AudioUnitRender() call fails with error
code -50 with the float format, I played around the float format a bit but could
not make it work.

I am wondering if the input ever support the float deinterleaved format.

[DaleCurtis, 2014/06/28 00:45:50]

Ah, that's unfortunate.

+      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_));
+    sink_->OnData(this, audio_wrapper_.get(), capture_delay_bytes,

[DaleCurtis, 2014/06/27 00:00:42]

clang-format? I think this style is frowned upon.

[no longer working on chromium, 2014/06/27 20:25:37]

Done.

+                  normalized_volume);
+    return noErr;
+  }
 
-    // Copy captured (and interleaved) data into deinterleaved audio bus.
-    audio_bus_->FromInterleaved(
-        data_->data(), audio_bus_->frames(), format_.mBitsPerChannel / 8);
+  // 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());

[DaleCurtis, 2014/06/27 00:00:42]

We could consider making a FIFO::Peek() object which allows callers to directly
use the contents of the FIFO through an AudioBus wrapper.  Thus avoiding this
output copy.  I think that'd be useful on the output side as well.  I can take a
look at that in another CL, or feel free to do it here.

[no longer working on chromium, 2014/06/27 20:25:37]

It is great if we can avoid the copying.

I took a quick look at the AudioFifo code, and it seems to me that the
read/write memory is wrapped internally, it is a bit unclear to me how we can
use a wrapper to get a linear memory out from the Fifo.
please guide me through if I miss something here.

[DaleCurtis, 2014/06/28 00:45:50]

Ah I forgot about the circular buffer properties, you can probably avoid the
copy some of the time, but not all the times in that case.  If you write a Peek
method() you could choose to only use it if Peek() returns enough frames:

const AudioBus* Peek(int max_frames) {
  audio_bus_wrapper_->set_frames(std::min(max_frames, max_frames_ - read_pos_));
  for(int i = 0; i < audio_bus_->channels(); ++i)
     audio_bus_wrapper_->SetChannelData(audio_bus_->channel(i) + read_pos_);
  return audio_bus_wrapper_.get();
}

Then if returned AudioBus* has enough linear frames you can use it. Otherwise
call the normal Consume() w/ copy. So long as there are a couple multiples of
frames_per_buffer() the chances of a linear view are pretty good.

Another idea: Since it seems you'll have to deinterleave the audio, what you can
instead do is keep N AudioBus objects and rotate between them, deinterleaving
directly into each one and passing it to the OnData() callback.  Where N is the
ceil((frames_per_buffer + requested_frames) / frames_per_buffer).  You can use
FromInterleavedPartial() to accomplish this.

[no longer working on chromium, 2014/06/29 20:30:00]

Both are good ideas, and I like the second one particularly since it might be
able to save two copies.
But I prefer writing a new FIFO implementation and taking this as separate
optimization on  the input code of all  platforms.
So I am going to land this CL as it is now.

[DaleCurtis, 2014/06/30 21:00:29]

I think that's a great idea.  Thanks! I don't think any of our current AudioFIFO
users actually rely on the circular buffer logic, so you could theoretically
replace that one with a multi-bus solution which would allow copy-removal for
all current users.

+    DCHECK(fifo_->frames() < static_cast<int>(number_of_frames_));
 
-    // Deliver data packet, delay estimation and volume level to the user.
-    sink_->OnData(
-        this, audio_bus_.get(), capture_delay_bytes, normalized_volume);
+    sink_->OnData(this, audio_bus_.get(), capture_delay_bytes,
+                  normalized_volume);
   }
 
   return noErr;