Test X11 header pollution

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 "content/common/gpu/media/v4l2_video_encode_accelerator.h"
+#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/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
-#include "content/common/gpu/media/shared_memory_region.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
+#include "media/gpu/shared_memory_region.h"
 
 #define NOTIFY_ERROR(x)                        \
   do {                                         \
     LOG(ERROR) << "Setting error state:" << x; \
     SetErrorState(x);                          \
   } while (0)
 
-#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;   \
-      NOTIFY_ERROR(kPlatformFailureError);                             \
-      return value;                                                    \
-    }                                                                  \
+#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; \
+      NOTIFY_ERROR(kPlatformFailureError);                           \
+      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 {
 
 struct V4L2VideoEncodeAccelerator::BitstreamBufferRef {
   BitstreamBufferRef(int32_t id, std::unique_ptr<SharedMemoryRegion> shm)
       : id(id), shm(std::move(shm)) {}
   const int32_t id;
   const std::unique_ptr<SharedMemoryRegion> shm;
 };
 
-V4L2VideoEncodeAccelerator::InputRecord::InputRecord() : at_device(false) {
-}
+V4L2VideoEncodeAccelerator::InputRecord::InputRecord() : at_device(false) {}
 
-V4L2VideoEncodeAccelerator::InputRecord::~InputRecord() {
-}
+V4L2VideoEncodeAccelerator::InputRecord::~InputRecord() {}
 
 V4L2VideoEncodeAccelerator::OutputRecord::OutputRecord()
-    : at_device(false), address(NULL), length(0) {
-}
+    : at_device(false), address(NULL), length(0) {}
 
-V4L2VideoEncodeAccelerator::OutputRecord::~OutputRecord() {
-}
+V4L2VideoEncodeAccelerator::OutputRecord::~OutputRecord() {}
 
 V4L2VideoEncodeAccelerator::ImageProcessorInputRecord::
     ImageProcessorInputRecord()
     : force_keyframe(false) {}
 
 V4L2VideoEncodeAccelerator::ImageProcessorInputRecord::
     ~ImageProcessorInputRecord() {}
 
 V4L2VideoEncodeAccelerator::V4L2VideoEncodeAccelerator(
     const scoped_refptr<V4L2Device>& device)
@@ skipping 44 matching lines @@
 
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(encoder_state_, kUninitialized);
 
   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 (!SetFormats(input_format, output_profile)) {
     DLOG(ERROR) << "Failed setting up formats";
     return false;
   }
 
   if (input_format != device_input_format_) {
     DVLOG(1) << "Input format not supported by the HW, will convert to "
@@ skipping 92 matching lines @@
                      base::Unretained(this), force_keyframe,
                      frame->timestamp()));
     } else {
       ImageProcessorInputRecord record;
       record.frame = frame;
       record.force_keyframe = force_keyframe;
       image_processor_input_queue_.push(record);
     }
   } else {
     encoder_thread_.message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&V4L2VideoEncodeAccelerator::EncodeTask,
-                   base::Unretained(this),
-                   frame,
-                   force_keyframe));
+        FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::EncodeTask,
+                              base::Unretained(this), frame, force_keyframe));
   }
 }
 
 void V4L2VideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const media::BitstreamBuffer& buffer) {
   DVLOG(3) << "UseOutputBitstreamBuffer(): id=" << buffer.id();
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (buffer.size() < output_buffer_byte_size_) {
     NOTIFY_ERROR(kInvalidArgumentError);
     return;
   }
 
   std::unique_ptr<SharedMemoryRegion> shm(
       new SharedMemoryRegion(buffer, false));
   if (!shm->Map()) {
     NOTIFY_ERROR(kPlatformFailureError);
     return;
   }
 
   std::unique_ptr<BitstreamBufferRef> buffer_ref(
       new BitstreamBufferRef(buffer.id(), std::move(shm)));
   encoder_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&V4L2VideoEncodeAccelerator::UseOutputBitstreamBufferTask,
-                 base::Unretained(this),
-                 base::Passed(&buffer_ref)));
+                 base::Unretained(this), base::Passed(&buffer_ref)));
 }
 
 void V4L2VideoEncodeAccelerator::RequestEncodingParametersChange(
     uint32_t bitrate,
     uint32_t framerate) {
   DVLOG(3) << "RequestEncodingParametersChange(): bitrate=" << bitrate
            << ", framerate=" << framerate;
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   encoder_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(
           &V4L2VideoEncodeAccelerator::RequestEncodingParametersChangeTask,
-          base::Unretained(this),
-          bitrate,
-          framerate));
+          base::Unretained(this), bitrate, framerate));
 }
 
 void V4L2VideoEncodeAccelerator::Destroy() {
   DVLOG(3) << "Destroy()";
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   // We're destroying; cancel all callbacks.
   client_ptr_factory_.reset();
   weak_this_ptr_factory_.InvalidateWeakPtrs();
 
   if (image_processor_.get())
     image_processor_.release()->Destroy();
 
   // If the encoder thread is running, destroy using posted task.
   if (encoder_thread_.IsRunning()) {
     encoder_thread_.message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&V4L2VideoEncodeAccelerator::DestroyTask,
-                   base::Unretained(this)));
+        FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::DestroyTask,
+                              base::Unretained(this)));
     // DestroyTask() will put the encoder into kError state and cause all tasks
     // to no-op.
     encoder_thread_.Stop();
   } else {
     // Otherwise, call the destroy task directly.
     DestroyTask();
   }
 
   // Set to kError state just in case.
   encoder_state_ = kError;
 
   delete this;
 }
 
 media::VideoEncodeAccelerator::SupportedProfiles
 V4L2VideoEncodeAccelerator::GetSupportedProfiles() {
   SupportedProfiles profiles;
   SupportedProfile profile;
   profile.max_framerate_numerator = 30;
   profile.max_framerate_denominator = 1;
 
   gfx::Size min_resolution;
   v4l2_fmtdesc fmtdesc;
   memset(&fmtdesc, 0, sizeof(fmtdesc));
   fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   for (; device_->Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0; ++fmtdesc.index) {
-    device_->GetSupportedResolution(fmtdesc.pixelformat,
-                                    &min_resolution, &profile.max_resolution);
+    device_->GetSupportedResolution(fmtdesc.pixelformat, &min_resolution,
+                                    &profile.max_resolution);
     switch (fmtdesc.pixelformat) {
       case V4L2_PIX_FMT_H264:
         profile.profile = media::H264PROFILE_MAIN;
         profiles.push_back(profile);
         break;
       case V4L2_PIX_FMT_VP8:
         profile.profile = media::VP8PROFILE_ANY;
         profiles.push_back(profile);
         break;
       case V4L2_PIX_FMT_VP9:
@@ skipping 157 matching lines @@
 
   // 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're in kError state, and we should have early-outed
   //   already.
   DCHECK(device_poll_thread_.message_loop());
   // Queue the DevicePollTask() now.
   device_poll_thread_.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&V4L2VideoEncodeAccelerator::DevicePollTask,
-                 base::Unretained(this),
-                 poll_device));
+      FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::DevicePollTask,
+                            base::Unretained(this), poll_device));
 
-  DVLOG(2) << __func__ << ": buffer counts: ENC["
-           << encoder_input_queue_.size() << "] => DEVICE["
-           << free_input_buffers_.size() << "+"
-           << input_buffer_queued_count_ << "/"
-           << input_buffer_map_.size() << "->"
-           << free_output_buffers_.size() << "+"
-           << output_buffer_queued_count_ << "/"
-           << output_buffer_map_.size() << "] => OUT["
-           << encoder_output_queue_.size() << "]";
+  DVLOG(2) << __func__ << ": buffer counts: ENC[" << encoder_input_queue_.size()
+           << "] => DEVICE[" << free_input_buffers_.size() << "+"
+           << input_buffer_queued_count_ << "/" << input_buffer_map_.size()
+           << "->" << free_output_buffers_.size() << "+"
+           << output_buffer_queued_count_ << "/" << output_buffer_map_.size()
+           << "] => OUT[" << encoder_output_queue_.size() << "]";
 }
 
 void V4L2VideoEncodeAccelerator::Enqueue() {
   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
 
   DVLOG(3) << "Enqueue() "
            << "free_input_buffers: " << free_input_buffers_.size()
            << "input_queue: " << encoder_input_queue_.size();
 
   // Enqueue all the inputs we can.
@@ skipping 118 matching lines @@
         memcpy(target_data + stream_header_size_, output_data, output_size);
         output_size += stream_header_size_;
       } else {
         memcpy(target_data, output_data, output_size);
       }
     } else {
       memcpy(target_data, output_data, output_size);
     }
 
     DVLOG(3) << "Dequeue(): returning "
-                "bitstream_buffer_id=" << output_record.buffer_ref->id
-             << ", size=" << output_size << ", key_frame=" << key_frame;
+                "bitstream_buffer_id="
+             << output_record.buffer_ref->id << ", size=" << output_size
+             << ", key_frame=" << key_frame;
     child_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Client::BitstreamBufferReady, client_,
                    output_record.buffer_ref->id, output_size, key_frame));
     output_record.at_device = false;
     output_record.buffer_ref.reset();
     free_output_buffers_.push_back(dqbuf.index);
     output_buffer_queued_count_--;
   }
 }
@@ skipping 11 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.m.planes = qbuf_planes;
 
   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>(media::VideoFrame::PlaneSize(
-            frame->format(), i, input_allocated_size_).GetArea());
+    qbuf.m.planes[i].bytesused = base::checked_cast<__u32>(
+        media::VideoFrame::PlaneSize(frame->format(), i, input_allocated_size_)
+            .GetArea());
 
     switch (input_memory_type_) {
       case V4L2_MEMORY_USERPTR:
         qbuf.m.planes[i].length = qbuf.m.planes[i].bytesused;
         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:
@@ skipping 55 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";
     NOTIFY_ERROR(kPlatformFailureError);
     return false;
   }
   // Enqueue a poll task with no devices to poll on -- it will wait only on the
   // interrupt fd.
   device_poll_thread_.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&V4L2VideoEncodeAccelerator::DevicePollTask,
-                 base::Unretained(this),
-                 false));
+      FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::DevicePollTask,
+                            base::Unretained(this), false));
 
   return true;
 }
 
 bool V4L2VideoEncodeAccelerator::StopDevicePoll() {
   DVLOG(3) << "StopDevicePoll()";
 
   // Signal the DevicePollTask() to stop, and stop the device poll thread.
   if (!device_->SetDevicePollInterrupt())
     return false;
@@ skipping 47 matching lines @@
 
   bool event_pending;
   if (!device_->Poll(poll_device, &event_pending)) {
     NOTIFY_ERROR(kPlatformFailureError);
     return;
   }
 
   // All processing should happen on ServiceDeviceTask(), since we shouldn't
   // touch encoder state from this thread.
   encoder_thread_.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&V4L2VideoEncodeAccelerator::ServiceDeviceTask,
-                 base::Unretained(this)));
+      FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::ServiceDeviceTask,
+                            base::Unretained(this)));
 }
 
 void V4L2VideoEncodeAccelerator::NotifyError(Error error) {
   DVLOG(1) << "NotifyError(): error=" << error;
 
   if (!child_task_runner_->BelongsToCurrentThread()) {
     child_task_runner_->PostTask(
         FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::NotifyError,
                               weak_this_, error));
     return;
@@ skipping 336 matching lines @@
     struct v4l2_plane planes[1];
     struct v4l2_buffer buffer;
     memset(&buffer, 0, sizeof(buffer));
     memset(planes, 0, sizeof(planes));
     buffer.index = i;
     buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
     buffer.memory = V4L2_MEMORY_MMAP;
     buffer.m.planes = planes;
     buffer.length = arraysize(planes);
     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYBUF, &buffer);
-    void* address = device_->Mmap(NULL,
-                                  buffer.m.planes[0].length,
-                                  PROT_READ | PROT_WRITE,
-                                  MAP_SHARED,
-                                  buffer.m.planes[0].m.mem_offset);
+    void* address =
+        device_->Mmap(NULL, buffer.m.planes[0].length, PROT_READ | PROT_WRITE,
+                      MAP_SHARED, buffer.m.planes[0].m.mem_offset);
     if (address == MAP_FAILED) {
       PLOG(ERROR) << "CreateOutputBuffers(): mmap() failed";
       return false;
     }
     output_buffer_map_[i].address = address;
     output_buffer_map_[i].length = buffer.m.planes[0].length;
     free_output_buffers_.push_back(i);
   }
 
   return true;
@@ skipping 30 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();
   free_output_buffers_.clear();
 }
 
-}  // namespace content
+}  // namespace media