Remove VideoDecoder::natural_size() & added VideoFrame::natural_size().

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::BufferData::BufferData(
+    int32 bbid, base::TimeDelta ts, const gfx::Size& ns)
+    : bitstream_buffer_id(bbid), timestamp(ts), natural_size(ns) {
+}
+
+GpuVideoDecoder::BufferData::~BufferData() {}
+
 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 99 matching lines @@
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   demuxer_stream_ = stream;
   statistics_cb_ = statistics_cb;
 
   if (config.codec() == kCodecH264)
     demuxer_stream_->EnableBitstreamConverter();
 
-  natural_size_ = config.natural_size();
-
   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());
   vda_.reset(vda);
@@ skipping 50 matching lines @@
         &GpuVideoDecoder::RequestBufferDecode, this, status, buffer));
     return;
   }
   demuxer_read_in_progress_ = false;
 
   if (status != DemuxerStream::kOk) {
     if (pending_read_cb_.is_null())
       return;
 
     // TODO(acolwell): Add support for reinitializing the decoder when
     // |status| == kConfigChanged. For now we just trigger a decode error.

[Ami GONE FROM CHROMIUM, 2012/08/02 17:34:45]

Do we still need this?
IOW if the decoders don't maintain config-related state, and instead query the
demuxer/stream as needed, can kConfigChanged die?

[acolwell GONE FROM CHROMIUM, 2012/08/02 20:20:21]

No. We still need this because the decoders hold state inside them when they are
initialized. This status is needed so that the decoders know when they need to
reinitialize this internal state.

     DecoderStatus decoder_status =
         (status == DemuxerStream::kAborted) ? kOk : kDecodeError;
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         pending_read_cb_, decoder_status, scoped_refptr<VideoFrame>()));
     pending_read_cb_.Reset();
     return;
   }
 
   if (!vda_.get()) {
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
@@ skipping 10 matching lines @@
   }
 
   size_t size = buffer->GetDataSize();
   SHMBuffer* shm_buffer = GetSHM(size);
   memcpy(shm_buffer->shm->memory(), buffer->GetData(), size);
   BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_++, shm_buffer->shm->handle(), size);
   bool inserted = bitstream_buffers_in_decoder_.insert(std::make_pair(
       bitstream_buffer.id(), BufferPair(shm_buffer, buffer))).second;
   DCHECK(inserted);
-  RecordBufferTimeData(bitstream_buffer, *buffer);
+  RecordBufferData(bitstream_buffer, *buffer);
 
   vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::Decode, weak_vda_, bitstream_buffer));
 }
 
-void GpuVideoDecoder::RecordBufferTimeData(
+void GpuVideoDecoder::RecordBufferData(
     const BitstreamBuffer& bitstream_buffer, const Buffer& buffer) {
-  input_buffer_time_data_.push_front(BufferTimeData(
-      bitstream_buffer.id(), buffer.GetTimestamp()));
+  input_buffer_data_.push_front(BufferData(
+      bitstream_buffer.id(), buffer.GetTimestamp(),
+      demuxer_stream_->video_decoder_config().natural_size()));
   // 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;
+  static const size_t kMaxInputBufferDataSize = 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();
+  if (input_buffer_data_.size() > kMaxInputBufferDataSize)
+    input_buffer_data_.pop_back();
 }
 
-base::TimeDelta GpuVideoDecoder::GetBufferTimestamp(int32 id) {
-  for (std::list<BufferTimeData>::const_iterator it =
-           input_buffer_time_data_.begin(); it != input_buffer_time_data_.end();
+void GpuVideoDecoder::GetBufferData(int32 id, base::TimeDelta* timestamp,
+                                    gfx::Size* natural_size) {
+  for (std::list<BufferData>::const_iterator it =
+           input_buffer_data_.begin(); it != input_buffer_data_.end();
        ++it) {
-    if (it->first == id)
-      return it->second;
+    if (it->bitstream_buffer_id != id)
+      continue;
+    *timestamp = it->timestamp;
+    *natural_size = it->natural_size;
+    return;
   }
   NOTREACHED() << "Missing bitstreambuffer id: " << id;
-  return kNoTimestamp();
-}
-
-const gfx::Size& GpuVideoDecoder::natural_size() {
-  return natural_size_;
 }
 
 bool GpuVideoDecoder::HasAlpha() const {
   return true;
 }
 
 void GpuVideoDecoder::PrepareForShutdownHack() {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::PrepareForShutdownHack, this));
@@ skipping 65 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 = GetBufferTimestamp(picture.bitstream_buffer_id());
+  base::TimeDelta timestamp;
+  gfx::Size natural_size;
+  GetBufferData(picture.bitstream_buffer_id(), &timestamp, &natural_size);
   DCHECK(decoder_texture_target_);
   scoped_refptr<VideoFrame> frame(VideoFrame::WrapNativeTexture(
-      pb.texture_id(), decoder_texture_target_, pb.size().width(),
-      pb.size().height(), timestamp,
+      pb.texture_id(), decoder_texture_target_, pb.size(), natural_size,
+      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 124 matching lines @@
     return;
   }
 
   if (!vda_.get())
     return;
 
   DCHECK(ready_video_frames_.empty());
 
   // This needs to happen after the Reset() on vda_ is done to ensure pictures
   // delivered during the reset can find their time data.
-  input_buffer_time_data_.clear();
+  input_buffer_data_.clear();
 
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
 
   if (!pending_read_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
 }
 
 void GpuVideoDecoder::NotifyError(media::VideoDecodeAccelerator::Error error) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::NotifyError, this, error));
     return;
   }
   if (!vda_.get())
     return;
   vda_loop_proxy_->DeleteSoon(FROM_HERE, vda_.release());
   DLOG(ERROR) << "VDA Error: " << error;
 
   error_occured_ = true;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media