Pass decoded picture size from VDA to client

content/renderer/media/rtc_video_decoder.cc

Index: content/renderer/media/rtc_video_decoder.cc
diff --git a/content/renderer/media/rtc_video_decoder.cc b/content/renderer/media/rtc_video_decoder.cc
index 4e4b3199683e7a0f33e37f48fee7360be304417c..0b5ccda45dbeb2c5b7fe5d73459c4adf0827731c 100644
--- a/content/renderer/media/rtc_video_decoder.cc
+++ b/content/renderer/media/rtc_video_decoder.cc
@@ -61,13 +61,9 @@ 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() {}
@@ -208,13 +204,17 @@ int32_t RTCVideoDecoder::Decode(
 
   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_)) {
@@ -227,8 +227,6 @@ int32_t RTCVideoDecoder::Decode(
   // 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;
@@ -365,12 +363,12 @@ void RTCVideoDecoder::PictureReady(const media::Picture& picture) {
   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(),
@@ -380,7 +378,11 @@ void RTCVideoDecoder::PictureReady(const media::Picture& picture) {
   // 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.
   {
@@ -424,10 +426,8 @@ 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(
@@ -777,18 +777,13 @@ void RTCVideoDecoder::RecordBufferData(const BufferData& buffer_data) {
 }
 
 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;