Remove VideoDecoderConfig.frame_rate_xxx() & VideoFrame:Get/SetDuration()

media/filters/video_renderer_base.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/filters/video_renderer_base.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/threading/platform_thread.h"
@@ skipping 86 matching lines @@
 void VideoRendererBase::Preroll(base::TimeDelta time,
                                 const PipelineStatusCB& cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kFlushed) << "Must flush prior to prerolling.";
   DCHECK(!cb.is_null());
   DCHECK(preroll_cb_.is_null());
 
   state_ = kPrerolling;
   preroll_cb_ = cb;
   preroll_timestamp_ = time;
+  prerolling_delayed_frame_ = NULL;
   AttemptRead_Locked();
 }
 
 void VideoRendererBase::Initialize(const scoped_refptr<VideoDecoder>& decoder,
                                    const PipelineStatusCB& init_cb,
                                    const StatisticsCB& statistics_cb,
                                    const TimeCB& time_cb,
                                    const NaturalSizeChangedCB& size_changed_cb,
                                    const base::Closure& ended_cb,
                                    const PipelineStatusCB& error_cb,
@@ skipping 297 matching lines @@
     // Abort preroll early for a NULL frame because we won't get more frames.
     // A new preroll will be requested after this one completes so there is no
     // point trying to collect more frames.
     state_ = kPrerolled;
     base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);
     return;
   }
 
   // Discard frames until we reach our desired preroll timestamp.
   if (state_ == kPrerolling && !frame->IsEndOfStream() &&
-      (frame->GetTimestamp() + frame->GetDuration()) <= preroll_timestamp_) {
+      frame->GetTimestamp() <= preroll_timestamp_) {
+    prerolling_delayed_frame_ = frame;
     AttemptRead_Locked();
     return;
   }
 
-  // Adjust the incoming frame if its rendering stop time is past the duration
-  // of the video itself. This is typically the last frame of the video and
-  // occurs if the container specifies a duration that isn't a multiple of the
-  // frame rate.  Another way for this to happen is for the container to state a
-  // smaller duration than the largest packet timestamp.
-  if (!frame->IsEndOfStream()) {
-    base::TimeDelta duration = get_duration_cb_.Run();
-    if (frame->GetTimestamp() > duration)
-      frame->SetTimestamp(duration);
-    if ((frame->GetTimestamp() + frame->GetDuration()) > duration)
-      frame->SetDuration(duration - frame->GetTimestamp());
+  if (prerolling_delayed_frame_) {
+    DCHECK_EQ(state_, kPrerolling);
+    AddReadyFrame(prerolling_delayed_frame_);
+    prerolling_delayed_frame_ = NULL;
   }
 
-  // This one's a keeper! Place it in the ready queue.
-  ready_frames_.push_back(frame);
-  DCHECK_LE(NumFrames_Locked(), limits::kMaxVideoFrames);
-  if (!frame->IsEndOfStream())
-    time_cb_.Run(frame->GetTimestamp() + frame->GetDuration());
-  frame_available_.Signal();
-
+  AddReadyFrame(frame);
   PipelineStatistics statistics;
   statistics.video_frames_decoded = 1;
   statistics_cb_.Run(statistics);
 
   // Always request more decoded video if we have capacity. This serves two
   // purposes:
   //   1) Prerolling while paused
   //   2) Keeps decoding going if video rendering thread starts falling behind
   if (NumFrames_Locked() < limits::kMaxVideoFrames && !frame->IsEndOfStream()) {
     AttemptRead_Locked();
@@ skipping 16 matching lines @@
 
     // ...and we're done prerolling!
     DCHECK(!preroll_cb_.is_null());
     base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);
 
     base::AutoUnlock ul(lock_);
     paint_cb_.Run();
   }
 }
 
+void VideoRendererBase::AddReadyFrame(const scoped_refptr<VideoFrame>& frame) {
+  // Adjust the incoming frame if its rendering stop time is past the duration
+  // of the video itself. This is typically the last frame of the video and
+  // occurs if the container specifies a duration that isn't a multiple of the
+  // frame rate.  Another way for this to happen is for the container to state a
+  // smaller duration than the largest packet timestamp.
+  base::TimeDelta duration = get_duration_cb_.Run();
+  if (frame->GetTimestamp() > duration || frame->IsEndOfStream()) {
+    frame->SetTimestamp(duration);
+  }
+
+  ready_frames_.push_back(frame);
+  DCHECK_LE(NumFrames_Locked(), limits::kMaxVideoFrames);
+  time_cb_.Run(frame->GetTimestamp());
+  frame_available_.Signal();
+}
+
 void VideoRendererBase::AttemptRead_Locked() {
   lock_.AssertAcquired();
   DCHECK_NE(kEnded, state_);
 
   if (pending_read_ ||
       NumFrames_Locked() == limits::kMaxVideoFrames ||
       (!ready_frames_.empty() && ready_frames_.back()->IsEndOfStream()) ||
       state_ == kFlushingDecoder ||
       state_ == kFlushing) {
     return;
   }
 
   pending_read_ = true;
   decoder_->Read(base::Bind(&VideoRendererBase::FrameReady, this));
 }
 
 void VideoRendererBase::OnDecoderFlushDone() {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kFlushingDecoder, state_);
   DCHECK(!pending_read_);
 
   state_ = kFlushing;
   AttemptFlush_Locked();
 }
 
 void VideoRendererBase::AttemptFlush_Locked() {
   lock_.AssertAcquired();
   DCHECK_EQ(kFlushing, state_);
 
-  // Get rid of any ready frames.
+  prerolling_delayed_frame_ = NULL;
   ready_frames_.clear();
 
   if (!pending_paint_ && !pending_read_) {
     state_ = kFlushed;
     current_frame_ = NULL;
     base::ResetAndReturn(&flush_cb_).Run();
   }
 }
 
 base::TimeDelta VideoRendererBase::CalculateSleepDuration(
     const scoped_refptr<VideoFrame>& next_frame,
     float playback_rate) {
   // Determine the current and next presentation timestamps.
   base::TimeDelta now = get_time_cb_.Run();
-  base::TimeDelta this_pts = current_frame_->GetTimestamp();
-  base::TimeDelta next_pts;
-  if (!next_frame->IsEndOfStream()) {
-    next_pts = next_frame->GetTimestamp();
-  } else {
-    next_pts = this_pts + current_frame_->GetDuration();
-  }
+  base::TimeDelta next_pts = next_frame->GetTimestamp();
 
   // Scale our sleep based on the playback rate.
   base::TimeDelta sleep = next_pts - now;
   return base::TimeDelta::FromMicroseconds(
       static_cast<int64>(sleep.InMicroseconds() / playback_rate));
 }
 
 void VideoRendererBase::DoStopOrError_Locked() {
   DCHECK(!pending_paint_);
   DCHECK(!pending_paint_with_last_available_);
   lock_.AssertAcquired();
   current_frame_ = NULL;
   last_available_frame_ = NULL;
   ready_frames_.clear();
 }
 
 int VideoRendererBase::NumFrames_Locked() const {
   lock_.AssertAcquired();
   int outstanding_frames =
       (current_frame_ ? 1 : 0) + (last_available_frame_ ? 1 : 0) +
       (current_frame_ && (current_frame_ == last_available_frame_) ? -1 : 0);
   return ready_frames_.size() + outstanding_frames;
 }
 
 }  // namespace media