Express audio delay more precisely in frames rather than milliseconds.

media/renderers/audio_renderer_impl.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/renderers/audio_renderer_impl.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
@@ skipping 616 matching lines @@
 }
 
 bool AudioRendererImpl::IsBeforeStartTime(
     const scoped_refptr<AudioBuffer>& buffer) {
   DCHECK_EQ(state_, kPlaying);
   return buffer.get() && !buffer->end_of_stream() &&
          (buffer->timestamp() + buffer->duration()) < start_timestamp_;
 }
 
 int AudioRendererImpl::Render(AudioBus* audio_bus,
-                              uint32_t audio_delay_milliseconds,
+                              uint32_t frames_delayed,
                               uint32_t frames_skipped) {
-  const int requested_frames = audio_bus->frames();
-  base::TimeDelta playback_delay = base::TimeDelta::FromMilliseconds(
-      audio_delay_milliseconds);
-  const int delay_frames = static_cast<int>(playback_delay.InSecondsF() *
-                                            audio_parameters_.sample_rate());
+  const int frames_requested = audio_bus->frames();
+  DVLOG(4) << __FUNCTION__ << " frames_delayed:" << frames_delayed
+           << " frames_skipped:" << frames_skipped
+           << " frames_requested:" << frames_requested;
+
   int frames_written = 0;
   {
     base::AutoLock auto_lock(lock_);
     last_render_time_ = tick_clock_->NowTicks();
 
     if (!stop_rendering_time_.is_null()) {
       audio_clock_->CompensateForSuspendedWrites(
-          last_render_time_ - stop_rendering_time_, delay_frames);
+          last_render_time_ - stop_rendering_time_, frames_delayed);
       stop_rendering_time_ = base::TimeTicks();
     }
 
     // Ensure Stop() hasn't destroyed our |algorithm_| on the pipeline thread.
     if (!algorithm_) {
-      audio_clock_->WroteAudio(
-          0, requested_frames, delay_frames, playback_rate_);
+      audio_clock_->WroteAudio(0, frames_requested, frames_delayed,
+                               playback_rate_);
       return 0;
     }
 
     if (playback_rate_ == 0) {
-      audio_clock_->WroteAudio(
-          0, requested_frames, delay_frames, playback_rate_);
+      audio_clock_->WroteAudio(0, frames_requested, frames_delayed,
+                               playback_rate_);
       return 0;
     }
 
     // Mute audio by returning 0 when not playing.
     if (state_ != kPlaying) {
-      audio_clock_->WroteAudio(
-          0, requested_frames, delay_frames, playback_rate_);
+      audio_clock_->WroteAudio(0, frames_requested, frames_delayed,
+                               playback_rate_);
       return 0;
     }
 
     // Delay playback by writing silence if we haven't reached the first
     // timestamp yet; this can occur if the video starts before the audio.
     if (algorithm_->frames_buffered() > 0) {
       CHECK_NE(first_packet_timestamp_, kNoTimestamp());
       CHECK_GE(first_packet_timestamp_, base::TimeDelta());
       const base::TimeDelta play_delay =
           first_packet_timestamp_ - audio_clock_->back_timestamp();
       CHECK_LT(play_delay.InSeconds(), 1000)
           << "first_packet_timestamp_ = " << first_packet_timestamp_
           << ", audio_clock_->back_timestamp() = "
           << audio_clock_->back_timestamp();
       if (play_delay > base::TimeDelta()) {
         DCHECK_EQ(frames_written, 0);
         frames_written =
             std::min(static_cast<int>(play_delay.InSecondsF() *
                                       audio_parameters_.sample_rate()),
-                     requested_frames);
+                     frames_requested);
         audio_bus->ZeroFramesPartial(0, frames_written);
       }
 
       // If there's any space left, actually render the audio; this is where the
       // aural magic happens.
-      if (frames_written < requested_frames) {
+      if (frames_written < frames_requested) {
         frames_written += algorithm_->FillBuffer(
-            audio_bus, frames_written, requested_frames - frames_written,
+            audio_bus, frames_written, frames_requested - frames_written,
             playback_rate_);
       }
     }
 
     // We use the following conditions to determine end of playback:
     //   1) Algorithm can not fill the audio callback buffer
     //   2) We received an end of stream buffer
     //   3) We haven't already signalled that we've ended
     //   4) We've played all known audio data sent to hardware
     //
@@ skipping 10 matching lines @@
     // data has ended.
     //
     // That being said, we don't want to advance time when underflowed as we
     // know more decoded frames will eventually arrive. If we did, we would
     // throw things out of sync when said decoded frames arrive.
     int frames_after_end_of_stream = 0;
     if (frames_written == 0) {
       if (received_end_of_stream_) {
         if (ended_timestamp_ == kInfiniteDuration())
           ended_timestamp_ = audio_clock_->back_timestamp();
-        frames_after_end_of_stream = requested_frames;
+        frames_after_end_of_stream = frames_requested;
       } else if (state_ == kPlaying &&
                  buffering_state_ != BUFFERING_HAVE_NOTHING) {
         algorithm_->IncreaseQueueCapacity();
         SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
       }
     }
 
     audio_clock_->WroteAudio(frames_written + frames_after_end_of_stream,
-                             requested_frames,
-                             delay_frames,
-                             playback_rate_);
+                             frames_requested, frames_delayed, playback_rate_);
 
     if (CanRead_Locked()) {
       task_runner_->PostTask(FROM_HERE,
                              base::Bind(&AudioRendererImpl::AttemptRead,
                                         weak_factory_.GetWeakPtr()));
     }
 
     if (audio_clock_->front_timestamp() >= ended_timestamp_ &&
         !rendered_end_of_stream_) {
       rendered_end_of_stream_ = true;
       task_runner_->PostTask(FROM_HERE, ended_cb_);
     }
   }
 
-  DCHECK_LE(frames_written, requested_frames);
+  DCHECK_LE(frames_written, frames_requested);
   return frames_written;
 }
 
 void AudioRendererImpl::OnRenderError() {
   // UMA data tells us this happens ~0.01% of the time. Trigger an error instead
   // of trying to gracefully fall back to a fake sink. It's very likely
   // OnRenderError() should be removed and the audio stack handle errors without
   // notifying clients. See http://crbug.com/234708 for details.
   HistogramRendererEvent(RENDER_ERROR);
 
@@ skipping 64 matching lines @@
            << buffering_state;
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(buffering_state_cb_, buffering_state_));
 }
 
 }  // namespace media