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

content/renderer/media/webrtc_audio_renderer.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 "content/renderer/media/webrtc_audio_renderer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 149 matching lines @@
     const std::string& device_id,
     const url::Origin& security_origin)
     : state_(UNINITIALIZED),
       source_render_frame_id_(source_render_frame_id),
       session_id_(session_id),
       signaling_thread_(signaling_thread),
       media_stream_(media_stream),
       source_(NULL),
       play_ref_count_(0),
       start_ref_count_(0),
+      audio_delay_milliseconds_(0),
       sink_params_(kFormat, kChannelLayout, 0, kBitsPerSample, 0),
       output_device_id_(device_id),
       security_origin_(security_origin) {
   WebRtcLogMessage(base::StringPrintf(
       "WAR::WAR. source_render_frame_id=%d, session_id=%d, effects=%i",
       source_render_frame_id, session_id, sink_params_.effects()));
 }
 
 WebRtcAudioRenderer::~WebRtcAudioRenderer() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 80 matching lines @@
   if (state_ == UNINITIALIZED)
     return;
 
   DCHECK(play_ref_count_ == 0 || state_ == PLAYING);
   ++play_ref_count_;
 
   if (state_ != PLAYING) {
     state_ = PLAYING;
 
     if (audio_fifo_) {
-      audio_delay_ = base::TimeDelta();
+      audio_delay_milliseconds_ = 0;
       audio_fifo_->Clear();
     }
   }
 }
 
 void WebRtcAudioRenderer::Pause() {
   DVLOG(1) << "WebRtcAudioRenderer::Pause()";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!playing_state_.playing())
     return;
@@ skipping 112 matching lines @@
     base::AutoLock auto_lock(lock_);
     source_->AudioRendererThreadStopped();
   }
   PrepareSink();
   sink_->Start();
   sink_->Play();  // Not all the sinks play on start.
 
   callback.Run(media::OUTPUT_DEVICE_STATUS_OK);
 }
 
-int WebRtcAudioRenderer::Render(base::TimeDelta delay,
-                                base::TimeTicks delay_timestamp,
-                                int prior_frames_skipped,
-                                media::AudioBus* audio_bus) {
+int WebRtcAudioRenderer::Render(media::AudioBus* audio_bus,
+                                uint32_t frames_delayed,
+                                uint32_t frames_skipped) {
   DCHECK(sink_->CurrentThreadIsRenderingThread());
   base::AutoLock auto_lock(lock_);
   if (!source_)
     return 0;
 
+  // TODO(grunell): Converting from frames to milliseconds will potentially lose
+  // hundreds of microseconds which may cause audio video drift. Update
+  // this class and all usage of render delay msec -> frames (possibly even
+  // using a double type for frames). See http://crbug.com/586540
+  uint32_t audio_delay_milliseconds = static_cast<double>(frames_delayed) *
+                                      base::Time::kMillisecondsPerSecond /
+                                      sink_params_.sample_rate();
+
   DVLOG(2) << "WebRtcAudioRenderer::Render()";
-  DVLOG(2) << "audio_delay: " << delay;
+  DVLOG(2) << "audio_delay_milliseconds: " << audio_delay_milliseconds;
 
-  audio_delay_ = delay;
+  DCHECK_LE(audio_delay_milliseconds, static_cast<uint32_t>(INT_MAX));
+  audio_delay_milliseconds_ = static_cast<int>(audio_delay_milliseconds);
 
   // If there are skipped frames, pull and throw away the same amount. We always
   // pull 10 ms of data from the source (see PrepareSink()), so the fifo is only
   // required if the number of frames to drop doesn't correspond to 10 ms.
-  if (prior_frames_skipped > 0) {
-    const int source_frames_per_buffer = sink_params_.sample_rate() / 100;
-    if (!audio_fifo_ && prior_frames_skipped != source_frames_per_buffer) {
+  if (frames_skipped > 0) {
+    const uint32_t source_frames_per_buffer =
+        static_cast<uint32_t>(sink_params_.sample_rate() / 100);
+    if (!audio_fifo_ && frames_skipped != source_frames_per_buffer) {
       audio_fifo_.reset(new media::AudioPullFifo(
           kChannels, source_frames_per_buffer,
           base::Bind(&WebRtcAudioRenderer::SourceCallback,
                      base::Unretained(this))));
     }
 
     std::unique_ptr<media::AudioBus> drop_bus =
-        media::AudioBus::Create(audio_bus->channels(), prior_frames_skipped);
+        media::AudioBus::Create(audio_bus->channels(), frames_skipped);
     if (audio_fifo_)
       audio_fifo_->Consume(drop_bus.get(), drop_bus->frames());
     else
       SourceCallback(0, drop_bus.get());
   }
 
   // Pull the data we will deliver.
   if (audio_fifo_)
     audio_fifo_->Consume(audio_bus, audio_bus->frames());
   else
     SourceCallback(0, audio_bus);
 
   return (state_ == PLAYING) ? audio_bus->frames() : 0;
 }
 
 void WebRtcAudioRenderer::OnRenderError() {
   NOTIMPLEMENTED();
   LOG(ERROR) << "OnRenderError()";
 }
 
 // Called by AudioPullFifo when more data is necessary.
 void WebRtcAudioRenderer::SourceCallback(
     int fifo_frame_delay, media::AudioBus* audio_bus) {
   DCHECK(sink_->CurrentThreadIsRenderingThread());
   base::TimeTicks start_time = base::TimeTicks::Now();
   DVLOG(2) << "WebRtcAudioRenderer::SourceCallback("
            << fifo_frame_delay << ", "
            << audio_bus->frames() << ")";
 
-  int output_delay_milliseconds = audio_delay_.InMilliseconds();
+  int output_delay_milliseconds = audio_delay_milliseconds_;
   // TODO(grunell): This integer division by sample_rate will cause loss of
   // partial milliseconds, and may cause avsync drift. http://crbug.com/586540
   output_delay_milliseconds += fifo_frame_delay *
                                base::Time::kMillisecondsPerSecond /
                                sink_params_.sample_rate();
   DVLOG(2) << "output_delay_milliseconds: " << output_delay_milliseconds;
 
   // We need to keep render data for the |source_| regardless of |state_|,
   // otherwise the data will be buffered up inside |source_|.
   source_->RenderData(audio_bus, sink_params_.sample_rate(),
@@ skipping 187 matching lines @@
     sink_params_ = new_sink_params;
   }
 
   // Specify the latency info to be passed to the browser side.
   new_sink_params.set_latency_tag(AudioDeviceFactory::GetSourceLatencyType(
       AudioDeviceFactory::AudioDeviceFactory::kSourceWebRtc));
   sink_->Initialize(new_sink_params, this);
 }
 
 }  // namespace content