Pass delay and timestamp to AudioSourceCallback::OnMoreData.

media/audio/win/audio_low_latency_output_win.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/win/audio_low_latency_output_win.h"
 
 #include <Functiondiscoverykeys_devpkey.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/scoped_propvariant.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/win/audio_manager_win.h"
 #include "media/audio/win/avrt_wrapper_win.h"
 #include "media/audio/win/core_audio_util_win.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 
 using base::win::ScopedComPtr;
@@ skipping 474 matching lines @@
     // Grab all available space in the rendering endpoint buffer
     // into which the client can write a data packet.
     hr = audio_render_client_->GetBuffer(packet_size_frames_,
                                          &audio_data);
     if (FAILED(hr)) {
       DLOG(ERROR) << "Failed to use rendering audio buffer: "
                  << std::hex << hr;
       return false;
     }
 
-    // Derive the audio delay which corresponds to the delay between
-    // a render event and the time when the first audio sample in a
-    // packet is played out through the speaker. This delay value
-    // can typically be utilized by an acoustic echo-control (AEC)
-    // unit at the render side.
+    // Find the time when the next sample written to the buffer is expected to
+    // be played out through the speaker.
     UINT64 position = 0;
-    uint32_t audio_delay_bytes = 0;
-    hr = audio_clock_->GetPosition(&position, NULL);
+    UINT64 qps_position = 0;
+    base::TimeTicks target_playout_time;
+    hr = audio_clock_->GetPosition(&position, &qps_position);
     if (SUCCEEDED(hr)) {
-      // Stream position of the sample that is currently playing
-      // through the speaker.
-      double pos_sample_playing_frames = format_.Format.nSamplesPerSec *
-          (static_cast<double>(position) / device_frequency);
+      // Number of frames already played out through the speaker.
+      const uint64_t played_out_frames =
+          format_.Format.nSamplesPerSec * position / device_frequency;
 
-      // Stream position of the last sample written to the endpoint
-      // buffer. Note that, the packet we are about to receive in
-      // the upcoming callback is also included.
-      size_t pos_last_sample_written_frames =
-          num_written_frames_ + packet_size_frames_;
+      // Number of frames that have been written to the buffer but not yet
+      // played out. Note that the packet about to be received in the upcoming
+      // callback is included.
+      const uint64_t delay_frames =
+          num_written_frames_ + packet_size_frames_ - played_out_frames;

[miu, 2016/09/16 18:35:58]

Is is correct to include the |packet_size_frames_| in the new calculation?
Unless I'm missing something, it seems that would set |target_playout_delay| to
the *last* sample about to be rendered by OnMoreData(), rather than the *first*
one (which is what the interface intends).

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

I believe you're correct. I'll change it.

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

Done.

 
-      // Derive the actual delay value which will be fed to the
-      // render client using the OnMoreData() callback.
-      audio_delay_bytes = (pos_last_sample_written_frames -
-          pos_sample_playing_frames) *  format_.Format.nBlockAlign;
+      // Convert the delay from frames to time.
+      const base::TimeDelta delay = base::TimeDelta::FromMicroseconds(
+          delay_frames * base::Time::kMicrosecondsPerSecond /
+          format_.Format.nSamplesPerSec);
+
+      target_playout_time = base::TimeTicks::FromQPSValue(qps_position) + delay;
+    } else {
+      target_playout_time = base::TimeTicks::Now();
     }
 
     // Read a data packet from the registered client source and
     // deliver a delay estimate in the same callback to the client.
 
     int frames_filled =
-        source_->OnMoreData(audio_bus_.get(), audio_delay_bytes, 0);
+        source_->OnMoreData(target_playout_time, 0, audio_bus_.get());
     uint32_t num_filled_bytes = frames_filled * format_.Format.nBlockAlign;
     DCHECK_LE(num_filled_bytes, packet_size_bytes_);
 
     // 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.
     const int bytes_per_sample = format_.Format.wBitsPerSample >> 3;
     audio_bus_->Scale(volume_);
     audio_bus_->ToInterleaved(
         frames_filled, bytes_per_sample, audio_data);
@@ skipping 85 matching lines @@
     DVLOG(1) << "IAudioClient::GetBufferSize: " << std::hex << hr;
     return hr;
   }
 
   *endpoint_buffer_size = buffer_size_in_frames;
   DVLOG(2) << "endpoint buffer size: " << buffer_size_in_frames;
   return hr;
 }
 
 void WASAPIAudioOutputStream::StopThread() {
-  if (render_thread_ ) {
+  if (render_thread_) {
     if (render_thread_->HasBeenStarted()) {
       // Wait until the thread completes and perform cleanup.
       SetEvent(stop_render_event_.Get());
       render_thread_->Join();
     }
 
     render_thread_.reset();
 
     // Ensure that we don't quit the main thread loop immediately next
     // time Start() is called.
     ResetEvent(stop_render_event_.Get());
   }
 
   source_ = NULL;
 }
 
 }  // namespace media