Implementation of 'AudioContext.getOutputTimestamp' method

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"
@@ skipping 53 matching lines @@
       opened_(false),
       volume_(1.0),
       packet_size_frames_(0),
       packet_size_bytes_(0),
       endpoint_buffer_size_frames_(0),
       device_id_(device_id),
       device_role_(device_role),
       share_mode_(GetShareMode()),
       num_written_frames_(0),
       source_(NULL),
+      hns_units_to_perf_count_(0.0),
       audio_bus_(AudioBus::Create(params)) {
   DCHECK(manager_);
 
   // The empty string is used to indicate a default device and the
   // |device_role_| member controls whether that's the default or default
   // communications device.
   DCHECK_NE(device_id_, AudioDeviceDescription::kDefaultDeviceId);
   DCHECK_NE(device_id_, AudioDeviceDescription::kCommunicationsDeviceId);
 
   DVLOG(1) << "WASAPIAudioOutputStream::WASAPIAudioOutputStream()";
@@ skipping 36 matching lines @@
   // All events are auto-reset events and non-signaled initially.
 
   // Create the event which the audio engine will signal each time
   // a buffer becomes ready to be processed by the client.
   audio_samples_render_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
   DCHECK(audio_samples_render_event_.IsValid());
 
   // Create the event which will be set in Stop() when capturing shall stop.
   stop_render_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
   DCHECK(stop_render_event_.IsValid());
+
+  LARGE_INTEGER performance_frequency;
+  if (QueryPerformanceFrequency(&performance_frequency)) {
+    hns_units_to_perf_count_ =
+        (static_cast<double>(performance_frequency.QuadPart) / 10000000.0);
+  } else {
+    DLOG(ERROR) << "High-resolution performance counters are not supported.";
+  }
 }
 
 WASAPIAudioOutputStream::~WASAPIAudioOutputStream() {
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
 }
 
 bool WASAPIAudioOutputStream::Open() {
   DVLOG(1) << "WASAPIAudioOutputStream::Open()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   if (opened_)
@@ skipping 364 matching lines @@
                  << 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.
     UINT64 position = 0;
+    UINT64 performance_counter_position = 0;
     uint32_t audio_delay_bytes = 0;
-    hr = audio_clock_->GetPosition(&position, NULL);
+    AudioTimestamp output_timestamp;
+
+    hr = audio_clock_->GetPosition(&position, &performance_counter_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);
 
       // 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_;
 
       // 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;
+      if (hns_units_to_perf_count_) {
+        output_timestamp.frames = pos_sample_playing_frames;
+        output_timestamp.ticks =
+            base::TimeTicks::FromQPCValue(performance_counter_position *
+                                          hns_units_to_perf_count_)
+                .ToInternalValue();
+      }
     }
 
     // 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);
+    int frames_filled = source_->OnMoreData(audio_bus_.get(), audio_delay_bytes,
+                                            0, output_timestamp);
     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 103 matching lines @@
 
     // 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