media: Drop "media::" in 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>
@@ skipping 35 matching lines @@
 
 V4L2ImageProcessor::OutputRecord::OutputRecord() : at_device(false) {}
 
 V4L2ImageProcessor::OutputRecord::~OutputRecord() {}
 
 V4L2ImageProcessor::JobRecord::JobRecord() : output_buffer_index(-1) {}
 
 V4L2ImageProcessor::JobRecord::~JobRecord() {}
 
 V4L2ImageProcessor::V4L2ImageProcessor(const scoped_refptr<V4L2Device>& device)
-    : input_format_(media::PIXEL_FORMAT_UNKNOWN),
-      output_format_(media::PIXEL_FORMAT_UNKNOWN),
+    : input_format_(PIXEL_FORMAT_UNKNOWN),
+      output_format_(PIXEL_FORMAT_UNKNOWN),
       input_memory_type_(V4L2_MEMORY_USERPTR),
       input_format_fourcc_(0),
       output_format_fourcc_(0),
       input_planes_count_(0),
       output_planes_count_(0),
       child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       device_(device),
       device_thread_("V4L2ImageProcessorThread"),
       device_poll_thread_("V4L2ImageProcessorDevicePollThread"),
       input_streamon_(false),
@@ skipping 21 matching lines @@
       FROM_HERE, base::Bind(&V4L2ImageProcessor::NotifyErrorOnChildThread,
                             weak_this_, error_cb_));
 }
 
 void V4L2ImageProcessor::NotifyErrorOnChildThread(
     const base::Closure& error_cb) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   error_cb_.Run();
 }
 
-bool V4L2ImageProcessor::Initialize(media::VideoPixelFormat input_format,
-                                    media::VideoPixelFormat output_format,
+bool V4L2ImageProcessor::Initialize(VideoPixelFormat input_format,
+                                    VideoPixelFormat output_format,
                                     v4l2_memory input_memory_type,
                                     gfx::Size input_visible_size,
                                     gfx::Size input_allocated_size,
                                     gfx::Size output_visible_size,
                                     gfx::Size output_allocated_size,
                                     int num_buffers,
                                     const base::Closure& error_cb) {
   DCHECK(!error_cb.is_null());
   DCHECK_GT(num_buffers, 0);
   DCHECK(input_memory_type == V4L2_MEMORY_USERPTR ||
@@ skipping 37 matching lines @@
     return false;
   }
 
   // StartDevicePoll will NotifyError on failure, so IgnoreResult is fine here.
   device_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&V4L2ImageProcessor::StartDevicePoll),
                  base::Unretained(this)));
 
   DVLOG(1) << "V4L2ImageProcessor initialized for "
-           << " input_format:" << media::VideoPixelFormatToString(input_format)
-           << ", output_format:"
-           << media::VideoPixelFormatToString(output_format)
+           << " input_format:" << VideoPixelFormatToString(input_format)
+           << ", output_format:" << VideoPixelFormatToString(output_format)
            << ", input_visible_size: " << input_visible_size.ToString()
            << ", input_allocated_size: " << input_allocated_size_.ToString()
            << ", input_planes_count: " << input_planes_count_
            << ", output_visible_size: " << output_visible_size.ToString()
            << ", output_allocated_size: " << output_allocated_size_.ToString()
            << ", output_planes_count: " << output_planes_count_;
 
   return true;
 }
 
@@ skipping 40 matching lines @@
   format.fmt.pix_mp.pixelformat = pixelformat;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_TRY_FMT, &format);
 
   *num_planes = format.fmt.pix_mp.num_planes;
   *size = V4L2Device::CodedSizeFromV4L2Format(format);
   DVLOG(1) << __func__ << ": adjusted output coded size=" << size->ToString()
            << ", num_planes=" << *num_planes;
   return true;
 }
 
-void V4L2ImageProcessor::Process(const scoped_refptr<media::VideoFrame>& frame,
+void V4L2ImageProcessor::Process(const scoped_refptr<VideoFrame>& frame,
                                  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(
@@ skipping 360 matching lines @@
   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 = input_memory_type_;
   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_)
+        VideoFrame::PlaneSize(input_record.frame->format(), i,
+                              input_allocated_size_)
             .GetArea();
     qbuf.m.planes[i].length = qbuf.m.planes[i].bytesused;
     if (input_memory_type_ == V4L2_MEMORY_USERPTR) {
       qbuf.m.planes[i].m.userptr =
           reinterpret_cast<unsigned long>(input_record.frame->data(i));
     } else {
       qbuf.m.planes[i].m.fd = input_record.frame->dmabuf_fd(i);
     }
   }
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
@@ skipping 98 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 media