Pass decoded picture size from VDA to client

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 35 matching lines @@
 GpuVideoDecoder::PendingDecoderBuffer::PendingDecoderBuffer(
     SHMBuffer* s,
     const scoped_refptr<DecoderBuffer>& b,
     const DecodeCB& done_cb)
     : shm_buffer(s), buffer(b), done_cb(done_cb) {
 }
 
 GpuVideoDecoder::PendingDecoderBuffer::~PendingDecoderBuffer() {}
 
 GpuVideoDecoder::BufferData::BufferData(
-    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) {
+    int32 bbid, base::TimeDelta ts)
+    : bitstream_buffer_id(bbid), timestamp(ts) {
 }
 
 GpuVideoDecoder::BufferData::~BufferData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
     const scoped_refptr<GpuVideoAcceleratorFactories>& factories,
     const scoped_refptr<MediaLog>& media_log)
     : needs_bitstream_conversion_(false),
       factories_(factories),
       state_(kNormal),
@@ skipping 200 matching lines @@
   DCHECK_LE(static_cast<int>(bitstream_buffers_in_decoder_.size()),
             kMaxInFlightDecodes);
   RecordBufferData(bitstream_buffer, *buffer.get());
 
   vda_->Decode(bitstream_buffer);
 }
 
 void GpuVideoDecoder::RecordBufferData(const BitstreamBuffer& bitstream_buffer,
                                        const DecoderBuffer& buffer) {
   input_buffer_data_.push_front(BufferData(bitstream_buffer.id(),
-                                           buffer.timestamp(),
-                                           config_.visible_rect(),
-                                           config_.natural_size()));
+                                           buffer.timestamp()));
   // 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) {
+void GpuVideoDecoder::GetBufferData(int32 id, base::TimeDelta* timestamp) {
   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::NeedsBitstreamConversion() const {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   return needs_bitstream_conversion_;
 }
 
@@ skipping 104 matching lines @@
       assigned_picture_buffers_.find(picture.picture_buffer_id());
   if (it == assigned_picture_buffers_.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, &visible_rect,
-                &natural_size);
+  gfx::Rect visible_rect(picture.size());

[Pawel Osciak, 2014/08/10 00:02:22]

Please do not make any changes to this class. Unfortunately some of the VDAs,
notably DXVA and AVDA, don't distinguish between visible size and coded size, so
this would result in us using coded size for them here, which is not what we
want. We should keep using config information.

The only advantage of using the VDA-provided size here over the config size
would be if we were decoding a resolution changing stream without a container
(or with a broken container), but the former does not happen when we use this
class anyway, and the latter we can't help given the above.

Please only document that we are dropping picture.size() for the above reasons:
"Some of the VDAs don't support and thus don't provide us with visible size,
passing coded size instead, so drop this and use config information instead."

[kcwu, 2014/08/12 04:48:06]

Done.

+  gfx::Size natural_size(picture.size());
+  GetBufferData(picture.bitstream_buffer_id(), &timestamp);
   DCHECK(decoder_texture_target_);
 
   scoped_refptr<VideoFrame> frame(VideoFrame::WrapNativeTexture(
       make_scoped_ptr(new gpu::MailboxHolder(
           pb.texture_mailbox(), decoder_texture_target_, 0 /* sync_point */)),
       BindToCurrentLoop(base::Bind(&GpuVideoDecoder::ReleaseMailbox,
                                    weak_factory_.GetWeakPtr(),
                                    factories_,
                                    picture.picture_buffer_id(),
                                    pb.texture_id())),
@@ skipping 161 matching lines @@
   DLOG(ERROR) << "VDA Error: " << error;
   DestroyVDA();
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media