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 149 matching lines @@
 
   bool SubmitSlice(const H264PPS* pps,
                    const H264SliceHeader* slice_hdr,
                    const H264Picture::Vector& ref_pic_list0,
                    const H264Picture::Vector& ref_pic_list1,
                    const scoped_refptr<H264Picture>& pic,
                    const uint8_t* data,
                    size_t size) override;
 
   bool SubmitDecode(const scoped_refptr<H264Picture>& pic) override;
-  bool OutputPicture(const scoped_refptr<H264Picture>& pic) override;
+  bool OutputPicture(const scoped_refptr<H264Picture>& pic,
+                     const gfx::Rect& visible_rect) override;
 
   void Reset() override;
 
  private:
   // Max size of reference list.
   static const size_t kDPBIndicesListSize = 32;
   void H264PictureListToDPBIndicesList(const H264Picture::Vector& src_pic_list,
                                        uint8_t dst_list[kDPBIndicesListSize]);
 
   void H264DPBToV4L2DPB(
@@ skipping 22 matching lines @@
 
   // VP8Decoder::VP8Accelerator implementation.
   scoped_refptr<VP8Picture> CreateVP8Picture() override;
 
   bool SubmitDecode(const scoped_refptr<VP8Picture>& pic,
                     const Vp8FrameHeader* frame_hdr,
                     const scoped_refptr<VP8Picture>& last_frame,
                     const scoped_refptr<VP8Picture>& golden_frame,
                     const scoped_refptr<VP8Picture>& alt_frame) override;
 
-  bool OutputPicture(const scoped_refptr<VP8Picture>& pic) override;
+  bool OutputPicture(const scoped_refptr<VP8Picture>& pic,
+                     const gfx::Rect& visible_rect) override;
 
  private:
   scoped_refptr<V4L2DecodeSurface> VP8PictureToV4L2DecodeSurface(
       const scoped_refptr<VP8Picture>& pic);
 
   V4L2SliceVideoDecodeAccelerator* v4l2_dec_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2VP8Accelerator);
 };
 
 class V4L2SliceVideoDecodeAccelerator::V4L2VP9Accelerator
     : public VP9Decoder::VP9Accelerator {
  public:
   explicit V4L2VP9Accelerator(V4L2SliceVideoDecodeAccelerator* v4l2_dec);
   ~V4L2VP9Accelerator() override;
 
   // VP9Decoder::VP9Accelerator implementation.
   scoped_refptr<VP9Picture> CreateVP9Picture() override;
 
   bool SubmitDecode(const scoped_refptr<VP9Picture>& pic,
                     const Vp9SegmentationParams& segm_params,
                     const Vp9LoopFilterParams& lf_params,
                     const std::vector<scoped_refptr<VP9Picture>>& ref_pictures,
                     const base::Closure& done_cb) override;
 
-  bool OutputPicture(const scoped_refptr<VP9Picture>& pic) override;
+  bool OutputPicture(const scoped_refptr<VP9Picture>& pic,
+                     const gfx::Rect& visible_rect) override;
 
   bool GetFrameContext(const scoped_refptr<VP9Picture>& pic,
                        Vp9FrameContext* frame_ctx) override;
 
   bool IsFrameContextRequired() const override {
     return device_needs_frame_context_;
   }
 
  private:
   scoped_refptr<V4L2DecodeSurface> VP9PictureToV4L2DecodeSurface(
@@ skipping 428 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 1673 matching lines @@
   if (!v4l2_dec_->SubmitExtControls(&ext_ctrls))
     return false;
 
   Reset();
 
   v4l2_dec_->DecodeSurface(dec_surface);
   return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::V4L2H264Accelerator::OutputPicture(
-    const scoped_refptr<H264Picture>& pic) {
+    const scoped_refptr<H264Picture>& pic,
+    const gfx::Rect& visible_rect) {
   scoped_refptr<V4L2DecodeSurface> dec_surface =
       H264PictureToV4L2DecodeSurface(pic);
+  dec_surface->SetVisibleRect(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 208 matching lines @@
 
   if (!v4l2_dec_->SubmitSlice(dec_surface->input_record(), frame_hdr->data,
                               frame_hdr->frame_size))
     return false;
 
   v4l2_dec_->DecodeSurface(dec_surface);
   return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::V4L2VP8Accelerator::OutputPicture(
-    const scoped_refptr<VP8Picture>& pic) {
+    const scoped_refptr<VP8Picture>& pic,
+    const gfx::Rect& visible_rect) {
   scoped_refptr<V4L2DecodeSurface> dec_surface =
       VP8PictureToV4L2DecodeSurface(pic);
-
+  dec_surface->SetVisibleRect(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 279 matching lines @@
 
   if (!v4l2_dec_->SubmitSlice(dec_surface->input_record(), frame_hdr->data,
                               frame_hdr->frame_size))
     return false;
 
   v4l2_dec_->DecodeSurface(dec_surface);
   return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::V4L2VP9Accelerator::OutputPicture(
-    const scoped_refptr<VP9Picture>& pic) {
+    const scoped_refptr<VP9Picture>& pic,
+    const gfx::Rect& visible_rect) {
   scoped_refptr<V4L2DecodeSurface> dec_surface =
       VP9PictureToV4L2DecodeSurface(pic);
-
+  dec_surface->SetVisibleRect(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