V4L2SVDA/VAAPIVDA: use visible size from decoder and pass to client

media/gpu/vp9_decoder.cc

 // Copyright 2015 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/gpu/vp9_decoder.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 81 matching lines @@
       // This frame header only instructs us to display one of the
       // previously-decoded frames, but has no frame data otherwise. Display
       // and continue decoding subsequent frames.
       size_t frame_to_show = curr_frame_hdr_->frame_to_show_map_idx;
       if (frame_to_show >= ref_frames_.size() || !ref_frames_[frame_to_show]) {
         DVLOG(1) << "Request to show an invalid frame";
         SetError();
         return kDecodeError;
       }
 
-      if (!accelerator_->OutputPicture(ref_frames_[frame_to_show])) {
+      if (!accelerator_->OutputPicture(ref_frames_[frame_to_show],
+                                       render_rect_)) {
         SetError();
         return kDecodeError;
       }
 
       curr_frame_hdr_.reset();
       continue;
     }
 
     gfx::Size new_pic_size(curr_frame_hdr_->frame_width,
                            curr_frame_hdr_->frame_height);
     DCHECK(!new_pic_size.IsEmpty());
 
+    gfx::Rect new_render_rect;
+    // Due to specification render size should be set as not larger than frame
+    // size, or set as frame size if render_and_frame_size_different == 0. For
+    // safety we check the validity of render size or leave it as (0, 0).
+    if (curr_frame_hdr_->render_width > 0 &&

[Pawel Osciak, 2017/06/08 04:58:25]

Perhaps:

gfx::Rect new_render_rect(curr_frame_hdr_->render_width,
                          curr_frame_hdr_->render_height);
if (gfx::Rect(new_pic_size).Contains(new_render_rect))
  render_rect_ = new_render_rect;
else
  render_rect_ = gfx::Rect();

[johnylin1, 2017/06/12 13:41:53]

Done.

+        curr_frame_hdr_->render_width <= curr_frame_hdr_->frame_width &&
+        curr_frame_hdr_->render_height > 0 &&
+        curr_frame_hdr_->render_height <= curr_frame_hdr_->frame_height) {
+      new_render_rect.SetRect(0, 0, curr_frame_hdr_->render_width,
+                              curr_frame_hdr_->render_height);
+    }
+    if (new_render_rect != render_rect_) {
+      DVLOG(1) << "New render resolution: " << new_render_rect.ToString();
+      render_rect_ = new_render_rect;
+    }
+
     if (new_pic_size != pic_size_) {
       DVLOG(1) << "New resolution: " << new_pic_size.ToString();
 
       if (!curr_frame_hdr_->IsKeyframe()) {
         // TODO(posciak): This is doable, but requires a few modifications to
         // VDA implementations to allow multiple picture buffer sets in flight.
         DVLOG(1) << "Resolution change currently supported for keyframes only";
         SetError();
         return kDecodeError;
       }
@@ skipping 55 matching lines @@
   if (!context_refresh_cb.is_null())
     done_cb = base::Bind(&VP9Decoder::UpdateFrameContext,
                          base::Unretained(this), pic, context_refresh_cb);
 
   const Vp9Parser::Context& context = parser_.context();
   if (!accelerator_->SubmitDecode(pic, context.segmentation(),
                                   context.loop_filter(), ref_frames_, done_cb))
     return false;
 
   if (pic->frame_hdr->show_frame) {
-    if (!accelerator_->OutputPicture(pic))
+    if (!accelerator_->OutputPicture(pic, render_rect_))
       return false;
   }
 
   RefreshReferenceFrames(pic);
   return true;
 }
 
 void VP9Decoder::SetError() {
   Reset();
   state_ = kError;
 }
 
 gfx::Size VP9Decoder::GetPicSize() const {
   return pic_size_;
 }
 
 size_t VP9Decoder::GetRequiredNumOfPictures() const {
   // kMaxVideoFrames to keep higher level media pipeline populated, +2 for the
   // pictures being parsed and decoded currently.
   return limits::kMaxVideoFrames + kVp9NumRefFrames + 2;
 }
 
 }  // namespace media