Migrate content/common/gpu/media code to media/gpu

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>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/numerics/safe_conversions.h"
-#include "content/common/gpu/media/v4l2_image_processor.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/gpu/v4l2_image_processor.h"
 
 #define IOCTL_OR_ERROR_RETURN_VALUE(type, arg, value, type_str)        \
   do {                                                                 \
     if (device_->Ioctl(type, arg) != 0) {                              \
       PLOG(ERROR) << __func__ << "(): ioctl() failed: " << type_str;   \
       return value;                                                    \
     }                                                                  \
   } while (0)
 
 #define IOCTL_OR_ERROR_RETURN(type, arg) \
   IOCTL_OR_ERROR_RETURN_VALUE(type, arg, ((void)0), #type)
 
 #define IOCTL_OR_ERROR_RETURN_FALSE(type, arg) \
   IOCTL_OR_ERROR_RETURN_VALUE(type, arg, false, #type)
 
-#define IOCTL_OR_LOG_ERROR(type, arg)                              \
-  do {                                                             \
-    if (device_->Ioctl(type, arg) != 0)                            \
-      PLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type;  \
+#define IOCTL_OR_LOG_ERROR(type, arg)                             \
+  do {                                                            \
+    if (device_->Ioctl(type, arg) != 0)                           \
+      PLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type; \
   } while (0)
 
-namespace content {
+namespace media {
 
-V4L2ImageProcessor::InputRecord::InputRecord() : at_device(false) {
-}
+V4L2ImageProcessor::InputRecord::InputRecord() : at_device(false) {}
 
-V4L2ImageProcessor::InputRecord::~InputRecord() {
-}
+V4L2ImageProcessor::InputRecord::~InputRecord() {}
 
 V4L2ImageProcessor::OutputRecord::OutputRecord() : at_device(false) {}
 
-V4L2ImageProcessor::OutputRecord::~OutputRecord() {
-}
+V4L2ImageProcessor::OutputRecord::~OutputRecord() {}
 
 V4L2ImageProcessor::JobRecord::JobRecord() : output_buffer_index(-1) {}
 
-V4L2ImageProcessor::JobRecord::~JobRecord() {
-}
+V4L2ImageProcessor::JobRecord::~JobRecord() {}
 
 V4L2ImageProcessor::V4L2ImageProcessor(const scoped_refptr<V4L2Device>& device)
     : input_format_(media::PIXEL_FORMAT_UNKNOWN),
       output_format_(media::PIXEL_FORMAT_UNKNOWN),
       input_format_fourcc_(0),
       output_format_fourcc_(0),
       input_planes_count_(0),
       output_planes_count_(0),
       child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       device_(device),
@@ skipping 68 matching lines @@
   output_planes_count_ = media::VideoFrame::NumPlanes(output_format);
   DCHECK_LE(output_planes_count_, static_cast<size_t>(VIDEO_MAX_PLANES));
 
   // Capabilities check.
   struct v4l2_capability caps;
   memset(&caps, 0, sizeof(caps));
   const __u32 kCapsRequired = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
     LOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: "
-                  "caps check failed: 0x" << std::hex << caps.capabilities;
+                  "caps check failed: 0x"
+               << std::hex << caps.capabilities;
     return false;
   }
 
   if (!CreateInputBuffers() || !CreateOutputBuffers())
     return false;
 
   if (!device_thread_.Start()) {
     LOG(ERROR) << "Initialize(): encoder thread failed to start";
     return false;
   }
@@ skipping 29 matching lines @@
                                  int output_buffer_index,
                                  const FrameReadyCB& cb) {
   DVLOG(3) << __func__ << ": ts=" << frame->timestamp().InMilliseconds();
 
   std::unique_ptr<JobRecord> job_record(new JobRecord());
   job_record->frame = frame;
   job_record->output_buffer_index = output_buffer_index;
   job_record->ready_cb = cb;
 
   device_thread_.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&V4L2ImageProcessor::ProcessTask,
-                 base::Unretained(this),
-                 base::Passed(&job_record)));
+      FROM_HERE, base::Bind(&V4L2ImageProcessor::ProcessTask,
+                            base::Unretained(this), base::Passed(&job_record)));
 }
 
 void V4L2ImageProcessor::ProcessTask(std::unique_ptr<JobRecord> job_record) {
   int index = job_record->output_buffer_index;
   DVLOG(3) << __func__ << ": Reusing output buffer, index=" << index;
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
 
   EnqueueOutput(index);
   input_queue_.push(make_linked_ptr(job_record.release()));
   EnqueueInput();
@@ skipping 63 matching lines @@
   for (size_t i = 0; i < input_planes_count_; ++i) {
     format.fmt.pix_mp.plane_fmt[i].sizeimage =
         media::VideoFrame::PlaneSize(input_format_, i, input_allocated_size_)
             .GetArea();
     format.fmt.pix_mp.plane_fmt[i].bytesperline =
         base::checked_cast<__u32>(input_allocated_size_.width());
   }
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
 
   input_allocated_size_ = V4L2Device::CodedSizeFromV4L2Format(format);
-  DCHECK(gfx::Rect(input_allocated_size_).Contains(
-      gfx::Rect(input_visible_size_)));
+  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);
 
@@ skipping 34 matching lines @@
     format.fmt.pix_mp.plane_fmt[i].sizeimage =
         media::VideoFrame::PlaneSize(output_format_, i, output_allocated_size_)
             .GetArea();
     format.fmt.pix_mp.plane_fmt[i].bytesperline =
         base::checked_cast<__u32>(output_allocated_size_.width());
   }
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
 
   gfx::Size adjusted_allocated_size =
       V4L2Device::CodedSizeFromV4L2Format(format);
-  DCHECK(gfx::Rect(adjusted_allocated_size).Contains(
-      gfx::Rect(output_allocated_size_)));
+  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);
@@ skipping 50 matching lines @@
 
   bool event_pending;
   if (!device_->Poll(poll_device, &event_pending)) {
     NotifyError();
     return;
   }
 
   // All processing should happen on ServiceDeviceTask(), since we shouldn't
   // touch encoder state from this thread.
   device_thread_.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&V4L2ImageProcessor::ServiceDeviceTask,
-                 base::Unretained(this)));
+      FROM_HERE, base::Bind(&V4L2ImageProcessor::ServiceDeviceTask,
+                            base::Unretained(this)));
 }
 
 void V4L2ImageProcessor::ServiceDeviceTask() {
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
   // ServiceDeviceTask() should only ever be scheduled from DevicePollTask(),
   // so either:
   // * device_poll_thread_ is running normally
   // * device_poll_thread_ scheduled us, but then a DestroyTask() shut it down,
   //   in which case we should early-out.
   if (!device_poll_thread_.message_loop())
@@ skipping 148 matching lines @@
   struct v4l2_buffer qbuf;
   struct v4l2_plane qbuf_planes[VIDEO_MAX_PLANES];
   memset(&qbuf, 0, sizeof(qbuf));
   memset(qbuf_planes, 0, sizeof(qbuf_planes));
   qbuf.index = index;
   qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   qbuf.memory = V4L2_MEMORY_USERPTR;
   qbuf.m.planes = qbuf_planes;
   qbuf.length = input_planes_count_;
   for (size_t i = 0; i < input_planes_count_; ++i) {
-    qbuf.m.planes[i].bytesused = media::VideoFrame::PlaneSize(
-        input_record.frame->format(), i, input_allocated_size_).GetArea();
+    qbuf.m.planes[i].bytesused =
+        media::VideoFrame::PlaneSize(input_record.frame->format(), i,
+                                     input_allocated_size_)
+            .GetArea();
     qbuf.m.planes[i].length = qbuf.m.planes[i].bytesused;
     qbuf.m.planes[i].m.userptr =
         reinterpret_cast<unsigned long>(input_record.frame->data(i));
   }
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
   input_record.at_device = true;
   running_jobs_.push(job_record);
   free_input_buffers_.pop_back();
   input_buffer_queued_count_++;
 
@@ skipping 31 matching lines @@
 
   // Start up the device poll thread and schedule its first DevicePollTask().
   if (!device_poll_thread_.Start()) {
     LOG(ERROR) << "StartDevicePoll(): Device thread failed to start";
     NotifyError();
     return false;
   }
   // Enqueue a poll task with no devices to poll on - will wait only for the
   // poll interrupt
   device_poll_thread_.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &V4L2ImageProcessor::DevicePollTask, base::Unretained(this), false));
+      FROM_HERE, base::Bind(&V4L2ImageProcessor::DevicePollTask,
+                            base::Unretained(this), false));
 
   return true;
 }
 
 bool V4L2ImageProcessor::StopDevicePoll() {
   DVLOG(3) << __func__ << ": stopping device poll";
   if (device_thread_.IsRunning())
     DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
 
   // Signal the DevicePollTask() to stop, and stop the device poll thread.
@@ skipping 39 matching lines @@
 
   return true;
 }
 
 void V4L2ImageProcessor::FrameReady(const FrameReadyCB& cb,
                                     int output_buffer_index) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   cb.Run(output_buffer_index);
 }
 
-}  // namespace content
+}  // namespace media