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

 // 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_bus.h"
+#include "media/base/audio_fifo.h"
 #include "media/base/data_buffer.h"
 
 namespace media {
 
 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,
-                                       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.
   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
   format_.mBytesPerPacket = (format_.mBitsPerChannel *
                              input_params.channels()) / 8;
   format_.mBytesPerFrame = format_.mBytesPerPacket;
   format_.mReserved = 0;
 
   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;
 
   // 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[data_byte_size]);
   audio_buffer_list_.mNumberBuffers = 1;
 
   AudioBuffer* audio_buffer = audio_buffer_list_.mBuffers;
   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() {}
 
 // Obtain and open the AUHAL AudioOutputUnit for recording.
 bool AUAudioInputStream::Open() {
   // Verify that we are not already opened.
   if (audio_unit_)
     return false;
 
   // Verify that we have a valid device.
   if (input_device_id_ == kAudioObjectUnknown) {
     NOTREACHED() << "Device ID is unknown";
     return false;
   }
 
   // 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).
+  AudioComponentDescription desc = {
+      kAudioUnitType_Output,
+      kAudioUnitSubType_HALOutput,
+      kAudioUnitManufacturer_Apple,
+      0,
+      0
+  };
 
-  // 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);
+  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;
   }
 
   // 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
@@ skipping 361 matching lines @@
   // 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);
-  // 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));
+    }
 
-  // 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_);
+    if (audio_wrapper_->frames() != static_cast<int>(number_of_frames)) {
+      audio_wrapper_ = media::AudioBus::Create(format_.mChannelsPerFrame,
+                                               number_of_frames);
+    }
+  }
 
-    // Copy captured (and interleaved) data into deinterleaved audio bus.
-    audio_bus_->FromInterleaved(
-        data_->data(), audio_bus_->frames(), format_.mBitsPerChannel / 8);
+  // 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);
 
-    // Deliver data packet, delay estimation and volume level to the user.
-    sink_->OnData(
-        this, audio_bus_.get(), capture_delay_bytes, normalized_volume);
+  // 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;
+  }
+
+  // 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_));
+
+    sink_->OnData(this, audio_bus_.get(), 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