Pass decoded picture size from VDA to client

content/renderer/media/rtc_video_decoder.cc

 // Copyright 2013 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 "content/renderer/media/rtc_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 43 matching lines @@
   const size_t size;
 };
 
 RTCVideoDecoder::SHMBuffer::SHMBuffer(base::SharedMemory* shm, size_t size)
     : shm(shm), size(size) {}
 
 RTCVideoDecoder::SHMBuffer::~SHMBuffer() { shm->Close(); }
 
 RTCVideoDecoder::BufferData::BufferData(int32 bitstream_buffer_id,
                                         uint32_t timestamp,
-                                        int width,
-                                        int height,
                                         size_t size)
     : bitstream_buffer_id(bitstream_buffer_id),
       timestamp(timestamp),
-      width(width),
-      height(height),
       size(size) {}
 
 RTCVideoDecoder::BufferData::BufferData() {}
 
 RTCVideoDecoder::BufferData::~BufferData() {}
 
 RTCVideoDecoder::RTCVideoDecoder(
     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories)
     : factories_(factories),
       decoder_texture_target_(0),
@@ skipping 120 matching lines @@
   // change gracefully need to have their clients cover for them, and we do that
   // here.
 #ifdef ANDROID
   const bool kVDACanHandleMidstreamResize = false;
 #else
   const bool kVDACanHandleMidstreamResize = true;
 #endif
 
   bool need_to_reset_for_midstream_resize = false;
   if (inputImage._frameType == webrtc::kKeyFrame) {
-    DVLOG(2) << "Got key frame. size=" << inputImage._encodedWidth << "x"
-             << inputImage._encodedHeight;
-    gfx::Size prev_frame_size = frame_size_;
-    frame_size_.SetSize(inputImage._encodedWidth, inputImage._encodedHeight);
-    if (!kVDACanHandleMidstreamResize && !prev_frame_size.IsEmpty() &&
-        prev_frame_size != frame_size_) {
-      need_to_reset_for_midstream_resize = true;
+    // TODO(kcwu): What if VDA cannot handle mid stream resize and
+    // encoded size is unknown??

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

s/??/?/

Not sure what you mean here, VDA will always return size on PictureReady, be it
visible or (wrongly) coded size. Can you explain what you have in mind here
please?

[kcwu, 2014/08/12 03:50:47]

1. Should I still use client provided size if available? 
2. According to line 200 and 214, on Android, it doesn't support mid stream
resize. So it relays on client "encoded size" to handle midstream resize. This
behavior will not work if encoded size is unknown.

[Pawel Osciak, 2014/08/12 04:05:07]

Given that some vdas can't provide visible size, I'd say yes, it should take
priority.
I think this patch doesn't change this though, because if we use the size
returned from vda on PictureReady instead, it would be too late anyway if it
couldn't handle the resize?

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

Okay, then should I leave comment here to indicate this problem? (rephrased)

[Pawel Osciak, 2014/08/12 04:59:24]

Yes please.

+    if (inputImage._encodedWidth && inputImage._encodedHeight) {
+      DVLOG(2) << "Got key frame. size=" << inputImage._encodedWidth << "x"
+               << inputImage._encodedHeight;
+      gfx::Size prev_frame_size = frame_size_;
+      frame_size_.SetSize(inputImage._encodedWidth, inputImage._encodedHeight);
+      if (!kVDACanHandleMidstreamResize && !prev_frame_size.IsEmpty() &&
+          prev_frame_size != frame_size_) {
+        need_to_reset_for_midstream_resize = true;
+      }
     }
   } else if (IsFirstBufferAfterReset(next_bitstream_buffer_id_,
                                      reset_bitstream_buffer_id_)) {
     // TODO(wuchengli): VDA should handle it. Remove this when
     // http://crosbug.com/p/21913 is fixed.
     DVLOG(1) << "The first frame should be a key frame. Drop this.";
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   // Create buffer metadata.
   BufferData buffer_data(next_bitstream_buffer_id_,
                          inputImage._timeStamp,
-                         frame_size_.width(),
-                         frame_size_.height(),
                          inputImage._length);
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & ID_LAST;
 
   // If a shared memory segment is available, there are no pending buffers, and
   // this isn't a mid-stream resolution change, then send the buffer for decode
   // immediately. Otherwise, save the buffer in the queue for later decode.
   scoped_ptr<SHMBuffer> shm_buffer;
   if (!need_to_reset_for_midstream_resize && pending_buffers_.size() == 0)
     shm_buffer = GetSHM_Locked(inputImage._length);
@@ skipping 116 matching lines @@
   std::map<int32, media::PictureBuffer>::iterator it =
       assigned_picture_buffers_.find(picture.picture_buffer_id());
   if (it == assigned_picture_buffers_.end()) {
     NOTREACHED() << "Missing picture buffer: " << picture.picture_buffer_id();
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   const media::PictureBuffer& pb = it->second;
 
   // Create a media::VideoFrame.
-  uint32_t timestamp = 0, width = 0, height = 0;
+  uint32_t timestamp = 0;
   size_t size = 0;
   GetBufferData(
-      picture.bitstream_buffer_id(), &timestamp, &width, &height, &size);
+      picture.bitstream_buffer_id(), &timestamp);
   scoped_refptr<media::VideoFrame> frame =
-      CreateVideoFrame(picture, pb, timestamp, width, height, size);
+      CreateVideoFrame(picture, pb, timestamp, size);
   bool inserted =
       picture_buffers_at_display_.insert(std::make_pair(
                                              picture.picture_buffer_id(),
                                              pb.texture_id())).second;
   DCHECK(inserted);
 
   // Create a WebRTC video frame.
   webrtc::RefCountImpl<NativeHandleImpl>* handle =
       new webrtc::RefCountImpl<NativeHandleImpl>(frame);
-  webrtc::TextureVideoFrame decoded_image(handle, width, height, timestamp, 0);
+  webrtc::TextureVideoFrame decoded_image(handle,
+                                          picture.size().width(),
+                                          picture.size().height(),
+                                          timestamp,
+                                          0);
 
   // Invoke decode callback. WebRTC expects no callback after Reset or Release.
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(decode_complete_callback_ != NULL);
     if (IsBufferAfterReset(picture.bitstream_buffer_id(),
                            reset_bitstream_buffer_id_)) {
       decode_complete_callback_->Decoded(decoded_image);
     }
   }
@@ skipping 23 matching lines @@
                                                        pixels,
                                                        &event)))
     return;
   event.Wait();
 }
 
 scoped_refptr<media::VideoFrame> RTCVideoDecoder::CreateVideoFrame(
     const media::Picture& picture,
     const media::PictureBuffer& pb,
     uint32_t timestamp,
-    uint32_t width,
-    uint32_t height,
     size_t size) {
-  gfx::Rect visible_rect(width, height);
+  gfx::Rect visible_rect(picture.size());
   DCHECK(decoder_texture_target_);
   // Convert timestamp from 90KHz to ms.
   base::TimeDelta timestamp_ms = base::TimeDelta::FromInternalValue(
       base::checked_cast<uint64_t>(timestamp) * 1000 / 90);
   return media::VideoFrame::WrapNativeTexture(
       make_scoped_ptr(new gpu::MailboxHolder(
           pb.texture_mailbox(), decoder_texture_target_, 0)),
       media::BindToCurrentLoop(base::Bind(&RTCVideoDecoder::ReleaseMailbox,
                                           weak_factory_.GetWeakPtr(),
                                           factories_,
@@ skipping 329 matching lines @@
   // 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 RTCVideoDecoder::GetBufferData(int32 bitstream_buffer_id,
-                                    uint32_t* timestamp,
-                                    uint32_t* width,
-                                    uint32_t* height,
-                                    size_t* size) {
+                                    uint32_t* timestamp) {
   for (std::list<BufferData>::iterator it = input_buffer_data_.begin();
        it != input_buffer_data_.end();
        ++it) {
     if (it->bitstream_buffer_id != bitstream_buffer_id)
       continue;
     *timestamp = it->timestamp;
-    *width = it->width;
-    *height = it->height;
     return;
   }
   NOTREACHED() << "Missing bitstream buffer id: " << bitstream_buffer_id;
 }
 
 int32_t RTCVideoDecoder::RecordInitDecodeUMA(int32_t status) {
   // Logging boolean is enough to know if HW decoding has been used. Also,
   // InitDecode is less likely to return an error so enum is not used here.
   bool sample = (status == WEBRTC_VIDEO_CODEC_OK) ? true : false;
   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoDecoderInitDecodeSuccess", sample);
   return status;
 }
 
 void RTCVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace content