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

media/gpu/vp8_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/vp8_decoder.h"
 #include "media/base/limits.h"
 
 namespace media {
 
 VP8Decoder::VP8Accelerator::VP8Accelerator() {}
@@ skipping 47 matching lines @@
     curr_frame_hdr_.reset(new Vp8FrameHeader());
     if (!parser_.ParseFrame(curr_frame_start_, frame_size_,
                             curr_frame_hdr_.get())) {
       DVLOG(1) << "Error during decode";
       state_ = kError;
       return kDecodeError;
     }
   }
 
   if (curr_frame_hdr_->IsKeyframe()) {
     gfx::Size new_pic_size(curr_frame_hdr_->width, curr_frame_hdr_->height);

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

Per spec, width/height in frame header may not be aligned to 16. I think we
should align them to 16x16 and use that as coded size, and the unaligned values
for visible size.

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

I thought we did the alignment while v4l2_slice_vda CreateOutputBuffer()
https://cs.chromium.org/chromium/src/media/gpu/v4l2_slice_video_decode_accele...

Or you say we need to do the alignment here for VP8?

[johnylin1, 2017/06/13 15:23:56]

Done, as following to spec.

     if (new_pic_size.IsEmpty())
       return kDecodeError;
 
     if (new_pic_size != pic_size_) {
       DVLOG(2) << "New resolution: " << new_pic_size.ToString();
       pic_size_ = new_pic_size;
 
       DCHECK(!curr_pic_);
       last_frame_ = nullptr;
       golden_frame_ = nullptr;
@@ skipping 83 matching lines @@
     curr_frame_hdr_->height = pic_size_.height();
     curr_frame_hdr_->horizontal_scale = horizontal_scale_;
     curr_frame_hdr_->vertical_scale = vertical_scale_;
   }
 
   if (!accelerator_->SubmitDecode(curr_pic_, curr_frame_hdr_.get(), last_frame_,
                                   golden_frame_, alt_frame_))
     return false;
 
   if (curr_frame_hdr_->show_frame)
-    if (!accelerator_->OutputPicture(curr_pic_))
+    if (!accelerator_->OutputPicture(curr_pic_, gfx::Rect(pic_size_)))
       return false;
 
   RefreshReferenceFrames();
 
   curr_pic_ = nullptr;
   curr_frame_hdr_ = nullptr;
   curr_frame_start_ = nullptr;
   frame_size_ = 0;
   return true;
 }
 
 gfx::Size VP8Decoder::GetPicSize() const {
   return pic_size_;
 }
 
 size_t VP8Decoder::GetRequiredNumOfPictures() const {
   const size_t kVP8NumFramesActive = 4;
   const size_t kPicsInPipeline = limits::kMaxVideoFrames + 2;
   return kVP8NumFramesActive + kPicsInPipeline;
 }
 
 }  // namespace media