Make more media APIs aware of |delay| and |delay_timestamp|

media/audio/audio_output_device.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_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_output_controller.h"
+#include "media/base/audio_timestamp_helper.h"
 #include "media/base/limits.h"
 
 namespace media {
 
 // Takes care of invoking the render callback on the audio thread.
 // An instance of this class is created for each capture stream in
 // OnStreamCreated().
 class AudioOutputDevice::AudioThreadCallback
     : public AudioDeviceThread::Callback {
  public:
   AudioThreadCallback(const AudioParameters& audio_parameters,
                       base::SharedMemoryHandle memory,
                       int memory_length,
                       AudioRendererSink::RenderCallback* render_callback);
   ~AudioThreadCallback() override;
 
   void MapSharedMemory() override;
 
   // Called whenever we receive notifications about pending data.
-  void Process(uint32_t pending_data) override;
+  void Process(int64_t pending_data, base::TimeTicks delay_timestamp) override;
 
   // Returns whether the current thread is the audio device thread or not.
   // Will always return true if DCHECKs are not enabled.
   bool CurrentThreadIsAudioDeviceThread();
 
  private:
-  const int bytes_per_frame_;
+  const int frame_rate_;
   AudioRendererSink::RenderCallback* render_callback_;
   std::unique_ptr<AudioBus> output_bus_;
   uint64_t callback_num_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
 };
 
 AudioOutputDevice::AudioOutputDevice(
     std::unique_ptr<AudioOutputIPC> ipc,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
@@ skipping 364 matching lines @@
 }
 
 // AudioOutputDevice::AudioThreadCallback
 
 AudioOutputDevice::AudioThreadCallback::AudioThreadCallback(
     const AudioParameters& audio_parameters,
     base::SharedMemoryHandle memory,
     int memory_length,
     AudioRendererSink::RenderCallback* render_callback)
     : AudioDeviceThread::Callback(audio_parameters, memory, memory_length, 1),
-      bytes_per_frame_(audio_parameters.GetBytesPerFrame()),
+      frame_rate_(audio_parameters.sample_rate()),
       render_callback_(render_callback),
       callback_num_(0) {}
 
 AudioOutputDevice::AudioThreadCallback::~AudioThreadCallback() {
 }
 
 void AudioOutputDevice::AudioThreadCallback::MapSharedMemory() {
   CHECK_EQ(total_segments_, 1);
   CHECK(shared_memory_.Map(memory_length_));
   DCHECK_EQ(static_cast<size_t>(memory_length_),
             sizeof(AudioOutputBufferParameters) +
                 AudioBus::CalculateMemorySize(audio_parameters_));
 
   AudioOutputBuffer* buffer =
       reinterpret_cast<AudioOutputBuffer*>(shared_memory_.memory());
   output_bus_ = AudioBus::WrapMemory(audio_parameters_, buffer->audio);
 }
 
 // Called whenever we receive notifications about pending data.
-void AudioOutputDevice::AudioThreadCallback::Process(uint32_t pending_data) {
-  // Convert the number of pending bytes in the render buffer into frames.
-  double frames_delayed = static_cast<double>(pending_data) / bytes_per_frame_;
+void AudioOutputDevice::AudioThreadCallback::Process(
+    int64_t pending_data,
+    base::TimeTicks delay_timestamp) {
+  base::TimeDelta delay = base::TimeDelta::FromInternalValue(pending_data);

[miu, 2016/10/23 01:19:16]

Instead of passing pending_data as an int64_t, could you pass it as a
base::TimeDelta? IMHO, we should try to keep all the (de)serialization logic
where the shared memory is owned/read.

[Mikhail, 2016/10/24 19:50:24]

The reason for keeping this is 'AudioInputDevice::AudioThreadCallback::Process'
(pls see comments above).

 
   callback_num_++;
   TRACE_EVENT1("audio", "AudioOutputDevice::FireRenderCallback",
                "callback_num", callback_num_);
 
   // When playback starts, we get an immediate callback to Process to make sure
   // that we have some data, we'll get another one after the device is awake and
   // ingesting data, which is what we want to track with this trace.
   if (callback_num_ == 2) {
     TRACE_EVENT_ASYNC_END0("audio", "StartingPlayback", this);
   }
 
   // Read and reset the number of frames skipped.
   AudioOutputBuffer* buffer =
       reinterpret_cast<AudioOutputBuffer*>(shared_memory_.memory());
   uint32_t frames_skipped = buffer->params.frames_skipped;
   buffer->params.frames_skipped = 0;
 
-  DVLOG(4) << __func__ << " pending_data:" << pending_data
-           << " frames_delayed(pre-round):" << frames_delayed
+  DVLOG(4) << __func__ << " delay:" << delay
            << " frames_skipped:" << frames_skipped;
 
+  // TODO(Mikhail) : Now all clients expect that bus duration included to
+  // |delay|. We should reconsider this.
+  const int frames = output_bus_->frames();

[chcunningham, 2016/10/21 18:19:47]

I'm confused. Why are we doing this here instead of audio_output_controller
where it was previously done?

[Mikhail, 2016/10/24 19:50:24]

Indeed. Thanks for noticing!

+  delay += AudioTimestampHelper::FramesToTime(frames, frame_rate_);
+
   // Update the audio-delay measurement, inform about the number of skipped
   // frames, and ask client to render audio.  Since |output_bus_| is wrapping
   // the shared memory the Render() call is writing directly into the shared
   // memory.
-  render_callback_->Render(output_bus_.get(), std::round(frames_delayed),
+  render_callback_->Render(output_bus_.get(), delay, delay_timestamp,
                            frames_skipped);
 }
 
 bool AudioOutputDevice::AudioThreadCallback::
     CurrentThreadIsAudioDeviceThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace media