Adding input and output delay estimation for mac.

media/audio/mac/audio_low_latency_input_mac.cc

 // Copyright (c) 2011 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 13 matching lines @@
 
 // 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& params)
     : manager_(manager),
       sink_(NULL),
       audio_unit_(0),
-      started_(false) {
+      input_device_id_(kAudioDeviceUnknown),
+      started_(false),
+      hardware_latency_ms_(0),
+      capture_latency_ms_(0) {
   DCHECK(manager_);
 
   // Set up the desired (output) format specified by the client.
   format_.mSampleRate = params.sample_rate;
   format_.mFormatID = kAudioFormatLinearPCM;
   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
                          kLinearPCMFormatFlagIsSignedInteger;
   format_.mBitsPerChannel = params.bits_per_sample;
   format_.mChannelsPerFrame = params.channels;
   format_.mFramesPerPacket = 1;  // uncompressed audio
@@ skipping 84 matching lines @@
                                 0,          // output element 0
                                 &enableIO,  // disable
                                 sizeof(enableIO));
   if (result) {
     HandleError(result);
     return false;
   }
 
   // Set the current device of the AudioOuputUnit to default input device.
 
-  AudioDeviceID input_device;
-  UInt32 size = sizeof(input_device);
+  UInt32 size = sizeof(input_device_id_);

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

I would use a local here and only assign if we are all OK.

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

 
   // First, obtain the current input device selected by the user.
   result = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,
                                     &size,
-                                    &input_device);
+                                    &input_device_id_);
   if (result) {
     HandleError(result);
     return false;
   }
 
   // Next, set the audio device to be the Audio Unit's current device.
   // Note that, devices can only be set to the AUHAL after enabling IO.
   result = AudioUnitSetProperty(audio_unit_,
                                 kAudioOutputUnitProperty_CurrentDevice,
                                 kAudioUnitScope_Global,
                                 0,
-                                &input_device,
-                                sizeof(input_device));
+                                &input_device_id_,
+                                sizeof(input_device_id_));
   if (result) {
     HandleError(result);
     return false;
   }
 
   // Register the input procedure for the AUHAL.
   // This procedure will be called when the AUHAL has received new data
   // from the input device.
   AURenderCallbackStruct callback;
   callback.inputProc = InputProc;
@@ skipping 36 matching lines @@
   }
 
   // Finally, initialize the audio unit and ensure that it is ready to render.
   // Allocates memory according to the maximum number of audio frames
   // it can produce in response to a single render call.
   result = AudioUnitInitialize(audio_unit_);
   if (result) {
     HandleError(result);
     return false;
   }
+
+  // Update the capture device hardware latency.

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

Can be a static method instead.

[no longer working on chromium, 2011/10/12 15:28:47]

Can't make it since the function needs some member variables. Hope it is fine.

+  UpdateHardwareLatency();
+
   return true;
 }
 
 void AUAudioInputStream::Start(AudioInputCallback* callback) {
   DCHECK(callback);
   if (started_)
     return;
   sink_ = callback;
   OSStatus result = AudioOutputUnitStart(audio_unit_);
   if (result == noErr) {
@@ skipping 57 matching lines @@
                                     flags,
                                     time_stamp,
                                     bus_number,
                                     number_of_frames,
                                     audio_input->audio_buffer_list());
   if (result)
     return result;
 
   // Deliver recorded data to the consumer as a callback.
   return audio_input->Provide(number_of_frames,
-                              audio_input->audio_buffer_list());
+                              audio_input->audio_buffer_list(),
+                              time_stamp);
 }
 
 OSStatus AUAudioInputStream::Provide(UInt32 number_of_frames,
-                                     AudioBufferList* io_data) {
+                                     AudioBufferList* io_data,
+                                     const AudioTimeStamp* time_stamp) {
+  // Update the capture latency.
+  UpdateCaptureLatency(time_stamp);

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

Have you checked if we need to call it each callback?

[no longer working on chromium, 2011/10/12 15:28:47]

The value should be quite stable in the normal cases, but it'd better the check
it for each callback since we never know if the delay is pending up, for
example, soundcard can become less responsive for some reasons. And calling the
function does not cost much since it only does some calculation.

On 2011/10/12 12:10:11, henrika1 wrote:

+
   AudioBuffer& buffer = io_data->mBuffers[0];
   uint8* audio_data = reinterpret_cast<uint8*>(buffer.mData);
+  uint32 capture_delay_bytes = (1.0e-3 * capture_latency_ms_ *

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

I would divide by 1000, and clean up casting here.

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+      format_.mSampleRate * format_.mBytesPerFrame);
   DCHECK(audio_data);
   if (!audio_data)
     return kAudioUnitErr_InvalidElement;
 
-  // TODO(henrika): improve delay estimation. Using buffer size for now.
-  sink_->OnData(this, audio_data, buffer.mDataByteSize, buffer.mDataByteSize);
+  sink_->OnData(this, audio_data, buffer.mDataByteSize, capture_delay_bytes);
 
   return noErr;
 }
 
 double AUAudioInputStream::HardwareSampleRate() {
   // Determine the default input device's sample-rate.
   AudioDeviceID device_id = kAudioDeviceUnknown;
   UInt32 info_size = sizeof(device_id);
 
   AudioObjectPropertyAddress default_input_device_address = {
@@ skipping 25 matching lines @@
                                       0,
                                       &info_size,
                                       &nominal_sample_rate);
   DCHECK_EQ(result, 0);
   if (result)
     return 0.0;
 
   return nominal_sample_rate;
 }
 
+void AUAudioInputStream::UpdateHardwareLatency() {
+  // Get audio unit latency.
+  Float64 audio_unit_latency_s = 0;

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

sec and 0.0.

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+  UInt32 size = sizeof(audio_unit_latency_s);
+  OSStatus result = AudioUnitGetProperty(

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

Use same style as in rest of the code.

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+      audio_unit_, kAudioUnitProperty_Latency, kAudioUnitScope_Global,
+      0, &audio_unit_latency_s, &size);
+  if (result) {
+    DLOG(WARNING) << "GetHardwareLatency: Could not get audio unit latency.";
+    audio_unit_latency_s = 0;

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

not needed

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+  }
+
+  // Get audio device latency.
+  UInt32 device_latency_frames = 0;
+  size = sizeof(device_latency_frames);
+  result = AudioDeviceGetProperty(input_device_id_, 0, true,

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

ditto

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+                                  kAudioDevicePropertyLatency, &size,
+                                  &device_latency_frames);
+  if (result) {
+    DLOG(WARNING) << "GetHardwareLatency: Could not get device latency.";
+    device_latency_frames = 0;

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

ditto

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+  }
+
+  // Get the stream latency.
+  UInt32 stream_latency_frames = 0;
+  size = 0;
+  result = AudioDeviceGetPropertyInfo(input_device_id_, 0, true,

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

ditto

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+                                      kAudioDevicePropertyStreams, &size, NULL);
+  if (!result) {
+    scoped_ptr_malloc<AudioStreamID>
+        streams(reinterpret_cast<AudioStreamID*>(malloc(size)));
+    AudioStreamID* stream_ids = streams.get();
+    result = AudioDeviceGetProperty(

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

ditto

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+        input_device_id_, 0, true,
+        kAudioDevicePropertyStreams, &size, stream_ids);
+    if (result) {
+      DLOG(WARNING) << "UpdateHardwareLatency: Could not get stream id.";
+      return;

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

Wrong!

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+    }
+
+    result = AudioStreamGetProperty(
+        stream_ids[0], 0, kAudioStreamPropertyLatency,

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

ditto

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+        &size, &stream_latency_frames);
+    if (result) {
+      DLOG(WARNING) << "UpdateHardwareLatency: Could not get stream latency.";
+      stream_latency_frames = 0;
+    }
+  } else {
+    DLOG(WARNING) << "UpdateHardwareLatency: Could not get stream id.";
+  }
+
+  hardware_latency_ms_ = static_cast<uint32>(1.0e3 * audio_unit_latency_s +

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

Are you sure?

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+      (1.0e3 * (device_latency_frames + stream_latency_frames)
+      / format_.mSampleRate) + 0.5);
+}
+
+void AUAudioInputStream::UpdateCaptureLatency(
+    const AudioTimeStamp* input_time_stamp) {
+  // Get the delay between now and when the data was hitting the hardware.

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

aooch ;-)

[no longer working on chromium, 2011/10/12 15:28:47]

Done.

+  UInt64 input_time_ns = AudioConvertHostTimeToNanos(
+      input_time_stamp->mHostTime);
+  UInt64 now_ns = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
+  uint32 delay_ms = static_cast<uint32>(1e-6 * (now_ns - input_time_ns) + 0.5);

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

Are you sure?

[no longer working on chromium, 2011/10/12 15:28:47]

I would like to keep it, since it is a more readable comparing with /1000000

+
+  capture_latency_ms_ = delay_ms + hardware_latency_ms_;

[henrika (OOO until Aug 14), 2011/10/12 12:10:11]

I would add a DCHECK here just in case (santity?)

[no longer working on chromium, 2011/10/12 15:28:47]

I need to think a bit more here. For other platforms like linux, the delay value
can be quite high in some special scenarios, like switching devices or when the
CPU spikes. but it will recover soon after the problems are gone. I am not sure
if it will happen on Mac. If it does, having a DCHECK here may break the call.  

+}
+
 void AUAudioInputStream::HandleError(OSStatus err) {
   NOTREACHED() << "error code: " << err;
   if (sink_)
     sink_->OnError(this, static_cast<int>(err));
 }