Pass delay and timestamp to AudioSourceCallback::OnMoreData.

media/audio/alsa/alsa_output.cc

 // Copyright 2013 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.
 //
 // THREAD SAFETY
 //
 // AlsaPcmOutputStream object is *not* thread-safe and should only be used
 // from the audio thread.  We DCHECK on this assumption whenever we can.
 //
 // SEMANTICS OF Close()
@@ skipping 19 matching lines @@
 // When |stop_stream_| is set, no more commands will be made against the
 // ALSA device, and playback will effectively stop.  From the client's point of
 // view, it will seem that the device has just clogged and stopped requesting
 // data.
 
 #include "media/audio/alsa/alsa_output.h"
 
 #include <stddef.h>
 
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/free_deleter.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "media/audio/alsa/alsa_util.h"
 #include "media/audio/alsa/alsa_wrapper.h"
 #include "media/audio/alsa/audio_manager_alsa.h"
+#include "media/base/audio_timestamp_helper.h"
 #include "media/base/channel_mixer.h"
 #include "media/base/data_buffer.h"
 #include "media/base/seekable_buffer.h"
 
 namespace media {
 
 // Set to 0 during debugging if you want error messages due to underrun
 // events or other recoverable errors.
 #if defined(NDEBUG)
 static const int kPcmRecoverIsSilent = 1;
@@ skipping 58 matching lines @@
       break;
     case AlsaPcmOutputStream::kIsPlaying:
       os << "kIsPlaying";
       break;
     case AlsaPcmOutputStream::kIsStopped:
       os << "kIsStopped";
       break;
     case AlsaPcmOutputStream::kIsClosed:
       os << "kIsClosed";
       break;
-  };
+  }
   return os;
 }
 
 const char AlsaPcmOutputStream::kDefaultDevice[] = "default";
 const char AlsaPcmOutputStream::kAutoSelectDevice[] = "";
 const char AlsaPcmOutputStream::kPlugPrefix[] = "plug:";
 
 // We use 40ms as our minimum required latency. If it is needed, we may be able
 // to get it down to 20ms.
 const uint32_t AlsaPcmOutputStream::kMinLatencyMicros = 40 * 1000;
 
 AlsaPcmOutputStream::AlsaPcmOutputStream(const std::string& device_name,
                                          const AudioParameters& params,
                                          AlsaWrapper* wrapper,
                                          AudioManagerBase* manager)
     : requested_device_name_(device_name),
       pcm_format_(alsa_util::BitsToFormat(params.bits_per_sample())),
       channels_(params.channels()),
       channel_layout_(params.channel_layout()),
       sample_rate_(params.sample_rate()),
       bytes_per_sample_(params.bits_per_sample() / 8),
       bytes_per_frame_(params.GetBytesPerFrame()),
       packet_size_(params.GetBytesPerBuffer()),
       latency_(std::max(
           base::TimeDelta::FromMicroseconds(kMinLatencyMicros),
-          FramesToTimeDelta(params.frames_per_buffer() * 2, sample_rate_))),
+          AudioTimestampHelper::FramesToTime(params.frames_per_buffer() * 2,
+                                             sample_rate_))),
       bytes_per_output_frame_(bytes_per_frame_),
       alsa_buffer_frames_(0),
       stop_stream_(false),
       wrapper_(wrapper),
       manager_(manager),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       playback_handle_(NULL),
       frames_per_packet_(packet_size_ / bytes_per_frame_),
       state_(kCreated),
       volume_(1.0f),
       source_callback_(NULL),
       audio_bus_(AudioBus::Create(params)),
+      tick_clock_(new base::DefaultTickClock()),
       weak_factory_(this) {
   DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
   DCHECK_EQ(audio_bus_->frames() * bytes_per_frame_, packet_size_);
 
   // Sanity check input values.
   if (!params.IsValid()) {
     LOG(WARNING) << "Unsupported audio parameters.";
     TransitionTo(kInError);
   }
 
@@ skipping 161 matching lines @@
 
   volume_ = static_cast<float>(volume);
 }
 
 void AlsaPcmOutputStream::GetVolume(double* volume) {
   DCHECK(CalledOnValidThread());
 
   *volume = volume_;
 }
 
+void AlsaPcmOutputStream::SetTickClockForTesting(
+    std::unique_ptr<base::TickClock> tick_clock) {
+  DCHECK(tick_clock);
+  tick_clock_ = std::move(tick_clock);
+}
+
 void AlsaPcmOutputStream::BufferPacket(bool* source_exhausted) {
   DCHECK(CalledOnValidThread());
 
   // If stopped, simulate a 0-length packet.
   if (stop_stream_) {
     buffer_->Clear();
     *source_exhausted = true;
     return;
   }
 
   *source_exhausted = false;
 
   // Request more data only when we run out of data in the buffer, because
   // WritePacket() consumes only the current chunk of data.
   if (!buffer_->forward_bytes()) {
     // Before making a request to source for data we need to determine the
-    // delay (in bytes) for the requested data to be played.
-    const uint32_t hardware_delay = GetCurrentDelay() * bytes_per_frame_;
+    // delay for the requested data to be played.
+    const base::TimeDelta delay =
+        AudioTimestampHelper::FramesToTime(GetCurrentDelay(), sample_rate_);
 
     scoped_refptr<media::DataBuffer> packet =
         new media::DataBuffer(packet_size_);
-    int frames_filled = RunDataCallback(
-        audio_bus_.get(), hardware_delay);
+    int frames_filled =
+        RunDataCallback(delay, tick_clock_->NowTicks(), audio_bus_.get());
 
     size_t packet_size = frames_filled * bytes_per_frame_;
     DCHECK_LE(packet_size, packet_size_);
 
     // TODO(dalecurtis): Channel downmixing, upmixing, should be done in mixer;
     // volume adjust should use SSE optimized vector_fmul() prior to interleave.
     AudioBus* output_bus = audio_bus_.get();
     ChannelLayout output_channel_layout = channel_layout_;
     if (channel_mixer_) {
       output_bus = mixed_audio_bus_.get();
@@ skipping 128 matching lines @@
     next_fill_time = base::TimeDelta();
   } else if (buffer_->forward_bytes()) {
     // If we've got data available and no room, poll until room is available.
     // Polling in this manner allows us to ensure a more consistent callback
     // schedule.  In testing this yields a variance of +/- 5ms versus the non-
     // polling strategy which is around +/- 30ms and bimodal.
     next_fill_time = base::TimeDelta::FromMilliseconds(5);
   } else if (available_frames < kTargetFramesAvailable) {
     // Schedule the next write for the moment when the available buffer of the
     // sound card hits |kTargetFramesAvailable|.
-    next_fill_time = FramesToTimeDelta(
+    next_fill_time = AudioTimestampHelper::FramesToTime(
         kTargetFramesAvailable - available_frames, sample_rate_);
   } else if (!source_exhausted) {
     // The sound card has |kTargetFramesAvailable| or more frames available.
     // Invoke the next write immediately to avoid underrun.
     next_fill_time = base::TimeDelta();
   } else {
     // The sound card has frames available, but our source is exhausted, so
     // avoid busy looping by delaying a bit.
     next_fill_time = base::TimeDelta::FromMilliseconds(10);
   }
 
   task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&AlsaPcmOutputStream::WriteTask, weak_factory_.GetWeakPtr()),
       next_fill_time);
 }
 
-// static
-base::TimeDelta AlsaPcmOutputStream::FramesToTimeDelta(int frames,
-                                                       double sample_rate) {
-  return base::TimeDelta::FromMicroseconds(
-      frames * base::Time::kMicrosecondsPerSecond / sample_rate);
-}
-
 std::string AlsaPcmOutputStream::FindDeviceForChannels(uint32_t channels) {
   // Constants specified by the ALSA API for device hints.
   static const int kGetAllDevices = -1;
   static const char kPcmInterfaceName[] = "pcm";
   static const char kIoHintName[] = "IOID";
   static const char kNameHintName[] = "NAME";
 
   const char* wanted_device = GuessSpecificDeviceName(channels);
   if (!wanted_device)
     return std::string();
@@ skipping 216 matching lines @@
   } else {
     state_ = to;
   }
   return state_;
 }
 
 AlsaPcmOutputStream::InternalState AlsaPcmOutputStream::state() {
   return state_;
 }
 
-int AlsaPcmOutputStream::RunDataCallback(AudioBus* audio_bus,
-                                         uint32_t total_bytes_delay) {
+int AlsaPcmOutputStream::RunDataCallback(base::TimeDelta delay,
+                                         base::TimeTicks delay_timestamp,
+                                         AudioBus* audio_bus) {
   TRACE_EVENT0("audio", "AlsaPcmOutputStream::RunDataCallback");
 
   if (source_callback_)
-    return source_callback_->OnMoreData(audio_bus, total_bytes_delay, 0);
+    return source_callback_->OnMoreData(delay, delay_timestamp, 0, audio_bus);
 
   return 0;
 }
 
 void AlsaPcmOutputStream::RunErrorCallback(int code) {
   if (source_callback_)
     source_callback_->OnError(this);
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::set_source_callback(AudioSourceCallback* callback) {
   DCHECK(CalledOnValidThread());
   source_callback_ = callback;
 }
 
 }  // namespace media