Pass delay and timestamp to AudioSourceCallback::OnMoreData.

media/audio/mac/audio_auhal_mac.cc

 // Copyright 2013 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_auhal_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
+#include <string>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
-#include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "media/audio/mac/audio_manager_mac.h"
 #include "media/base/audio_pull_fifo.h"
 
 namespace media {
 
 static void WrapBufferList(AudioBufferList* buffer_list,
                            AudioBus* bus,
                            int frames) {
   DCHECK(buffer_list);
@@ skipping 203 matching lines @@
       audio_fifo_.reset(new AudioPullFifo(
           output_channels_,
           number_of_frames_,
           base::Bind(&AUHALStream::ProvideInput, base::Unretained(this))));
     }
   }
 
   // Make |output_bus_| wrap the output AudioBufferList.
   WrapBufferList(data, output_bus_.get(), number_of_frames);
 
-  // Update the playout latency.
-  const double playout_latency_frames = GetPlayoutLatency(output_time_stamp);
-  current_hardware_pending_bytes_ = static_cast<uint32_t>(
-      (playout_latency_frames + 0.5) * params_.GetBytesPerFrame());
+  // Update the playout time.
+  const UInt64 output_time_ns =
+      AudioConvertHostTimeToNanos(output_time_stamp->mHostTime);
+  // TODO(jameswest): Find an alternative to FromInternalValue.
+  current_target_playout_time_ = base::TimeTicks::FromInternalValue(
+      output_time_ns / base::Time::kNanosecondsPerMicrosecond);
 
   if (audio_fifo_)
     audio_fifo_->Consume(output_bus_.get(), output_bus_->frames());
   else
     ProvideInput(0, output_bus_.get());
 
   last_number_of_frames_ = number_of_frames;
 
   return noErr;
 }
 
 void AUHALStream::ProvideInput(int frame_delay, AudioBus* dest) {
   base::AutoLock auto_lock(source_lock_);
   if (!source_) {
     dest->Zero();
     return;
   }
 
+  const base::TimeDelta delay = base::TimeDelta::FromSecondsD(
+      static_cast<double>(frame_delay) / params_.sample_rate());
+  const base::TimeTicks target_playout_time =
+      current_target_playout_time_ + delay;
+
   // Supply the input data and render the output data.
-  source_->OnMoreData(dest, current_hardware_pending_bytes_ +
-                                frame_delay * params_.GetBytesPerFrame(),
-                      current_lost_frames_);
+  source_->OnMoreData(target_playout_time, current_lost_frames_, dest);
   dest->Scale(volume_);
   current_lost_frames_ = 0;
 }
 
 // AUHAL callback.
 OSStatus AUHALStream::InputProc(
     void* user_data,
     AudioUnitRenderActionFlags* flags,
     const AudioTimeStamp* output_time_stamp,
     UInt32 bus_number,
@@ skipping 52 matching lines @@
       &device_latency_frames);
   if (result != noErr) {
     OSSTATUS_DLOG(WARNING, result) << "Could not get audio device latency";
     return 0.0;
   }
 
   return static_cast<double>((audio_unit_latency_sec *
       output_format_.mSampleRate) + device_latency_frames);
 }
 
-double AUHALStream::GetPlayoutLatency(
-    const AudioTimeStamp* output_time_stamp) {
-  // Ensure mHostTime is valid.
-  if ((output_time_stamp->mFlags & kAudioTimeStampHostTimeValid) == 0)

[chcunningham, 2016/07/29 01:21:09]

This method had checks for validity of host time... these checks should probably
stay in your new usage.

[jameswest, 2016/08/26 02:08:47]

Done.

-    return 0;
-
-  // Get the delay between the moment getting the callback and the scheduled
-  // time stamp that tells when the data is going to be played out.
-  UInt64 output_time_ns = AudioConvertHostTimeToNanos(
-      output_time_stamp->mHostTime);
-  UInt64 now_ns = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
-
-  // Prevent overflow leading to huge delay information; occurs regularly on
-  // the bots, probably less so in the wild.
-  if (now_ns > output_time_ns)

[chcunningham, 2016/07/29 01:21:09]

I think you need to still account for this

[jameswest, 2016/08/26 02:08:47]

Done.

-    return 0;
-
-  double delay_frames = static_cast<double>
-      (1e-9 * (output_time_ns - now_ns) * output_format_.mSampleRate);
-
-  return (delay_frames + hardware_latency_frames_);
-}
-
 void AUHALStream::UpdatePlayoutTimestamp(const AudioTimeStamp* timestamp) {
   if ((timestamp->mFlags & kAudioTimeStampSampleTimeValid) == 0)
     return;
 
   if (last_sample_time_) {
     DCHECK_NE(0U, last_number_of_frames_);
     UInt32 diff =
         static_cast<UInt32>(timestamp->mSampleTime - last_sample_time_);
     if (diff != last_number_of_frames_) {
       DCHECK_GT(diff, last_number_of_frames_);
@@ skipping 185 matching lines @@
   OSStatus result = AudioUnitUninitialize(audio_unit_);
   OSSTATUS_DLOG_IF(ERROR, result != noErr, result)
       << "AudioUnitUninitialize() failed.";
   result = AudioComponentInstanceDispose(audio_unit_);
   OSSTATUS_DLOG_IF(ERROR, result != noErr, result)
       << "AudioComponentInstanceDispose() failed.";
   audio_unit_ = 0;
 }
 
 }  // namespace media