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

media/filters/ffmpeg_video_decoder.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/ffmpeg_video_decoder.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 42 matching lines @@
   return decode_threads;
 }
 
 FFmpegVideoDecoder::FFmpegVideoDecoder(
     const base::Callback<MessageLoop*()>& message_loop_cb)
     : message_loop_factory_cb_(message_loop_cb),
       message_loop_(NULL),
       state_(kUninitialized),
       codec_context_(NULL),
       av_frame_(NULL),
-      frame_rate_numerator_(0),
-      frame_rate_denominator_(0),
       decryptor_(NULL) {
 }
 
 int FFmpegVideoDecoder::GetVideoBuffer(AVCodecContext* codec_context,
                                        AVFrame* frame) {
   // Don't use |codec_context_| here! With threaded decoding,
   // it will contain unsynchronized width/height/pix_fmt values,
   // whereas |codec_context| contains the current threads's
   // updated width/height/pix_fmt, which can change for adaptive
   // content.
   VideoFrame::Format format = PixelFormatToVideoFormat(codec_context->pix_fmt);
   if (format == VideoFrame::INVALID)
     return AVERROR(EINVAL);
   DCHECK(format == VideoFrame::YV12 || format == VideoFrame::YV16);
 
   int width = codec_context->width;
   int height = codec_context->height;
   int ret;
   if ((ret = av_image_check_size(width, height, 0, NULL)) < 0)
     return ret;
 
   scoped_refptr<VideoFrame> video_frame =
-      VideoFrame::CreateFrame(format, width, height,
-                              kNoTimestamp(), kNoTimestamp());
+      VideoFrame::CreateFrame(format, width, height, kNoTimestamp());
 
   for (int i = 0; i < 3; i++) {
     frame->base[i] = video_frame->data(i);
     frame->data[i] = video_frame->data(i);
     frame->linesize[i] = video_frame->stride(i);
   }
 
   frame->opaque = video_frame.release();
   frame->type = FF_BUFFER_TYPE_USER;
   frame->pkt_pts = codec_context->pkt ? codec_context->pkt->pts :
@@ skipping 83 matching lines @@
 
   if (avcodec_open2(codec_context_, codec, NULL) < 0) {
     status_cb.Run(PIPELINE_ERROR_DECODE);
     return;
   }
 
   // Success!
   state_ = kNormal;
   av_frame_ = avcodec_alloc_frame();
   natural_size_ = config.natural_size();
-  frame_rate_numerator_ = config.frame_rate_numerator();
-  frame_rate_denominator_ = config.frame_rate_denominator();
   status_cb.Run(PIPELINE_OK);
 }
 
 void FFmpegVideoDecoder::Read(const ReadCB& read_cb) {
   // Complete operation asynchronously on different stack of execution as per
   // the API contract of VideoDecoder::Read()
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &FFmpegVideoDecoder::DoRead, this, read_cb));
 }
 
@@ skipping 294 matching lines @@
     *video_frame = NULL;
     return false;
   }
 
   if (!av_frame_->opaque) {
     LOG(ERROR) << "VideoFrame object associated with frame data not set.";
     return false;
   }
   *video_frame = static_cast<VideoFrame*>(av_frame_->opaque);
 
-  if (frame_rate_numerator_ == 0) {
-    // A framerate of zero indicates that no timing information was available
-    // during initial stream demuxing, and that the framerate should be inferred
-    // from the first frame's duration.
-    frame_rate_numerator_ = buffer->GetDuration().InMicroseconds();
-    frame_rate_denominator_ = base::Time::kMicrosecondsPerSecond;
-  }
-
-  // Determine timestamp and calculate the duration based on the repeat
-  // picture count. According to FFmpeg docs, the total duration can be
-  // calculated as follows:
-  //   fps = 1 / time_base
-  //
-  //   duration = (1 / fps) + (repeat_pict) / (2 * fps)
-  //            = (2 + repeat_pict) / (2 * fps)
-  //            = (2 + repeat_pict) / (2 * (1 / time_base))
-  DCHECK_LE(av_frame_->repeat_pict, 2);  // Sanity check.
-  AVRational doubled_time_base;
-  doubled_time_base.num = frame_rate_denominator_;
-  doubled_time_base.den = frame_rate_numerator_ * 2;
-
   (*video_frame)->SetTimestamp(
       base::TimeDelta::FromMicroseconds(av_frame_->reordered_opaque));
-  (*video_frame)->SetDuration(
-      ConvertFromTimeBase(doubled_time_base, 2 + av_frame_->repeat_pict));
 
   return true;
 }
 
 void FFmpegVideoDecoder::ReleaseFFmpegResources() {
   if (codec_context_) {
     av_free(codec_context_->extradata);
     avcodec_close(codec_context_);
     av_free(codec_context_);
     codec_context_ = NULL;
   }
   if (av_frame_) {
     av_free(av_frame_);
     av_frame_ = NULL;
   }
 }
 
 }  // namespace media