media: Drop "media::" in media/gpu

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>
@@ skipping 62 matching lines @@
     ImageProcessorInputRecord()
     : force_keyframe(false) {}
 
 V4L2VideoEncodeAccelerator::ImageProcessorInputRecord::
     ~ImageProcessorInputRecord() {}
 
 V4L2VideoEncodeAccelerator::V4L2VideoEncodeAccelerator(
     const scoped_refptr<V4L2Device>& device)
     : child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       output_buffer_byte_size_(0),
-      device_input_format_(media::PIXEL_FORMAT_UNKNOWN),
+      device_input_format_(PIXEL_FORMAT_UNKNOWN),
       input_planes_count_(0),
       output_format_fourcc_(0),
       encoder_state_(kUninitialized),
       stream_header_size_(0),
       device_(device),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       input_memory_type_(V4L2_MEMORY_USERPTR),
       output_streamon_(false),
       output_buffer_queued_count_(0),
       encoder_thread_("V4L2EncoderThread"),
       device_poll_thread_("V4L2EncoderDevicePollThread"),
       weak_this_ptr_factory_(this) {
   weak_this_ = weak_this_ptr_factory_.GetWeakPtr();
 }
 
 V4L2VideoEncodeAccelerator::~V4L2VideoEncodeAccelerator() {
   DCHECK(!encoder_thread_.IsRunning());
   DCHECK(!device_poll_thread_.IsRunning());
   DVLOG(4) << __func__;
 
   DestroyInputBuffers();
   DestroyOutputBuffers();
 }
 
-bool V4L2VideoEncodeAccelerator::Initialize(
-    media::VideoPixelFormat input_format,
-    const gfx::Size& input_visible_size,
-    media::VideoCodecProfile output_profile,
-    uint32_t initial_bitrate,
-    Client* client) {
+bool V4L2VideoEncodeAccelerator::Initialize(VideoPixelFormat input_format,
+                                            const gfx::Size& input_visible_size,
+                                            VideoCodecProfile output_profile,
+                                            uint32_t initial_bitrate,
+                                            Client* client) {
   DVLOG(3) << __func__
-           << ": input_format=" << media::VideoPixelFormatToString(input_format)
+           << ": input_format=" << VideoPixelFormatToString(input_format)
            << ", input_visible_size=" << input_visible_size.ToString()
            << ", output_profile=" << output_profile
            << ", initial_bitrate=" << initial_bitrate;
 
   visible_size_ = input_visible_size;
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
 
   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;
     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 "
-             << media::VideoPixelFormatToString(device_input_format_);
+             << VideoPixelFormatToString(device_input_format_);
 
     scoped_refptr<V4L2Device> device =
         V4L2Device::Create(V4L2Device::kImageProcessor);
     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(
@@ skipping 56 matching lines @@
                      : input_allocated_size_,
                  output_buffer_byte_size_));
   return true;
 }
 
 void V4L2VideoEncodeAccelerator::ImageProcessorError() {
   LOG(ERROR) << "Image processor error";
   NOTIFY_ERROR(kPlatformFailureError);
 }
 
-void V4L2VideoEncodeAccelerator::Encode(
-    const scoped_refptr<media::VideoFrame>& frame,
-    bool force_keyframe) {
+void V4L2VideoEncodeAccelerator::Encode(const scoped_refptr<VideoFrame>& frame,
+                                        bool force_keyframe) {
   DVLOG(3) << "Encode(): force_keyframe=" << force_keyframe;
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (image_processor_) {
     if (free_image_processor_output_buffers_.size() > 0) {
       int output_buffer_index = free_image_processor_output_buffers_.back();
       free_image_processor_output_buffers_.pop_back();
       // Unretained is safe because |this| owns image processor and there will
       // be no callbacks after processor destroys.
       image_processor_->Process(
           frame, output_buffer_index,
           base::Bind(&V4L2VideoEncodeAccelerator::FrameProcessed,
                      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));
   }
 }
 
 void V4L2VideoEncodeAccelerator::UseOutputBitstreamBuffer(
-    const media::BitstreamBuffer& buffer) {
+    const 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));
@@ skipping 47 matching lines @@
     // Otherwise, call the destroy task directly.
     DestroyTask();
   }
 
   // Set to kError state just in case.
   encoder_state_ = kError;
 
   delete this;
 }
 
-media::VideoEncodeAccelerator::SupportedProfiles
+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);
     switch (fmtdesc.pixelformat) {
       case V4L2_PIX_FMT_H264:
-        profile.profile = media::H264PROFILE_MAIN;
+        profile.profile = H264PROFILE_MAIN;
         profiles.push_back(profile);
         break;
       case V4L2_PIX_FMT_VP8:
-        profile.profile = media::VP8PROFILE_ANY;
+        profile.profile = VP8PROFILE_ANY;
         profiles.push_back(profile);
         break;
       case V4L2_PIX_FMT_VP9:
-        profile.profile = media::VP9PROFILE_PROFILE0;
+        profile.profile = VP9PROFILE_PROFILE0;
         profiles.push_back(profile);
-        profile.profile = media::VP9PROFILE_PROFILE1;
+        profile.profile = VP9PROFILE_PROFILE1;
         profiles.push_back(profile);
-        profile.profile = media::VP9PROFILE_PROFILE2;
+        profile.profile = VP9PROFILE_PROFILE2;
         profiles.push_back(profile);
-        profile.profile = media::VP9PROFILE_PROFILE3;
+        profile.profile = VP9PROFILE_PROFILE3;
         profiles.push_back(profile);
         break;
     }
   }
 
   return profiles;
 }
 
 void V4L2VideoEncodeAccelerator::FrameProcessed(bool force_keyframe,
                                                 base::TimeDelta timestamp,
                                                 int output_buffer_index) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DVLOG(3) << "FrameProcessed(): force_keyframe=" << force_keyframe
            << ", output_buffer_index=" << output_buffer_index;
   DCHECK_GE(output_buffer_index, 0);
   DCHECK_LT(static_cast<size_t>(output_buffer_index),
             image_processor_output_buffer_map_.size());
 
   std::vector<base::ScopedFD>& scoped_fds =
       image_processor_output_buffer_map_[output_buffer_index];
   std::vector<int> fds;
   for (auto& fd : scoped_fds) {
     fds.push_back(fd.get());
   }
-  scoped_refptr<media::VideoFrame> output_frame =
-      media::VideoFrame::WrapExternalDmabufs(
-          device_input_format_, image_processor_->output_allocated_size(),
-          gfx::Rect(visible_size_), visible_size_, fds, timestamp);
+  scoped_refptr<VideoFrame> output_frame = VideoFrame::WrapExternalDmabufs(
+      device_input_format_, image_processor_->output_allocated_size(),
+      gfx::Rect(visible_size_), visible_size_, fds, timestamp);
   if (!output_frame) {
     NOTIFY_ERROR(kPlatformFailureError);
     return;
   }
-  output_frame->AddDestructionObserver(media::BindToCurrentLoop(
+  output_frame->AddDestructionObserver(BindToCurrentLoop(
       base::Bind(&V4L2VideoEncodeAccelerator::ReuseImageProcessorOutputBuffer,
                  weak_this_, output_buffer_index)));
 
   encoder_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&V4L2VideoEncodeAccelerator::EncodeTask,
                  base::Unretained(this), output_frame, force_keyframe));
 }
 
 void V4L2VideoEncodeAccelerator::ReuseImageProcessorOutputBuffer(
     int output_buffer_index) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DVLOG(3) << __func__ << ": output_buffer_index=" << output_buffer_index;
   free_image_processor_output_buffers_.push_back(output_buffer_index);
   if (!image_processor_input_queue_.empty()) {
     ImageProcessorInputRecord record = image_processor_input_queue_.front();
     image_processor_input_queue_.pop();
     Encode(record.frame, record.force_keyframe);
   }
 }
 
 void V4L2VideoEncodeAccelerator::EncodeTask(
-    const scoped_refptr<media::VideoFrame>& frame,
+    const scoped_refptr<VideoFrame>& frame,
     bool force_keyframe) {
   DVLOG(3) << "EncodeTask(): force_keyframe=" << force_keyframe;
   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(encoder_state_, kUninitialized);
 
   if (encoder_state_ == kError) {
     DVLOG(2) << "EncodeTask(): early out: kError state";
     return;
   }
 
@@ skipping 258 matching lines @@
     output_buffer_queued_count_--;
   }
 }
 
 bool V4L2VideoEncodeAccelerator::EnqueueInputRecord() {
   DVLOG(3) << "EnqueueInputRecord()";
   DCHECK(!free_input_buffers_.empty());
   DCHECK(!encoder_input_queue_.empty());
 
   // Enqueue an input (VIDEO_OUTPUT) buffer.
-  scoped_refptr<media::VideoFrame> frame = encoder_input_queue_.front();
+  scoped_refptr<VideoFrame> frame = encoder_input_queue_.front();
   const int index = free_input_buffers_.back();
   InputRecord& input_record = input_buffer_map_[index];
   DCHECK(!input_record.at_device);
   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;
   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>(
-        media::VideoFrame::PlaneSize(frame->format(), i, input_allocated_size_)
+        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;
 
@@ skipping 199 matching lines @@
   memset(&parms, 0, sizeof(parms));
   parms.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   // Note that we are provided "frames per second" but V4L2 expects "time per
   // frame"; hence we provide the reciprocal of the framerate here.
   parms.parm.output.timeperframe.numerator = 1;
   parms.parm.output.timeperframe.denominator = framerate;
   IOCTL_OR_ERROR_RETURN(VIDIOC_S_PARM, &parms);
 }
 
 bool V4L2VideoEncodeAccelerator::SetOutputFormat(
-    media::VideoCodecProfile output_profile) {
+    VideoCodecProfile output_profile) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
   DCHECK(!output_streamon_);
 
   output_format_fourcc_ =
       V4L2Device::VideoCodecProfileToV4L2PixFmt(output_profile, false);
   if (!output_format_fourcc_) {
     LOG(ERROR) << "Initialize(): invalid output_profile=" << output_profile;
     return false;
   }
@@ skipping 13 matching lines @@
 
   // Device might have adjusted the required output size.
   size_t adjusted_output_buffer_size =
       base::checked_cast<size_t>(format.fmt.pix_mp.plane_fmt[0].sizeimage);
   output_buffer_byte_size_ = adjusted_output_buffer_size;
 
   return true;
 }
 
 bool V4L2VideoEncodeAccelerator::NegotiateInputFormat(
-    media::VideoPixelFormat input_format) {
+    VideoPixelFormat input_format) {
   DVLOG(3) << "NegotiateInputFormat()";
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
   DCHECK(!output_streamon_);
 
-  device_input_format_ = media::PIXEL_FORMAT_UNKNOWN;
+  device_input_format_ = PIXEL_FORMAT_UNKNOWN;
   input_planes_count_ = 0;
 
   uint32_t input_format_fourcc =
       V4L2Device::VideoPixelFormatToV4L2PixFmt(input_format);
   if (!input_format_fourcc) {
     LOG(ERROR) << "Unsupported input format" << input_format_fourcc;
     return false;
   }
 
-  size_t input_planes_count = media::VideoFrame::NumPlanes(input_format);
+  size_t input_planes_count = VideoFrame::NumPlanes(input_format);
   DCHECK_LE(input_planes_count, static_cast<size_t>(VIDEO_MAX_PLANES));
 
   // First see if we the device can use the provided input_format directly.
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   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;
   if (device_->Ioctl(VIDIOC_S_FMT, &format) != 0) {
     // Error or format unsupported by device, try to negotiate a fallback.
     input_format_fourcc = device_->PreferredInputFormat();
     input_format =
         V4L2Device::V4L2PixFmtToVideoPixelFormat(input_format_fourcc);
-    if (input_format == media::PIXEL_FORMAT_UNKNOWN) {
+    if (input_format == PIXEL_FORMAT_UNKNOWN) {
       LOG(ERROR) << "Unsupported input format" << input_format_fourcc;
       return false;
     }
 
-    input_planes_count = media::VideoFrame::NumPlanes(input_format);
+    input_planes_count = VideoFrame::NumPlanes(input_format);
     DCHECK_LE(input_planes_count, static_cast<size_t>(VIDEO_MAX_PLANES));
 
     // Device might have adjusted parameters, reset them along with the format.
     memset(&format, 0, sizeof(format));
     format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
     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_))) {
     DVLOG(1) << "Input size too big " << visible_size_.ToString()
              << ", adjusted to " << input_allocated_size_.ToString();
     return false;
   }
 
   device_input_format_ = input_format;
   input_planes_count_ = input_planes_count;
   return true;
 }
 
-bool V4L2VideoEncodeAccelerator::SetFormats(
-    media::VideoPixelFormat input_format,
-    media::VideoCodecProfile output_profile) {
+bool V4L2VideoEncodeAccelerator::SetFormats(VideoPixelFormat input_format,
+                                            VideoCodecProfile output_profile) {
   DVLOG(3) << "SetFormats()";
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
   DCHECK(!output_streamon_);
 
   if (!SetOutputFormat(output_profile))
     return false;
 
   if (!NegotiateInputFormat(input_format))
     return false;
@@ skipping 218 matching lines @@
   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 media