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);
-    if (new_pic_size.IsEmpty())
+    gfx::Rect new_visible_rect(curr_frame_hdr_->width, curr_frame_hdr_->height);
+    if (new_visible_rect.IsEmpty())
       return kDecodeError;
+    visible_rect_ = new_visible_rect;
+    DVLOG(2) << "Visible size: " << visible_rect_.ToString();
+
+    // Per spec, frame size is not necessarily evenly divisible by 16, while
+    // frame is encoded by 16x16 macroblock units. Add excess width and height
+    // to be divisible by 16.
+    uint16_t coded_width =

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

You may use base::bits::Align.

https://cs.chromium.org/chromium/src/base/bits.h?rcl=59571c968913ef4968f6fb9a...

But I would suggest to have another CL for it, since it sounds like a
independent issue. 

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

Sounds good to me. Let's create another CL then.

+        (curr_frame_hdr_->width & 15)
+            ? curr_frame_hdr_->width + 16 - (curr_frame_hdr_->width & 15)
+            : curr_frame_hdr_->width;
+    uint16_t coded_height =
+        (curr_frame_hdr_->height & 15)
+            ? curr_frame_hdr_->height + 16 - (curr_frame_hdr_->height & 15)
+            : curr_frame_hdr_->height;
+    gfx::Size new_pic_size(coded_width, coded_height);
 
     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;
       alt_frame_ = nullptr;
 
       return kAllocateNewSurfaces;
     }
 
     state_ = kDecoding;
   } else {
     if (state_ != kDecoding) {
       // Need a resume point.
       curr_frame_hdr_.reset();
       return kRanOutOfStreamData;
     }
   }
 
   curr_pic_ = accelerator_->CreateVP8Picture();
   if (!curr_pic_)
     return kRanOutOfSurfaces;
 
+  curr_pic_->visible_rect = visible_rect_;
   if (!DecodeAndOutputCurrentFrame())
     return kDecodeError;
 
   return kRanOutOfStreamData;
 }
 
 void VP8Decoder::RefreshReferenceFrames() {
   if (curr_frame_hdr_->IsKeyframe()) {
     last_frame_ = curr_pic_;
     golden_frame_ = curr_pic_;
@@ skipping 78 matching lines @@
   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