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

media/filters/gpu_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/gpu_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 18 matching lines @@
 
 GpuVideoDecoder::SHMBuffer::~SHMBuffer() {}
 
 GpuVideoDecoder::BufferPair::BufferPair(
     SHMBuffer* s, const scoped_refptr<DecoderBuffer>& b)
     : shm_buffer(s), buffer(b) {
 }
 
 GpuVideoDecoder::BufferPair::~BufferPair() {}
 
-GpuVideoDecoder::BufferTimeData::BufferTimeData(
-    int32 bbid, base::TimeDelta ts, base::TimeDelta dur)
-    : bitstream_buffer_id(bbid), timestamp(ts), duration(dur) {
-}
-
-GpuVideoDecoder::BufferTimeData::~BufferTimeData() {}
-
 GpuVideoDecoder::GpuVideoDecoder(
     MessageLoop* message_loop,
     MessageLoop* vda_loop,
     const scoped_refptr<Factories>& factories)
     : gvd_loop_proxy_(message_loop->message_loop_proxy()),
       vda_loop_proxy_(vda_loop->message_loop_proxy()),
       factories_(factories),
       state_(kNormal),
       demuxer_read_in_progress_(false),
       decoder_texture_target_(0),
@@ skipping 100 matching lines @@
     return;
   }
 
   demuxer_stream_ = stream;
   statistics_cb_ = statistics_cb;
 
   if (config.codec() == kCodecH264)
     demuxer_stream_->EnableBitstreamConverter();
 
   natural_size_ = config.natural_size();
-  config_frame_duration_ = GetFrameDuration(config);
 
   DVLOG(1) << "GpuVideoDecoder::Initialize() succeeded.";
   vda_loop_proxy_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&GpuVideoDecoder::SetVDA, this, vda),
       base::Bind(status_cb, PIPELINE_OK));
 }
 
 void GpuVideoDecoder::SetVDA(VideoDecodeAccelerator* vda) {
   DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
@@ skipping 90 matching lines @@
       bitstream_buffer.id(), BufferPair(shm_buffer, buffer))).second;
   DCHECK(inserted);
   RecordBufferTimeData(bitstream_buffer, *buffer);
 
   vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::Decode, weak_vda_, bitstream_buffer));
 }
 
 void GpuVideoDecoder::RecordBufferTimeData(
     const BitstreamBuffer& bitstream_buffer, const Buffer& buffer) {
-  base::TimeDelta duration = buffer.GetDuration();
-  if (duration == base::TimeDelta())
-    duration = config_frame_duration_;
   input_buffer_time_data_.push_front(BufferTimeData(
-      bitstream_buffer.id(), buffer.GetTimestamp(), duration));
+      bitstream_buffer.id(), buffer.GetTimestamp()));
   // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
   // that's too small for some pathological B-frame test videos.  The cost of
   // using too-high a value is low (192 bits per extra slot).
   static const size_t kMaxInputBufferTimeDataSize = 128;
   // Pop from the back of the list, because that's the oldest and least likely
   // to be useful in the future data.
   if (input_buffer_time_data_.size() > kMaxInputBufferTimeDataSize)
     input_buffer_time_data_.pop_back();
 }
 
-void GpuVideoDecoder::GetBufferTimeData(
-    int32 id, base::TimeDelta* timestamp, base::TimeDelta* duration) {
-  // If all else fails later, at least we can set a default duration if there
-  // was one in the config.
-  *duration = config_frame_duration_;
+base::TimeDelta GpuVideoDecoder::GetBufferTimeData(int32 id) {
   for (std::list<BufferTimeData>::const_iterator it =
            input_buffer_time_data_.begin(); it != input_buffer_time_data_.end();
        ++it) {
-    if (it->bitstream_buffer_id != id)
+    if (it->first != id)
       continue;
-    *timestamp = it->timestamp;
-    *duration = it->duration;
-    return;
+    return it->second;

[Ami GONE FROM CHROMIUM, 2012/07/31 18:44:42]

now that you're returning the value it'd be clearer as:
if (it->first == id)
  return it->second;

[acolwell GONE FROM CHROMIUM, 2012/07/31 19:23:44]

Done.

   }
   NOTREACHED() << "Missing bitstreambuffer id: " << id;
+  return kNoTimestamp();
 }
 
 const gfx::Size& GpuVideoDecoder::natural_size() {
   return natural_size_;
 }
 
 bool GpuVideoDecoder::HasAlpha() const {
   return true;
 }
 
@@ skipping 69 matching lines @@
   std::map<int32, PictureBuffer>::iterator it =
       picture_buffers_in_decoder_.find(picture.picture_buffer_id());
   if (it == picture_buffers_in_decoder_.end()) {
     NOTREACHED() << "Missing picture buffer: " << picture.picture_buffer_id();
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   const PictureBuffer& pb = it->second;
 
   // Update frame's timestamp.
-  base::TimeDelta timestamp;
-  base::TimeDelta duration;
-  GetBufferTimeData(picture.bitstream_buffer_id(), &timestamp, &duration);
-
+  base::TimeDelta timestamp = GetBufferTimeData(picture.bitstream_buffer_id());
   DCHECK(decoder_texture_target_);
   scoped_refptr<VideoFrame> frame(VideoFrame::WrapNativeTexture(
       pb.texture_id(), decoder_texture_target_, pb.size().width(),
-      pb.size().height(), timestamp, duration,
+      pb.size().height(), timestamp,
       base::Bind(&GpuVideoDecoder::ReusePictureBuffer, this,
                  picture.picture_buffer_id())));
 
   EnqueueFrameAndTriggerFrameDelivery(frame);
 }
 
 void GpuVideoDecoder::EnqueueFrameAndTriggerFrameDelivery(
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
@@ skipping 153 matching lines @@
 
   error_occured_ = true;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media