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

media/gpu/v4l2_slice_video_decode_accelerator.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/v4l2_slice_video_decode_accelerator.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
@@ skipping 71 matching lines @@
 
   // Mark the surface as decoded. This will also release all references, as
   // they are not needed anymore and execute the done callback, if not null.
   void SetDecoded();
   bool decoded() const { return decoded_; }
 
   int32_t bitstream_id() const { return bitstream_id_; }
   int input_record() const { return input_record_; }
   int output_record() const { return output_record_; }
   uint32_t config_store() const { return config_store_; }
+  gfx::Rect visible_rect() const { return visible_rect_; }
+
+  void SetVisibleRect(const gfx::Rect& visible_rect) {
+    visible_rect_ = visible_rect;
+  }
 
   // Take references to each reference surface and keep them until the
   // target surface is decoded.
   void SetReferenceSurfaces(
       const std::vector<scoped_refptr<V4L2DecodeSurface>>& ref_surfaces);
 
   // If provided via this method, |done_cb| callback will be executed after
   // decoding into this surface is finished. The callback is reset afterwards,
   // so it needs to be set again before each decode operation.
   void SetDecodeDoneCallback(const base::Closure& done_cb) {
     DCHECK(done_cb_.is_null());
     done_cb_ = done_cb;
   }
 
   std::string ToString() const;
 
  private:
   friend class base::RefCounted<V4L2DecodeSurface>;
   ~V4L2DecodeSurface();
 
   int32_t bitstream_id_;
   int input_record_;
   int output_record_;
   uint32_t config_store_;
+  gfx::Rect visible_rect_;
 
   bool decoded_;
   ReleaseCB release_cb_;
   base::Closure done_cb_;
 
   std::vector<scoped_refptr<V4L2DecodeSurface>> reference_surfaces_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2DecodeSurface);
 };
 
@@ skipping 667 matching lines @@
 }
 
 bool V4L2SliceVideoDecodeAccelerator::CreateOutputBuffers() {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
   DCHECK(output_buffer_map_.empty());
   DCHECK(surfaces_at_display_.empty());
   DCHECK(surfaces_at_device_.empty());
 
-  visible_size_ = decoder_->GetPicSize();
+  gfx::Size pic_size = decoder_->GetPicSize();
   size_t num_pictures = decoder_->GetRequiredNumOfPictures();
 
   DCHECK_GT(num_pictures, 0u);
-  DCHECK(!visible_size_.IsEmpty());
+  DCHECK(!pic_size.IsEmpty());
 
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.pixelformat = output_format_fourcc_;
-  format.fmt.pix_mp.width = visible_size_.width();
-  format.fmt.pix_mp.height = visible_size_.height();
+  format.fmt.pix_mp.width = pic_size.width();
+  format.fmt.pix_mp.height = pic_size.height();
   format.fmt.pix_mp.num_planes = input_planes_count_;
 
   if (device_->Ioctl(VIDIOC_S_FMT, &format) != 0) {
     PLOGF(ERROR) << "Failed setting format to: " << output_format_fourcc_;
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
   }
 
   coded_size_.SetSize(base::checked_cast<int>(format.fmt.pix_mp.width),
                       base::checked_cast<int>(format.fmt.pix_mp.height));
   DCHECK_EQ(coded_size_.width() % 16, 0);
   DCHECK_EQ(coded_size_.height() % 16, 0);
 
-  if (!gfx::Rect(coded_size_).Contains(gfx::Rect(visible_size_))) {
+  if (!gfx::Rect(coded_size_).Contains(gfx::Rect(pic_size))) {
     LOGF(ERROR) << "Got invalid adjusted coded size: "
                 << coded_size_.ToString();
     return false;
   }
 
   DVLOGF(3) << "buffer_count=" << num_pictures
-            << ", visible size=" << visible_size_.ToString()
+            << ", pic size=" << pic_size.ToString()
             << ", coded size=" << coded_size_.ToString();
 
   // With ALLOCATE mode the client can sample it as RGB and doesn't need to
   // know the precise format.
   VideoPixelFormat pixel_format =
       (output_mode_ == Config::OutputMode::IMPORT)
           ? V4L2Device::V4L2PixFmtToVideoPixelFormat(output_format_fourcc_)
           : PIXEL_FORMAT_UNKNOWN;
 
   child_task_runner_->PostTask(
@@ skipping 1676 matching lines @@
   Reset();
 
   v4l2_dec_->DecodeSurface(dec_surface);
   return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::V4L2H264Accelerator::OutputPicture(
     const scoped_refptr<H264Picture>& pic) {
   scoped_refptr<V4L2DecodeSurface> dec_surface =
       H264PictureToV4L2DecodeSurface(pic);
+  dec_surface->SetVisibleRect(pic->visible_rect);
   v4l2_dec_->SurfaceReady(dec_surface);
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::V4L2H264Accelerator::Reset() {
   num_slices_ = 0;
   memset(&v4l2_decode_param_, 0, sizeof(v4l2_decode_param_));
   memset(&v4l2_slice_params_, 0, sizeof(v4l2_slice_params_));
 }
 
@@ skipping 211 matching lines @@
     return false;
 
   v4l2_dec_->DecodeSurface(dec_surface);
   return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::V4L2VP8Accelerator::OutputPicture(
     const scoped_refptr<VP8Picture>& pic) {
   scoped_refptr<V4L2DecodeSurface> dec_surface =
       VP8PictureToV4L2DecodeSurface(pic);
-
+  dec_surface->SetVisibleRect(pic->visible_rect);
   v4l2_dec_->SurfaceReady(dec_surface);
   return true;
 }
 
 scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>
 V4L2SliceVideoDecodeAccelerator::V4L2VP8Accelerator::
     VP8PictureToV4L2DecodeSurface(const scoped_refptr<VP8Picture>& pic) {
   V4L2VP8Picture* v4l2_pic = pic->AsV4L2VP8Picture();
   CHECK(v4l2_pic);
   return v4l2_pic->dec_surface();
@@ skipping 282 matching lines @@
     return false;
 
   v4l2_dec_->DecodeSurface(dec_surface);
   return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::V4L2VP9Accelerator::OutputPicture(
     const scoped_refptr<VP9Picture>& pic) {
   scoped_refptr<V4L2DecodeSurface> dec_surface =
       VP9PictureToV4L2DecodeSurface(pic);
-
+  dec_surface->SetVisibleRect(pic->visible_rect);
   v4l2_dec_->SurfaceReady(dec_surface);
   return true;
 }
 
 static void FillVp9FrameContext(struct v4l2_vp9_entropy_ctx& v4l2_entropy_ctx,
                                 Vp9FrameContext* vp9_frame_ctx) {
 #define ARRAY_MEMCPY_CHECKED_V4L2_ENTR_TO_FRM_CTX(a) \
   ARRAY_MEMCPY_CHECKED(vp9_frame_ctx->a, v4l2_entropy_ctx.a)
   ARRAY_MEMCPY_CHECKED_V4L2_ENTR_TO_FRM_CTX(tx_probs_8x8);
   ARRAY_MEMCPY_CHECKED_V4L2_ENTR_TO_FRM_CTX(tx_probs_16x16);
@@ skipping 103 matching lines @@
       surfaces_at_display_
           .insert(std::make_pair(output_record.picture_id, dec_surface))
           .second;
   DCHECK(inserted);
 
   DCHECK(!output_record.at_client);
   DCHECK(!output_record.at_device);
   DCHECK_NE(output_record.picture_id, -1);
   output_record.at_client = true;
 
-  // TODO(posciak): Use visible size from decoder here instead
-  // (crbug.com/402760). Passing (0, 0) results in the client using the
-  // visible size extracted from the container instead.
   // TODO(hubbe): Insert correct color space. http://crbug.com/647725
   Picture picture(output_record.picture_id, dec_surface->bitstream_id(),
-                  gfx::Rect(0, 0), gfx::ColorSpace(), false);
+                  dec_surface->visible_rect(), gfx::ColorSpace(), false);
   DVLOGF(3) << dec_surface->ToString()
             << ", bitstream_id: " << picture.bitstream_buffer_id()
-            << ", picture_id: " << picture.picture_buffer_id();
+            << ", picture_id: " << picture.picture_buffer_id()
+            << ", visible_rect: " << picture.visible_rect().ToString();
   pending_picture_ready_.push(PictureRecord(output_record.cleared, picture));
   SendPictureReady();
   output_record.cleared = true;
 }
 
 scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>
 V4L2SliceVideoDecodeAccelerator::CreateSurface() {
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kDecoding);
 
@@ skipping 86 matching lines @@
 V4L2SliceVideoDecodeAccelerator::GetSupportedProfiles() {
   scoped_refptr<V4L2Device> device = V4L2Device::Create();
   if (!device)
     return SupportedProfiles();
 
   return device->GetSupportedDecodeProfiles(arraysize(supported_input_fourccs_),
                                             supported_input_fourccs_);
 }
 
 }  // namespace media