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 94 matching lines @@
       }
 
       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(curr_frame_hdr_->render_width,
+                              curr_frame_hdr_->render_height);
+    // Due to specification render size should be set as not larger than frame

[Owen Lin, 2017/06/13 03:00:14]

Why we need to care about render_and_frame_size_different == 0 here?
It should be already handled in vp9_parser.

https://cs.chromium.org/chromium/src/media/filters/vp9_uncompressed_header_pa...

Besides, I am not sure if returning (0, 0) is better than returning pic_size. I
think pic_size is still better than coded_size.

[johnylin1, 2017/06/13 07:10:30]

Yes, actually I want this check just to prevent if there is abnormal values of
parsed render_width/height. 
It looks also good to me. We could apply this on both VP9 and H264.
Pawel, what do you think?

[Owen Lin, 2017/06/14 02:28:25]

I see. Then I think we don't need to mention about the detail of VP9 spec here
since it doesn't provide more information, I mean render_width/height are
already following the spec and set properly in the vp9 parser. In this comment,
saying "For safety, check the validity of render size or ..." should be enough. 

[johnylin1, 2017/06/14 14:11:22]

Done.

+    // 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 (!gfx::Rect(new_pic_size).Contains(new_render_rect))
+      new_render_rect = gfx::Rect();
+    DVLOG(1) << "Render resolution: " << new_render_rect.ToString();
+
     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;
       }
 
       // TODO(posciak): This requires us to be on a keyframe (see above) and is
       // required, because VDA clients expect all surfaces to be returned before
       // they can cycle surface sets after receiving kAllocateNewSurfaces.
       // This is only an implementation detail of VDAs and can be improved.
       for (auto& ref_frame : ref_frames_)
         ref_frame = nullptr;
 
       pic_size_ = new_pic_size;
       return kAllocateNewSurfaces;
     }
 
     scoped_refptr<VP9Picture> pic = accelerator_->CreateVP9Picture();
     if (!pic)
       return kRanOutOfSurfaces;
 
+    pic->visible_rect = new_render_rect;
     pic->frame_hdr.reset(curr_frame_hdr_.release());
 
     if (!DecodeAndOutputPicture(pic)) {
       SetError();
       return kDecodeError;
     }
   }
 }
 
 void VP9Decoder::RefreshReferenceFrames(const scoped_refptr<VP9Picture>& pic) {
@@ skipping 53 matching lines @@
   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