Plumb through cropped output size for VideoFrame

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/cpu.h"
 #include "base/message_loop.h"
@@ skipping 25 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) {
+    int32 bbid, base::TimeDelta ts, const gfx::Rect& vr, const gfx::Size& ns)
+    : bitstream_buffer_id(bbid), timestamp(ts), visible_rect(vr),
+      natural_size(ns) {
 }
 
 GpuVideoDecoder::BufferData::~BufferData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
     const MessageLoopFactoryCB& message_loop_factory_cb,
     const scoped_refptr<base::MessageLoopProxy>& vda_loop_proxy,
     const scoped_refptr<Factories>& factories)
     : message_loop_factory_cb_(message_loop_factory_cb),
       gvd_loop_proxy_(NULL),
@@ skipping 264 matching lines @@
       &VideoDecodeAccelerator::Decode, weak_vda_, bitstream_buffer));
 
   if (CanMoreDecodeWorkBeDone())
     EnsureDemuxOrDecode();
 }
 
 void GpuVideoDecoder::RecordBufferData(
     const BitstreamBuffer& bitstream_buffer, const Buffer& buffer) {
   input_buffer_data_.push_front(BufferData(
       bitstream_buffer.id(), buffer.GetTimestamp(),
+      demuxer_stream_->video_decoder_config().visible_rect(),
       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 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_data_.size() > kMaxInputBufferDataSize)
     input_buffer_data_.pop_back();
 }
 
 void GpuVideoDecoder::GetBufferData(int32 id, base::TimeDelta* timestamp,
+                                    gfx::Rect* visible_rect,
                                     gfx::Size* natural_size) {
   for (std::list<BufferData>::const_iterator it =
            input_buffer_data_.begin(); it != input_buffer_data_.end();
        ++it) {
     if (it->bitstream_buffer_id != id)
       continue;
     *timestamp = it->timestamp;
+    *visible_rect = it->visible_rect;
     *natural_size = it->natural_size;
     return;
   }
   NOTREACHED() << "Missing bitstreambuffer id: " << id;
 }
 
 bool GpuVideoDecoder::HasAlpha() const {
   return true;
 }
 
@@ skipping 61 matching lines @@
       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;
+  gfx::Rect visible_rect;
   gfx::Size natural_size;
-  GetBufferData(picture.bitstream_buffer_id(), &timestamp, &natural_size);
+  GetBufferData(picture.bitstream_buffer_id(), &timestamp, &visible_rect,
+                &natural_size);
   DCHECK(decoder_texture_target_);
-  scoped_refptr<VideoFrame> frame(VideoFrame::WrapNativeTexture(
-      pb.texture_id(), decoder_texture_target_, pb.size(), natural_size,
-      timestamp,
-      base::Bind(&Factories::ReadPixels, factories_, pb.texture_id(),
-                 decoder_texture_target_, pb.size()),
-      base::Bind(&GpuVideoDecoder::ReusePictureBuffer, this,
-                 picture.picture_buffer_id())));
+  scoped_refptr<VideoFrame> frame(
+      VideoFrame::WrapNativeTexture(
+          pb.texture_id(), decoder_texture_target_, pb.size(), visible_rect,
+          natural_size, timestamp,
+          base::Bind(&Factories::ReadPixels, factories_, pb.texture_id(),
+                     decoder_texture_target_, pb.size()),
+          base::Bind(&GpuVideoDecoder::ReusePictureBuffer, this,
+                     picture.picture_buffer_id())));
 
   EnqueueFrameAndTriggerFrameDelivery(frame);
 }
 
 void GpuVideoDecoder::EnqueueFrameAndTriggerFrameDelivery(
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   // During a pending vda->Reset(), we don't accumulate frames.  Drop it on the
   // floor and return.
@@ skipping 155 matching lines @@
 
   error_occured_ = true;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media