Pass delay and timestamp to AudioSourceCallback::OnMoreData.

media/audio/simple_sources.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.
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "media/audio/simple_sources.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/files/file.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/time/time.h"
 #include "media/audio/sounds/wav_audio_handler.h"
 #include "media/base/audio_bus.h"
 
 namespace media {
 namespace {
 // Opens |wav_filename|, reads it and loads it as a wav file. This function will
 // return a null pointer if we can't read the file or if it's malformed. The
 // caller takes ownership of the returned data. The size of the data is stored
 // in |read_length|.
 std::unique_ptr<char[]> ReadWavFile(const base::FilePath& wav_filename,
@@ skipping 81 matching lines @@
       cap_(0),
       callbacks_(0),
       errors_(0) {
 }
 
 SineWaveAudioSource::~SineWaveAudioSource() {
 }
 
 // The implementation could be more efficient if a lookup table is constructed
 // but it is efficient enough for our simple needs.
-int SineWaveAudioSource::OnMoreData(AudioBus* audio_bus,
-                                    uint32_t total_bytes_delay,
-                                    uint32_t frames_skipped) {
+int SineWaveAudioSource::OnMoreData(base::TimeDelta /* delay */,
+                                    base::TimeTicks /* delay_timestamp */,
+                                    int /* prior_frames_skipped */,
+                                    AudioBus* dest) {
   base::AutoLock auto_lock(time_lock_);
   callbacks_++;
 
   // The table is filled with s(t) = kint16max*sin(Theta*t),
   // where Theta = 2*PI*fs.
   // We store the discrete time value |t| in a member to ensure that the
   // next pass starts at a correct state.
-  int max_frames = cap_ > 0 ?
-      std::min(audio_bus->frames(), cap_ - time_state_) : audio_bus->frames();
+  int max_frames =
+      cap_ > 0 ? std::min(dest->frames(), cap_ - time_state_) : dest->frames();
   for (int i = 0; i < max_frames; ++i)
-    audio_bus->channel(0)[i] = sin(2.0 * M_PI * f_ * time_state_++);
-  for (int i = 1; i < audio_bus->channels(); ++i) {
-    memcpy(audio_bus->channel(i), audio_bus->channel(0),
-           max_frames * sizeof(*audio_bus->channel(i)));
+    dest->channel(0)[i] = sin(2.0 * M_PI * f_ * time_state_++);
+  for (int i = 1; i < dest->channels(); ++i) {
+    memcpy(dest->channel(i), dest->channel(0),
+           max_frames * sizeof(*dest->channel(i)));
   }
   return max_frames;
 }
 
 void SineWaveAudioSource::OnError(AudioOutputStream* stream) {
   errors_++;
 }
 
 void SineWaveAudioSource::CapSamples(int cap) {
   base::AutoLock auto_lock(time_lock_);
@@ skipping 49 matching lines @@
       AudioParameters::AUDIO_PCM_LOW_LATENCY,
       GuessChannelLayout(wav_audio_handler_->num_channels()),
       wav_audio_handler_->sample_rate(), wav_audio_handler_->bits_per_sample(),
       params_.frames_per_buffer());
 
   file_audio_converter_.reset(
       new AudioConverter(file_audio_slice, params_, false));
   file_audio_converter_->AddInput(this);
 }
 
-int FileSource::OnMoreData(AudioBus* audio_bus,
-                           uint32_t total_bytes_delay,
-                           uint32_t frames_skipped) {
+int FileSource::OnMoreData(base::TimeDelta /* delay */,
+                           base::TimeTicks /* delay_timestamp */,
+                           int /* prior_frames_skipped */,
+                           AudioBus* dest) {
   // Load the file if we haven't already. This load needs to happen on the
   // audio thread, otherwise we'll run on the UI thread on Mac for instance.
   // This will massively delay the first OnMoreData, but we'll catch up.
   if (!wav_audio_handler_)
     LoadWavFile(path_to_wav_file_);
   if (load_failed_)
     return 0;
 
   DCHECK(wav_audio_handler_.get());
 
   if (wav_audio_handler_->AtEnd(wav_file_read_pos_)) {
     if (looping_)
       Rewind();
     else
       return 0;
   }
 
   // This pulls data from ProvideInput.
-  file_audio_converter_->Convert(audio_bus);
-  return audio_bus->frames();
+  file_audio_converter_->Convert(dest);
+  return dest->frames();
 }
 
 void FileSource::Rewind() {
   wav_file_read_pos_ = 0;
 }
 
 double FileSource::ProvideInput(AudioBus* audio_bus_into_converter,
                                 uint32_t frames_delayed) {
   // Unfilled frames will be zeroed by CopyTo.
   size_t bytes_written;
@@ skipping 14 matching lines @@
       beep_duration_in_buffers_(kBeepDurationMilliseconds *
                                 params.sample_rate() /
                                 params.frames_per_buffer() /
                                 1000),
       beep_generated_in_buffers_(0),
       beep_period_in_frames_(params.sample_rate() / kBeepFrequency) {}
 
 BeepingSource::~BeepingSource() {
 }
 
-int BeepingSource::OnMoreData(AudioBus* audio_bus,
-                              uint32_t total_bytes_delay,
-                              uint32_t frames_skipped) {
+int BeepingSource::OnMoreData(base::TimeDelta /* delay */,
+                              base::TimeTicks /* delay_timestamp */,
+                              int /* prior_frames_skipped */,
+                              AudioBus* dest) {
   // Accumulate the time from the last beep.
   interval_from_last_beep_ += base::TimeTicks::Now() - last_callback_time_;
 
   memset(buffer_.get(), 0, buffer_size_);
   bool should_beep = false;
   BeepContext* beep_context = g_beep_context.Pointer();
   if (beep_context->automatic_beep()) {
     base::TimeDelta delta = interval_from_last_beep_ -
         base::TimeDelta::FromMilliseconds(kAutomaticBeepIntervalInMs);
     if (delta > base::TimeDelta()) {
@@ skipping 23 matching lines @@
       // Then leave low values in the buffer with |high_bytes|.
       position += high_bytes * 2;
     }
 
     ++beep_generated_in_buffers_;
     if (beep_generated_in_buffers_ >= beep_duration_in_buffers_)
       beep_generated_in_buffers_ = 0;
   }
 
   last_callback_time_ = base::TimeTicks::Now();
-  audio_bus->FromInterleaved(
-      buffer_.get(), audio_bus->frames(), params_.bits_per_sample() / 8);
-  return audio_bus->frames();
+  dest->FromInterleaved(buffer_.get(), dest->frames(),
+                        params_.bits_per_sample() / 8);
+  return dest->frames();
 }
 
 void BeepingSource::OnError(AudioOutputStream* stream) {
 }
 
 void BeepingSource::BeepOnce() {
   g_beep_context.Pointer()->SetBeepOnce(true);
 }
 
 }  // namespace media