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_(kAudioObjectUnknown),
+      started_(false),
+      hardware_latency_frames_(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;
+  // First, obtain the current input device selected by the user.

[henrika (OOO until Aug 14), 2011/10/21 07:27:23]

May I ask why you decided to use another API here?

[no longer working on chromium, 2011/10/21 12:21:46]

Andrew pointed out that the AudioHardwareGetProperty is deprecated in deprecated
in 10.6 in favour of AudioObjectGetPropertyData(). See CL:
http://codereview.chromium.org/210009
  

+  AudioObjectPropertyAddress default_intput_device_address = {
+    kAudioHardwarePropertyDefaultInputDevice,
+    kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster
+  };
+  AudioDeviceID input_device = kAudioObjectUnknown;
   UInt32 size = sizeof(input_device);
-
-  // First, obtain the current input device selected by the user.
-  result = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,
-                                    &size,
-                                    &input_device);
+  result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                      &default_intput_device_address,
+                                      0,
+                                      0,
+                                      &size,
+                                      &input_device);
   if (result) {
     HandleError(result);
     return false;
   }
 
+  // Store the input device id.

[henrika (OOO until Aug 14), 2011/10/21 07:27:23]

Don't think this comment adds much.

[no longer working on chromium, 2011/10/21 12:21:46]

Done.

+  input_device_id_ = input_device;
+
   // 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,
+                                &input_device_id_,
                                 sizeof(input_device));
   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;
@@ skipping 37 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;
   }
+
+  hardware_latency_frames_ = GetHardwareLatency();

[henrika (OOO until Aug 14), 2011/10/21 07:27:23]

But a comment here could emphasize that parts of the delay estimate is fixed and
can be stored here.

[no longer working on chromium, 2011/10/21 12:21:46]

Done.

+
   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.
+  double capture_latency_frames = GetCaptureLatency(time_stamp);
+
   AudioBuffer& buffer = io_data->mBuffers[0];
   uint8* audio_data = reinterpret_cast<uint8*>(buffer.mData);
+  uint32 capture_delay_bytes = static_cast<uint32>
+      (capture_latency_frames * format_.mBytesPerFrame + 0.5);
   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;
+  AudioDeviceID device_id = kAudioObjectUnknown;
   UInt32 info_size = sizeof(device_id);
 
   AudioObjectPropertyAddress default_input_device_address = {
     kAudioHardwarePropertyDefaultInputDevice,
     kAudioObjectPropertyScopeGlobal,
     kAudioObjectPropertyElementMaster
   };
   OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
                                                &default_input_device_address,
                                                0,
@@ skipping 18 matching lines @@
                                       0,
                                       &info_size,
                                       &nominal_sample_rate);
   DCHECK_EQ(result, 0);
   if (result)
     return 0.0;
 
   return nominal_sample_rate;
 }
 
+double AUAudioInputStream::GetHardwareLatency() {
+  if (!audio_unit_ || input_device_id_ == kAudioObjectUnknown)

[henrika (OOO until Aug 14), 2011/10/21 07:27:23]

Is this a valid state? Guess it is since this part will be very low. Perhaps a
DLOG()?

[no longer working on chromium, 2011/10/21 12:21:46]

It is safer to add a check here, since this function is a member to the class.

Done. 

+    return 0.0;
+
+  // Get audio unit latency.
+  Float64 audio_unit_latency_sec = 0.0;
+  UInt32 size = sizeof(audio_unit_latency_sec);
+  OSStatus result = AudioUnitGetProperty(audio_unit_,
+                                         kAudioUnitProperty_Latency,
+                                         kAudioUnitScope_Global,
+                                         0,
+                                         &audio_unit_latency_sec,
+                                         &size);
+  if (result) {
+    DLOG(WARNING) << "GetHardwareLatency: Could not get audio unit latency.";

[henrika (OOO until Aug 14), 2011/10/21 07:27:23]

Don't need GetHardwareLatency:, the log message is rich as is.  Function name is
added to output log.

Also, DLOG_IF(WARNING, result != noErr) <<

[no longer working on chromium, 2011/10/21 12:21:46]

Done.

+  }
+
+  // Get audio device latency.
+  UInt32 device_latency_frames = 0;
+  size = sizeof(device_latency_frames);
+  result = AudioDeviceGetProperty(input_device_id_, 0,
+                                  true,
+                                  kAudioDevicePropertyLatency,
+                                  &size,
+                                  &device_latency_frames);
+  if (result) {
+    DLOG(WARNING) << "GetHardwareLatency: Could not get device latency.";

[henrika (OOO until Aug 14), 2011/10/21 07:27:23]

ditto

[no longer working on chromium, 2011/10/21 12:21:46]

Done.

+  }
+
+  // Get the stream latency.
+  UInt32 stream_latency_frames = 0;
+  size = 0;
+  result = AudioDeviceGetPropertyInfo(input_device_id_,
+                                      0,
+                                      true,
+                                      kAudioDevicePropertyStreams,
+                                      &size,
+                                      NULL);
+  if (!result) {
+    scoped_ptr_malloc<AudioStreamID>
+        streams(reinterpret_cast<AudioStreamID*>(malloc(size)));
+    AudioStreamID* stream_ids = streams.get();
+    result = AudioDeviceGetProperty(input_device_id_,
+                                    0,
+                                    true,
+                                    kAudioDevicePropertyStreams,
+                                    &size,
+                                    stream_ids);
+    if (!result)
+      result = AudioStreamGetProperty(stream_ids[0],
+                                      0,
+                                      kAudioStreamPropertyLatency,
+                                      &size,
+                                      &stream_latency_frames);
+  }
+  // Logs the warning if it fails to get the stream latency.

[scherkus (not reviewing), 2011/10/21 00:20:58]

nit: comment adds no value -- remove

[no longer working on chromium, 2011/10/21 12:21:46]

Done.

+  if (result) {
+    DLOG(WARNING) << "GetHardwareLatency: Could not get stream latency.";
+  }
+
+  // Store the hardware latency value in frames.

[scherkus (not reviewing), 2011/10/21 00:20:58]

ditto

[no longer working on chromium, 2011/10/21 12:21:46]

Done.

+  return static_cast<double>(audio_unit_latency_sec *

[henrika (OOO until Aug 14), 2011/10/21 07:27:23]

I would write it as ((x*a) + b + c)

[no longer working on chromium, 2011/10/21 12:21:46]

Done.

+      format_.mSampleRate + device_latency_frames + stream_latency_frames);
+}
+
+double AUAudioInputStream::GetCaptureLatency(
+    const AudioTimeStamp* input_time_stamp) {
+  // Get the delay between now and when the data was reaching the hardware.

[henrika (OOO until Aug 14), 2011/10/21 07:27:23]

This comment is not clear. See my proposal in the header file. Basically, you
are measuring the time difference from the timestamp of the first recorded frame
in a packet and the timestamp of the callback.

[no longer working on chromium, 2011/10/21 12:21:46]

Done.

+  UInt64 input_time_ns = AudioConvertHostTimeToNanos(

[henrika (OOO until Aug 14), 2011/10/21 07:27:23]

capture_time_ns

[no longer working on chromium, 2011/10/21 12:21:46]

Done.

+      input_time_stamp->mHostTime);
+  UInt64 now_ns = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
+  double delay_frames = static_cast<double>
+      (1e-9 * (now_ns - input_time_ns) * format_.mSampleRate);
+
+  return (delay_frames + hardware_latency_frames_);

[henrika (OOO until Aug 14), 2011/10/21 07:27:23]

Comment about sum of fixed parts and dynamic part perhaps.

[no longer working on chromium, 2011/10/21 12:21:46]

Done.

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