Pass delay and timestamp to AudioSourceCallback::OnMoreData.

media/audio/cras/cras_unified.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/cras/cras_unified.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "media/audio/cras/audio_manager_cras.h"
 
@@ skipping 43 matching lines @@
     : client_(NULL),
       stream_id_(0),
       params_(params),
       bytes_per_frame_(0),
       is_playing_(false),
       volume_(1.0),
       manager_(manager),
       source_callback_(NULL),
       stream_direction_(CRAS_STREAM_OUTPUT) {
   DCHECK(manager_);
-  DCHECK(params_.channels()  > 0);
+  DCHECK_GT(params_.channels(), 0);
 
   output_bus_ = AudioBus::Create(params);
 }
 
 CrasUnifiedStream::~CrasUnifiedStream() {
   DCHECK(!is_playing_);
 }
 
 bool CrasUnifiedStream::Open() {
   // Sanity check input values.
@@ skipping 151 matching lines @@
   if (!client_)
     return;
   volume_ = static_cast<float>(volume);
   cras_client_set_stream_volume(client_, stream_id_, volume_);
 }
 
 void CrasUnifiedStream::GetVolume(double* volume) {
   *volume = volume_;
 }
 
-uint32_t CrasUnifiedStream::GetBytesLatency(const struct timespec& latency_ts) {
-  uint32_t latency_usec;
-
+base::TimeTicks CrasUnifiedStream::GetTargetPlayoutTime(
+    const struct timespec& latency_ts) {
   // Treat negative latency (if we are too slow to render) as 0.
   if (latency_ts.tv_sec < 0 || latency_ts.tv_nsec < 0) {
-    latency_usec = 0;
-  } else {
-    latency_usec = (latency_ts.tv_sec * base::Time::kMicrosecondsPerSecond) +
-        latency_ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond;
+    return base::TimeTicks::Now();
   }
 
-  double frames_latency =
-      latency_usec * params_.sample_rate() / base::Time::kMicrosecondsPerSecond;
-
-  return static_cast<unsigned int>(frames_latency * bytes_per_frame_);
+  return base::TimeTicks::Now() + base::TimeDelta::FromTimeSpec(latency_ts);
 }
 
 // Static callback asking for samples.
 int CrasUnifiedStream::UnifiedCallback(cras_client* client,
                                        cras_stream_id_t stream_id,
                                        uint8_t* input_samples,
                                        uint8_t* output_samples,
                                        unsigned int frames,
                                        const timespec* input_ts,
                                        const timespec* output_ts,

[jameswest, 2016/09/16 21:59:43]

Do you know if |output_ts| is target playout time? The documentation below says
it's "Playback time for the first sample written."

https://chromium.googlesource.com/chromiumos/third_party/adhd/+/stabilize-705...

If so, what do you think about adding TimeTicks::FromTimeSpec and using this
value directly?

[miu, 2016/09/16 23:38:28]

That would be my interpretation (that output_ts is the target playout time).
However...
It could be relative to a different clock or time origin (i.e., not the same
clock/origin as clock_gettime(MONOTONIC)). You'd have to dig deeper to find out
whether that's the case. If it is, I'd still suggest adding a DCHECK to ensure
the assumption isn't broken by CrAS changes in the future, unless you can find
API comments that are specific about this.

[jameswest, 2016/09/19 23:32:36]

I couldn't find anything with a quick search, so I left it as is. We need the
latency now anyway, so it would only help to improve the accuracy of the
timestamp, which probably isn't necessary.

                                        void* arg) {
   CrasUnifiedStream* me = static_cast<CrasUnifiedStream*>(arg);
   return me->DispatchCallback(frames,
                               input_samples,
                               output_samples,
                               input_ts,
                               output_ts);
 }
 
 // Static callback for stream errors.
@@ skipping 28 matching lines @@
 uint32_t CrasUnifiedStream::WriteAudio(size_t frames,
                                        uint8_t* buffer,
                                        const timespec* sample_ts) {
   DCHECK_EQ(frames, static_cast<size_t>(output_bus_->frames()));
 
   // Determine latency and pass that on to the source.
   timespec latency_ts  = {0, 0};
   cras_client_calc_playback_latency(sample_ts, &latency_ts);
 
   int frames_filled = source_callback_->OnMoreData(
-      output_bus_.get(), GetBytesLatency(latency_ts), 0);
+      GetTargetPlayoutTime(latency_ts), 0, output_bus_.get());
 
   // Note: If this ever changes to output raw float the data must be clipped and
   // sanitized since it may come from an untrusted source such as NaCl.
   output_bus_->ToInterleaved(
       frames_filled, bytes_per_frame_ / params_.channels(), buffer);
 
   return frames_filled;
 }
 
 void CrasUnifiedStream::NotifyStreamError(int err) {
   // This will remove the stream from the client.
   if (source_callback_)
     source_callback_->OnError(this);
 }
 
 }  // namespace media