Pass delay and timestamp to AudioSourceCallback::OnMoreData.

media/audio/android/opensles_output.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/android/opensles_output.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "media/audio/android/audio_manager_android.h"
 
 #define LOG_ON_FAILURE_AND_RETURN(op, ...)      \
   do {                                          \
     SLresult err = (op);                        \
     if (err != SL_RESULT_SUCCESS) {             \
       DLOG(ERROR) << #op << " failed: " << err; \
       return __VA_ARGS__;                       \
     }                                           \
@@ skipping 314 matching lines @@
 }
 
 void OpenSLESOutputStream::FillBufferQueueNoLock() {
   // Ensure that the calling thread has acquired the lock since it is not
   // done in this method.
   lock_.AssertAcquired();
 
   // Calculate the position relative to the number of frames written.
   uint32_t position_in_ms = 0;
   SLresult err = (*player_)->GetPosition(player_, &position_in_ms);
-  const int delay =
-      err == SL_RESULT_SUCCESS
-          ? -delay_calculator_.GetFramesToTarget(
-                base::TimeDelta::FromMilliseconds(position_in_ms)) *
-                bytes_per_frame_
-          : 0;
+  // Calculate the delay in frames.

[miu, 2016/08/31 23:26:54]

nit: At first glance it feels wonky to get a time position, convert it to a
frame delay, and then convert that back to a time position in the code later.
However, this is absolutely correct because one is relative to the audio
system's clock, which is different from the system reference clock (the one that
creates TimeTicks values).

So, could you elaborate on this comment here? Perhaps something like:

"Given the media time position, compute the approximate number of frames
currently queued for playout. This will be added to the system reference time
below to compute the approximate playout time of the audio to be rendered in the
call to OnMoreData() below."

[James West, 2016/09/13 07:40:50]

Done.

+  const int delay = err == SL_RESULT_SUCCESS
+                        ? -delay_calculator_.GetFramesToTarget(
+                              base::TimeDelta::FromMilliseconds(position_in_ms))
+                        : 0;
   DCHECK_GE(delay, 0);
 
+  // Calculate when the requested data will be played by converting the delay to
+  // time and adding it to the current time.
+  const base::TimeTicks target_playout_time =
+      base::TimeTicks::Now() +
+      base::TimeDelta::FromMicroseconds(
+          delay * base::Time::kMicrosecondsPerSecond / format_.samplesPerSec);
+
   // Read data from the registered client source.
-  const int frames_filled = callback_->OnMoreData(audio_bus_.get(), delay, 0);
+  const int frames_filled =
+      callback_->OnMoreData(target_playout_time, 0, audio_bus_.get());
   if (frames_filled <= 0) {
     // Audio source is shutting down, or halted on error.
     return;
   }
 
   // Note: If the internal representation ever changes from 16-bit PCM to
   // raw float, the data must be clipped and sanitized since it may come
   // from an untrusted source such as NaCl.
   audio_bus_->Scale(muted_ ? 0.0f : volume_);
   audio_bus_->ToInterleaved(frames_filled, format_.bitsPerSample / 8,
@@ skipping 31 matching lines @@
   }
 }
 
 void OpenSLESOutputStream::HandleError(SLresult error) {
   DLOG(ERROR) << "OpenSLES Output error " << error;
   if (callback_)
     callback_->OnError(this);
 }
 
 }  // namespace media