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 782 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();
+  visible_rect_ = decoder_->GetVisibleRect();
   size_t num_pictures = decoder_->GetRequiredNumOfPictures();
 
   DCHECK_GT(num_pictures, 0u);
-  DCHECK(!visible_size_.IsEmpty());
+  DCHECK(!pic_size.IsEmpty());
+  DCHECK(!visible_rect_.IsEmpty());

[Owen Lin, 2017/06/07 06:10:59]

As said in previous file, remove the check. 
Is it possible we change the visible size without changing the coded size. In
that case, we need to get the new visible_rect somewhere else.

[johnylin1, 2017/06/07 15:38:37]

We may pass visible size from decoder to VDA along with OutputPicture(), and put
visible size information into DecodeSurface.

 
   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_))) {
-    LOGF(ERROR) << "Got invalid adjusted coded size: "
-                << coded_size_.ToString();
+  if (!gfx::Rect(coded_size_).Contains(visible_rect_)) {

[Owen Lin, 2017/06/07 06:10:59]

use pic_size.

[johnylin1, 2017/06/07 15:38:37]

Done.

+    LOGF(ERROR) << "Got invalid adjusted coded size: " << coded_size_.ToString()
+                << ", visible rect:" << visible_rect_.ToString();
     return false;
   }
 
   DVLOGF(3) << "buffer_count=" << num_pictures
-            << ", visible size=" << visible_size_.ToString()
+            << ", visible rect=" << visible_rect_.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 2334 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);
+                  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: " << 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