V4L2ImageProcessor: Use VIDIOC_S_SELECTION for buffer region control

media/gpu/v4l2_image_processor.cc

 // Copyright 2014 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 <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/eventfd.h>
@@ skipping 347 matching lines @@
   format.fmt.pix_mp.height = input_allocated_size_.height();
   format.fmt.pix_mp.pixelformat = input_format_fourcc_;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
 
   input_planes_count_ = format.fmt.pix_mp.num_planes;
   DCHECK_LE(input_planes_count_, static_cast<size_t>(VIDEO_MAX_PLANES));
   input_allocated_size_ = V4L2Device::CodedSizeFromV4L2Format(format);
   DCHECK(gfx::Rect(input_allocated_size_)
              .Contains(gfx::Rect(input_visible_size_)));
 
-  struct v4l2_crop crop;
-  memset(&crop, 0, sizeof(crop));
-  crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-  crop.c.left = 0;
-  crop.c.top = 0;
-  crop.c.width = base::checked_cast<__u32>(input_visible_size_.width());
-  crop.c.height = base::checked_cast<__u32>(input_visible_size_.height());
-  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CROP, &crop);
+  struct v4l2_rect visible_rect;
+  visible_rect.left = 0;
+  visible_rect.top = 0;
+  visible_rect.width = base::checked_cast<__u32>(input_visible_size_.width());
+  visible_rect.height = base::checked_cast<__u32>(input_visible_size_.height());
+
+  struct v4l2_selection selection_arg;
+  memset(&selection_arg, 0, sizeof(selection_arg));
+  selection_arg.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+  selection_arg.target = V4L2_SEL_TGT_CROP;
+  selection_arg.r = visible_rect;
+  if (device_->Ioctl(VIDIOC_S_SELECTION, &selection_arg) != 0) {
+    DVLOG(2) << "Fallback to VIDIOC_S_CROP for input buffers.";
+    struct v4l2_crop crop;
+    memset(&crop, 0, sizeof(crop));
+    crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    crop.c = visible_rect;
+    IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CROP, &crop);
+  }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = num_buffers_;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = input_memory_type_;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
   if (static_cast<int>(reqbufs.count) != num_buffers_) {
     LOG(ERROR) << "Failed to allocate input buffers. reqbufs.count="
                << reqbufs.count << ", num_buffers=" << num_buffers_;
@@ skipping 23 matching lines @@
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
 
   output_planes_count_ = format.fmt.pix_mp.num_planes;
   DCHECK_LE(output_planes_count_, static_cast<size_t>(VIDEO_MAX_PLANES));
   gfx::Size adjusted_allocated_size =
       V4L2Device::CodedSizeFromV4L2Format(format);
   DCHECK(gfx::Rect(adjusted_allocated_size)
              .Contains(gfx::Rect(output_allocated_size_)));
   output_allocated_size_ = adjusted_allocated_size;
 
-  struct v4l2_crop crop;
-  memset(&crop, 0, sizeof(crop));
-  crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-  crop.c.left = 0;
-  crop.c.top = 0;
-  crop.c.width = base::checked_cast<__u32>(output_visible_size_.width());
-  crop.c.height = base::checked_cast<__u32>(output_visible_size_.height());
-  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CROP, &crop);
+  struct v4l2_rect visible_rect;
+  visible_rect.left = 0;
+  visible_rect.top = 0;
+  visible_rect.width = base::checked_cast<__u32>(output_visible_size_.width());
+  visible_rect.height =
+    base::checked_cast<__u32>(output_visible_size_.height());
+
+  struct v4l2_selection selection_arg;
+  memset(&selection_arg, 0, sizeof(selection_arg));
+  selection_arg.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  selection_arg.target = V4L2_SEL_TGT_COMPOSE;
+  selection_arg.r = visible_rect;
+  if (device_->Ioctl(VIDIOC_S_SELECTION, &selection_arg) != 0) {
+    DVLOG(2) << "Fallback to VIDIOC_S_CROP for output buffers.";
+    struct v4l2_crop crop;
+    memset(&crop, 0, sizeof(crop));
+    crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    crop.c = visible_rect;
+    IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CROP, &crop);
+  }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = num_buffers_;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = output_memory_type_;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
   if (static_cast<int>(reqbufs.count) != num_buffers_) {
     LOG(ERROR) << "Failed to allocate output buffers. reqbufs.count="
                << reqbufs.count << ", num_buffers=" << num_buffers_;
@@ skipping 340 matching lines @@
   output_buffer_queued_count_ = 0;
 }
 
 void V4L2ImageProcessor::FrameReady(const FrameReadyCB& cb,
                                     int output_buffer_index) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   cb.Run(output_buffer_index);
 }
 
 }  // namespace media