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

media/gpu/v4l2_jpeg_decode_accelerator.cc

 // Copyright 2015 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_jpeg_decode_accelerator.h"
 
 #include <errno.h>
 #include <linux/videodev2.h>
 #include <string.h>
 #include <sys/mman.h>
@@ skipping 95 matching lines @@
     0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4,
     0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
     0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA};
 
 V4L2JpegDecodeAccelerator::BufferRecord::BufferRecord()
     : address(nullptr), length(0), at_device(false) {}
 
 V4L2JpegDecodeAccelerator::BufferRecord::~BufferRecord() {}
 
 V4L2JpegDecodeAccelerator::JobRecord::JobRecord(
-    const media::BitstreamBuffer& bitstream_buffer,
-    scoped_refptr<media::VideoFrame> video_frame)
+    const BitstreamBuffer& bitstream_buffer,
+    scoped_refptr<VideoFrame> video_frame)
     : bitstream_buffer_id(bitstream_buffer.id()),
       shm(bitstream_buffer, true),
       out_frame(video_frame) {}
 
 V4L2JpegDecodeAccelerator::JobRecord::~JobRecord() {}
 
 V4L2JpegDecodeAccelerator::V4L2JpegDecodeAccelerator(
     const scoped_refptr<V4L2Device>& device,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : output_buffer_pixelformat_(0),
@@ skipping 91 matching lines @@
 
   decoder_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2JpegDecodeAccelerator::StartDevicePoll,
                             base::Unretained(this)));
 
   DVLOG(1) << "V4L2JpegDecodeAccelerator initialized.";
   return true;
 }
 
 void V4L2JpegDecodeAccelerator::Decode(
-    const media::BitstreamBuffer& bitstream_buffer,
-    const scoped_refptr<media::VideoFrame>& video_frame) {
+    const BitstreamBuffer& bitstream_buffer,
+    const scoped_refptr<VideoFrame>& video_frame) {
   DVLOG(1) << "Decode(): input_id=" << bitstream_buffer.id()
            << ", size=" << bitstream_buffer.size();
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (bitstream_buffer.id() < 0) {
     LOG(ERROR) << "Invalid bitstream_buffer, id: " << bitstream_buffer.id();
     if (base::SharedMemory::IsHandleValid(bitstream_buffer.handle()))
       base::SharedMemory::CloseHandle(bitstream_buffer.handle());
     PostNotifyError(bitstream_buffer.id(), INVALID_ARGUMENT);
     return;
   }
 
-  if (video_frame->format() != media::PIXEL_FORMAT_I420) {
+  if (video_frame->format() != PIXEL_FORMAT_I420) {
     PostNotifyError(bitstream_buffer.id(), UNSUPPORTED_JPEG);
     return;
   }
 
   std::unique_ptr<JobRecord> job_record(
       new JobRecord(bitstream_buffer, video_frame));
 
   decoder_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2JpegDecodeAccelerator::DecodeTask,
                             base::Unretained(this), base::Passed(&job_record)));
@@ skipping 127 matching lines @@
   return true;
 }
 
 bool V4L2JpegDecodeAccelerator::CreateOutputBuffers() {
   DVLOG(3) << __func__;
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
   DCHECK(!running_jobs_.empty());
   linked_ptr<JobRecord> job_record = running_jobs_.front();
 
-  size_t frame_size = media::VideoFrame::AllocationSize(
-      media::PIXEL_FORMAT_I420, job_record->out_frame->coded_size());
+  size_t frame_size = VideoFrame::AllocationSize(
+      PIXEL_FORMAT_I420, job_record->out_frame->coded_size());
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   format.fmt.pix.width = job_record->out_frame->coded_size().width();
   format.fmt.pix.height = job_record->out_frame->coded_size().height();
   format.fmt.pix.sizeimage = frame_size;
   format.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
   format.fmt.pix.field = V4L2_FIELD_ANY;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
   output_buffer_pixelformat_ = format.fmt.pix.pixelformat;
   output_buffer_coded_size_.SetSize(format.fmt.pix.width,
                                     format.fmt.pix.height);
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = kBufferCount;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
 
   DCHECK(output_buffer_map_.empty());
   output_buffer_map_.resize(reqbufs.count);
 
-  media::VideoPixelFormat output_format =
+  VideoPixelFormat output_format =
       V4L2Device::V4L2PixFmtToVideoPixelFormat(output_buffer_pixelformat_);
 
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     free_output_buffers_.push_back(i);
 
     struct v4l2_buffer buffer;
     memset(&buffer, 0, sizeof(buffer));
     buffer.index = i;
     buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     buffer.memory = V4L2_MEMORY_MMAP;
     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYBUF, &buffer);
 
     DCHECK_GE(buffer.length,
-              media::VideoFrame::AllocationSize(
+              VideoFrame::AllocationSize(
                   output_format,
                   gfx::Size(format.fmt.pix.width, format.fmt.pix.height)));
 
     void* address = device_->Mmap(NULL, buffer.length, PROT_READ | PROT_WRITE,
                                   MAP_SHARED, buffer.m.offset);
     if (address == MAP_FAILED) {
       PLOG(ERROR) << __func__ << ": mmap() failed";
       PostNotifyError(kInvalidBitstreamBufferId, PLATFORM_FAILURE);
       return false;
     }
@@ skipping 168 matching lines @@
   if (!output_streamon_ && OutputBufferQueuedCount()) {
     __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMON, &type);
     output_streamon_ = true;
   }
 }
 
 static bool CopyOutputImage(const uint32_t src_pixelformat,
                             const void* src_addr,
                             const gfx::Size& src_coded_size,
-                            const scoped_refptr<media::VideoFrame>& dst_frame) {
-  media::VideoPixelFormat format =
+                            const scoped_refptr<VideoFrame>& dst_frame) {
+  VideoPixelFormat format =
       V4L2Device::V4L2PixFmtToVideoPixelFormat(src_pixelformat);
-  size_t src_size = media::VideoFrame::AllocationSize(format, src_coded_size);
-  uint8_t* dst_y = dst_frame->data(media::VideoFrame::kYPlane);
-  uint8_t* dst_u = dst_frame->data(media::VideoFrame::kUPlane);
-  uint8_t* dst_v = dst_frame->data(media::VideoFrame::kVPlane);
-  size_t dst_y_stride = dst_frame->stride(media::VideoFrame::kYPlane);
-  size_t dst_u_stride = dst_frame->stride(media::VideoFrame::kUPlane);
-  size_t dst_v_stride = dst_frame->stride(media::VideoFrame::kVPlane);
+  size_t src_size = VideoFrame::AllocationSize(format, src_coded_size);
+  uint8_t* dst_y = dst_frame->data(VideoFrame::kYPlane);
+  uint8_t* dst_u = dst_frame->data(VideoFrame::kUPlane);
+  uint8_t* dst_v = dst_frame->data(VideoFrame::kVPlane);
+  size_t dst_y_stride = dst_frame->stride(VideoFrame::kYPlane);
+  size_t dst_u_stride = dst_frame->stride(VideoFrame::kUPlane);
+  size_t dst_v_stride = dst_frame->stride(VideoFrame::kVPlane);
 
   // If the source format is I420, ConvertToI420 will simply copy the frame.
   if (libyuv::ConvertToI420(static_cast<uint8_t*>(const_cast<void*>(src_addr)),
                             src_size,
                             dst_y, dst_y_stride,
                             dst_u, dst_u_stride,
                             dst_v, dst_v_stride,
                             0, 0,
                             src_coded_size.width(),
                             src_coded_size.height(),
@@ skipping 100 matching lines @@
   DCHECK(input_ptr);
   DCHECK(output_ptr);
   DCHECK_LE((input_size + sizeof(kDefaultDhtSeg)), output_size);
 
   base::BigEndianReader reader(static_cast<const char*>(input_ptr), input_size);
   bool has_marker_dht = false;
   bool has_marker_sos = false;
   uint8_t marker1, marker2;
   READ_U8_OR_RETURN_FALSE(reader, &marker1);
   READ_U8_OR_RETURN_FALSE(reader, &marker2);
-  if (marker1 != media::JPEG_MARKER_PREFIX || marker2 != media::JPEG_SOI) {
+  if (marker1 != JPEG_MARKER_PREFIX || marker2 != JPEG_SOI) {
     DLOG(ERROR) << __func__ << ": The input is not a Jpeg";
     return false;
   }
 
   // copy SOI marker (0xFF, 0xD8)
   memcpy(output_ptr, input_ptr, 2);
   size_t current_offset = 2;
 
   while (!has_marker_sos && !has_marker_dht) {
     const char* start_addr = reader.ptr();
     READ_U8_OR_RETURN_FALSE(reader, &marker1);
-    if (marker1 != media::JPEG_MARKER_PREFIX) {
+    if (marker1 != JPEG_MARKER_PREFIX) {
       DLOG(ERROR) << __func__ << ": marker1 != 0xFF";
       return false;
     }
     do {
       READ_U8_OR_RETURN_FALSE(reader, &marker2);
-    } while (marker2 == media::JPEG_MARKER_PREFIX);  // skip fill bytes
+    } while (marker2 == JPEG_MARKER_PREFIX);  // skip fill bytes
 
     uint16_t size;
     READ_U16_OR_RETURN_FALSE(reader, &size);
     // The size includes the size field itself.
     if (size < sizeof(size)) {
       DLOG(ERROR) << __func__ << ": Ill-formed JPEG. Segment size (" << size
                   << ") is smaller than size field (" << sizeof(size) << ")";
       return false;
     }
     size -= sizeof(size);
 
     switch (marker2) {
-      case media::JPEG_DHT: {
+      case JPEG_DHT: {
         has_marker_dht = true;
         break;
       }
-      case media::JPEG_SOS: {
+      case JPEG_SOS: {
         if (!has_marker_dht) {
           memcpy(static_cast<uint8_t*>(output_ptr) + current_offset,
                  kDefaultDhtSeg, sizeof(kDefaultDhtSeg));
           current_offset += sizeof(kDefaultDhtSeg);
         }
         has_marker_sos = true;
         break;
       }
       default:
         break;
@@ skipping 95 matching lines @@
   device_poll_thread_.Stop();
 
   // Clear the interrupt now, to be sure.
   if (!device_->ClearDevicePollInterrupt())
     return false;
 
   return true;
 }
 
 }  // namespace media