Implementation of 'AudioContext.getOutputTimestamp' method

media/audio/audio_output_resampler.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/audio_output_resampler.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 15 matching lines @@
     : public AudioOutputStream::AudioSourceCallback,
       public AudioConverter::InputCallback {
  public:
   OnMoreDataConverter(const AudioParameters& input_params,
                       const AudioParameters& output_params);
   ~OnMoreDataConverter() override;
 
   // AudioSourceCallback interface.
   int OnMoreData(AudioBus* dest,
                  uint32_t total_bytes_delay,
-                 uint32_t frames_skipped) override;
+                 uint32_t frames_skipped,
+                 const AudioTimestamp& timestamp) override;
   void OnError(AudioOutputStream* stream) override;
 
   // Sets |source_callback_|.  If this is not a new object, then Stop() must be
   // called before Start().
   void Start(AudioOutputStream::AudioSourceCallback* callback);
 
   // Clears |source_callback_| and flushes the resampler.
   void Stop();
 
   bool started() const { return source_callback_ != nullptr; }
@@ skipping 18 matching lines @@
   const int input_bytes_per_frame_;
 
   // Handles resampling, buffering, and channel mixing between input and output
   // parameters.
   AudioConverter audio_converter_;
 
   // True if OnError() was ever called.  Should only be read if the underlying
   // stream has been stopped.
   bool error_occurred_;
 
+  // Information about last recorded stream output position.
+  AudioTimestamp output_timestamp_;
+
   DISALLOW_COPY_AND_ASSIGN(OnMoreDataConverter);
 };
 
 // Record UMA statistics for hardware output configuration.
 static void RecordStats(const AudioParameters& output_params) {
   // Note the 'PRESUBMIT_IGNORE_UMA_MAX's below, these silence the PRESUBMIT.py
   // check for uma enum max usage, since we're abusing UMA_HISTOGRAM_ENUMERATION
   // to report a discrete value.
   UMA_HISTOGRAM_ENUMERATION(
       "Media.HardwareAudioBitsPerChannel",
@@ skipping 256 matching lines @@
   DCHECK(callbacks_.empty());
 }
 
 OnMoreDataConverter::OnMoreDataConverter(const AudioParameters& input_params,
                                          const AudioParameters& output_params)
     : io_ratio_(static_cast<double>(input_params.GetBytesPerSecond()) /
                 output_params.GetBytesPerSecond()),
       source_callback_(nullptr),
       input_bytes_per_frame_(input_params.GetBytesPerFrame()),
       audio_converter_(input_params, output_params, false),
-      error_occurred_(false) {}
+      error_occurred_(false),
+      output_timestamp_() {}
 
 OnMoreDataConverter::~OnMoreDataConverter() {
   // Ensure Stop() has been called so we don't end up with an AudioOutputStream
   // calling back into OnMoreData() after destruction.
   CHECK(!source_callback_);
 }
 
 void OnMoreDataConverter::Start(
     AudioOutputStream::AudioSourceCallback* callback) {
   CHECK(!source_callback_);
   source_callback_ = callback;
 
   // While AudioConverter can handle multiple inputs, we're using it only with
   // a single input currently.  Eventually this may be the basis for a browser
   // side mixer.
   audio_converter_.AddInput(this);
 }
 
 void OnMoreDataConverter::Stop() {
   CHECK(source_callback_);
   source_callback_ = nullptr;
   audio_converter_.RemoveInput(this);
 }
 
 int OnMoreDataConverter::OnMoreData(AudioBus* dest,
                                     uint32_t total_bytes_delay,
-                                    uint32_t frames_skipped) {
+                                    uint32_t frames_skipped,
+                                    const AudioTimestamp& timestamp) {
+  output_timestamp_ = timestamp;
   current_total_bytes_delay_ = total_bytes_delay;
   audio_converter_.Convert(dest);
 
   // Always return the full number of frames requested, ProvideInput()
   // will pad with silence if it wasn't able to acquire enough data.
   return dest->frames();
 }
 
 double OnMoreDataConverter::ProvideInput(AudioBus* dest,
                                          uint32_t frames_delayed) {
   // Adjust playback delay to include |frames_delayed|.
   // TODO(dalecurtis): Stop passing bytes around, it doesn't make sense since
   // AudioBus is just float data.  Use TimeDelta instead.
   uint32_t new_total_bytes_delay = base::saturated_cast<uint32_t>(
       io_ratio_ *
       (current_total_bytes_delay_ + frames_delayed * input_bytes_per_frame_));
 
   // Retrieve data from the original callback.
-  const int frames =
-      source_callback_->OnMoreData(dest, new_total_bytes_delay, 0);
+  const int frames = source_callback_->OnMoreData(dest, new_total_bytes_delay,
+                                                  0, output_timestamp_);
 
   // Zero any unfilled frames if anything was filled, otherwise we'll just
   // return a volume of zero and let AudioConverter drop the output.
   if (frames > 0 && frames < dest->frames())
     dest->ZeroFramesPartial(frames, dest->frames() - frames);
   return frames > 0 ? 1 : 0;
 }
 
 void OnMoreDataConverter::OnError(AudioOutputStream* stream) {
   error_occurred_ = true;
   source_callback_->OnError(stream);
 }
 
 }  // namespace media