Pass delay and timestamp to AudioSourceCallback::OnMoreData.

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 <algorithm>
+#include <string>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/sample_rates.h"
 #include "media/base/audio_converter.h"
 #include "media/base/limits.h"
 
 namespace media {
 
 class OnMoreDataConverter
     : 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;
+  int OnMoreData(base::TimeTicks target_playout_time,
+                 int prior_frames_skipped,
+                 AudioBus* dest) 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; }
 
   bool error_occurred() const { return error_occurred_; }
 
  private:
   // AudioConverter::InputCallback implementation.
   double ProvideInput(AudioBus* audio_bus, uint32_t frames_delayed) override;
 
   // Ratio of input bytes to output bytes used to correct playback delay with
   // regard to buffering and resampling.
   const double io_ratio_;
 
   // Source callback.
   AudioOutputStream::AudioSourceCallback* source_callback_;
 
-  // Last |total_bytes_delay| received via OnMoreData(), used to correct
-  // playback delay by ProvideInput() and passed on to |source_callback_|.
-  uint32_t current_total_bytes_delay_;
+  // Last |target_playout_time| received via OnMoreData() and passed on to
+  // |source_callback_|.
+  base::TimeTicks target_playout_time_;
 
   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_;
@@ skipping 292 matching lines @@
   // 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) {
-  current_total_bytes_delay_ = total_bytes_delay;
+int OnMoreDataConverter::OnMoreData(base::TimeTicks target_playout_time,
+                                    int /* prior_frames_skipped */,
+                                    AudioBus* dest) {
+  target_playout_time_ = target_playout_time;
   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

[chcunningham, 2016/07/29 01:21:09]

Why is it ok for you to just drop frames_delayed? I think you need to factor
this into target_playout_time as additional delay. 

[jameswest, 2016/08/26 02:08:47]

Done.

-  // 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);
+      source_callback_->OnMoreData(target_playout_time_, 0, dest);
 
   // 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