TEST-ONLY: V4L2VEA: align the size of each plane to 128.

media/gpu/v4l2_video_encode_accelerator.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 "media/gpu/v4l2_video_encode_accelerator.h"
 
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include <utility>
 
+#include "base/bits.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/filters/h264_parser.h"
@@ skipping 168 matching lines @@
     scoped_refptr<V4L2Device> device = V4L2Device::Create();
     image_processor_.reset(new V4L2ImageProcessor(device));
 
     // Convert from input_format to device_input_format_, keeping the size
     // at visible_size_ and requiring the output buffers to be of at least
     // input_allocated_size_. Unretained is safe because |this| owns image
     // processor and there will be no callbacks after processor destroys.
     if (!image_processor_->Initialize(
             input_format, device_input_format_, V4L2_MEMORY_USERPTR,
             V4L2_MEMORY_MMAP, visible_size_, visible_size_, visible_size_,
-            input_allocated_size_, kImageProcBufferCount,
+            input_coded_size_, kImageProcBufferCount,
             base::Bind(&V4L2VideoEncodeAccelerator::ImageProcessorError,
                        base::Unretained(this)))) {
       LOG(ERROR) << "Failed initializing image processor";
       return false;
     }
     // The output of image processor is the input of encoder. Output coded
     // width of processor must be the same as input coded width of encoder.
     // Output coded height of processor can be larger but not smaller than the
     // input coded height of encoder. For example, suppose input size of encoder
     // is 320x193. It is OK if the output of processor is 320x208.
     if (image_processor_->output_allocated_size().width() !=
-            input_allocated_size_.width() ||
+            input_coded_size_.width() ||
         image_processor_->output_allocated_size().height() <
-            input_allocated_size_.height()) {
+            input_coded_size_.height()) {
       LOG(ERROR) << "Invalid image processor output coded size "
                  << image_processor_->output_allocated_size().ToString()
                  << ", encode input coded size is "
-                 << input_allocated_size_.ToString();
+                 << input_coded_size_.ToString();
       return false;
     }
 
     for (int i = 0; i < kImageProcBufferCount; i++) {
       std::vector<base::ScopedFD> fds =
           image_processor_->GetDmabufsForOutputBuffer(i);
       if (fds.size() == 0) {
         LOG(ERROR) << __func__ << ": failed to get fds of image processor.";
         return false;
       }
@@ skipping 514 matching lines @@
   qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   qbuf.m.planes = qbuf_planes;
   qbuf.timestamp.tv_sec = static_cast<time_t>(frame->timestamp().InSeconds());
   qbuf.timestamp.tv_usec =
       frame->timestamp().InMicroseconds() -
       frame->timestamp().InSeconds() * base::Time::kMicrosecondsPerSecond;
 
   DCHECK_EQ(device_input_format_, frame->format());
   for (size_t i = 0; i < input_planes_count_; ++i) {
     qbuf.m.planes[i].bytesused = base::checked_cast<__u32>(
-        VideoFrame::PlaneSize(frame->format(), i, input_allocated_size_)
-            .GetArea());
+        VideoFrame::PlaneSize(frame->format(), i, input_coded_size_).GetArea());
 
     switch (input_memory_type_) {
       case V4L2_MEMORY_USERPTR:
-        qbuf.m.planes[i].length = qbuf.m.planes[i].bytesused;
+        qbuf.m.planes[i].length = base::checked_cast<__u32>(
+            VideoFrame::PlaneSize(frame->format(), i, input_allocated_size_)
+                .GetArea());
         qbuf.m.planes[i].m.userptr =
             reinterpret_cast<unsigned long>(frame->data(i));
         DCHECK(qbuf.m.planes[i].m.userptr);
         break;
 
       case V4L2_MEMORY_DMABUF:
         qbuf.m.planes[i].m.fd = frame->dmabuf_fd(i);
         DCHECK_NE(qbuf.m.planes[i].m.fd, -1);
         break;
 
@@ skipping 275 matching lines @@
     format.fmt.pix_mp.width = visible_size_.width();
     format.fmt.pix_mp.height = visible_size_.height();
     format.fmt.pix_mp.pixelformat = input_format_fourcc;
     format.fmt.pix_mp.num_planes = input_planes_count;
     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
     DCHECK_EQ(format.fmt.pix_mp.num_planes, input_planes_count);
   }
 
   // Take device-adjusted sizes for allocated size. If the size is adjusted
   // down, it means the input is too big and the hardware does not support it.
-  input_allocated_size_ = V4L2Device::CodedSizeFromV4L2Format(format);
-  if (!gfx::Rect(input_allocated_size_).Contains(gfx::Rect(visible_size_))) {
+  input_coded_size_ = V4L2Device::CodedSizeFromV4L2Format(format);
+  if (!gfx::Rect(input_coded_size_).Contains(gfx::Rect(visible_size_))) {
     DVLOG(1) << "Input size too big " << visible_size_.ToString()
-             << ", adjusted to " << input_allocated_size_.ToString();
+             << ", adjusted to " << input_coded_size_.ToString();
     return false;
   }
 
+  // Make sure the size of each plane is multiple of 128. If the width is
+  // multiple of 16 and the height is multiple of 32, U or V plane size will
+  // be multiple of 16 * 32 / 4 = 128.
+  if (input_coded_size_.width() % 16 != 0) {
+    LOG(ERROR) << "Input coded width is not multiple of 16";
+    return false;
+  }
+  input_allocated_size_.set_width(input_coded_size_.width());
+  input_allocated_size_.set_height(
+      base::bits::Align(input_coded_size_.height(), 32));
+  DVLOG(1) << "Input coded size=" << input_coded_size_.ToString()
+           << ", input allocated size=" << input_allocated_size_.ToString();
+
   device_input_format_ = input_format;
   input_planes_count_ = input_planes_count;
   return true;
 }
 
 bool V4L2VideoEncodeAccelerator::SetFormats(VideoPixelFormat input_format,
                                             VideoCodecProfile output_profile) {
   DVLOG(3) << "SetFormats()";
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
@@ skipping 257 matching lines @@
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   output_buffer_map_.clear();
 }
 
 }  // namespace media