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

media/gpu/v4l2_video_decode_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_decode_accelerator.h"
 
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
@@ skipping 67 matching lines @@
 };
 
 struct V4L2VideoDecodeAccelerator::EGLSyncKHRRef {
   EGLSyncKHRRef(EGLDisplay egl_display, EGLSyncKHR egl_sync);
   ~EGLSyncKHRRef();
   EGLDisplay const egl_display;
   EGLSyncKHR egl_sync;
 };
 
 struct V4L2VideoDecodeAccelerator::PictureRecord {
-  PictureRecord(bool cleared, const media::Picture& picture);
+  PictureRecord(bool cleared, const Picture& picture);
   ~PictureRecord();
   bool cleared;  // Whether the texture is cleared and safe to render from.
-  media::Picture picture;  // The decoded picture.
+  Picture picture;  // The decoded picture.
 };
 
 V4L2VideoDecodeAccelerator::BitstreamBufferRef::BitstreamBufferRef(
     base::WeakPtr<Client>& client,
     scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner,
     std::unique_ptr<SharedMemoryRegion> shm,
     int32_t input_id)
     : client(client),
       client_task_runner(client_task_runner),
       shm(std::move(shm)),
@@ skipping 27 matching lines @@
 
 V4L2VideoDecodeAccelerator::OutputRecord::OutputRecord()
     : state(kFree),
       egl_image(EGL_NO_IMAGE_KHR),
       egl_sync(EGL_NO_SYNC_KHR),
       picture_id(-1),
       cleared(false) {}
 
 V4L2VideoDecodeAccelerator::OutputRecord::~OutputRecord() {}
 
-V4L2VideoDecodeAccelerator::PictureRecord::PictureRecord(
-    bool cleared,
-    const media::Picture& picture)
+V4L2VideoDecodeAccelerator::PictureRecord::PictureRecord(bool cleared,
+                                                         const Picture& picture)
     : cleared(cleared), picture(picture) {}
 
 V4L2VideoDecodeAccelerator::PictureRecord::~PictureRecord() {}
 
 V4L2VideoDecodeAccelerator::V4L2VideoDecodeAccelerator(
     EGLDisplay egl_display,
     const GetGLContextCallback& get_gl_context_cb,
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const scoped_refptr<V4L2Device>& device)
     : child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ skipping 13 matching lines @@
       output_buffer_queued_count_(0),
       output_dpb_size_(0),
       output_planes_count_(0),
       picture_clearing_count_(0),
       pictures_assigned_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                          base::WaitableEvent::InitialState::NOT_SIGNALED),
       device_poll_thread_("V4L2DevicePollThread"),
       egl_display_(egl_display),
       get_gl_context_cb_(get_gl_context_cb),
       make_context_current_cb_(make_context_current_cb),
-      video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
+      video_profile_(VIDEO_CODEC_PROFILE_UNKNOWN),
       output_format_fourcc_(0),
       egl_image_format_fourcc_(0),
       egl_image_planes_count_(0),
       weak_this_factory_(this) {
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 V4L2VideoDecodeAccelerator::~V4L2VideoDecodeAccelerator() {
   DCHECK(!decoder_thread_.IsRunning());
   DCHECK(!device_poll_thread_.IsRunning());
@@ skipping 79 matching lines @@
 
   if (!SetupFormats())
     return false;
 
   // Subscribe to the resolution change event.
   struct v4l2_event_subscription sub;
   memset(&sub, 0, sizeof(sub));
   sub.type = V4L2_EVENT_SOURCE_CHANGE;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_SUBSCRIBE_EVENT, &sub);
 
-  if (video_profile_ >= media::H264PROFILE_MIN &&
-      video_profile_ <= media::H264PROFILE_MAX) {
-    decoder_h264_parser_.reset(new media::H264Parser());
+  if (video_profile_ >= H264PROFILE_MIN && video_profile_ <= H264PROFILE_MAX) {
+    decoder_h264_parser_.reset(new H264Parser());
   }
 
   if (!CreateInputBuffers())
     return false;
 
   if (!decoder_thread_.Start()) {
     LOG(ERROR) << "Initialize(): decoder thread failed to start";
     return false;
   }
 
   decoder_state_ = kInitialized;
 
   // StartDevicePoll will NOTIFY_ERROR on failure, so IgnoreResult is fine here.
   decoder_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(base::IgnoreResult(
                                 &V4L2VideoDecodeAccelerator::StartDevicePoll),
                             base::Unretained(this)));
 
   return true;
 }
 
 void V4L2VideoDecodeAccelerator::Decode(
-    const media::BitstreamBuffer& bitstream_buffer) {
+    const BitstreamBuffer& bitstream_buffer) {
   DVLOG(1) << "Decode(): input_id=" << bitstream_buffer.id()
            << ", size=" << bitstream_buffer.size();
   DCHECK(decode_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());
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
   // DecodeTask() will take care of running a DecodeBufferTask().
   decoder_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&V4L2VideoDecodeAccelerator::DecodeTask,
                             base::Unretained(this), bitstream_buffer));
 }
 
 void V4L2VideoDecodeAccelerator::AssignPictureBuffers(
-    const std::vector<media::PictureBuffer>& buffers) {
+    const std::vector<PictureBuffer>& buffers) {
   DVLOG(3) << "AssignPictureBuffers(): buffer_count=" << buffers.size();
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   const uint32_t req_buffer_count =
       output_dpb_size_ + kDpbOutputBufferExtraCount;
 
   if (buffers.size() < req_buffer_count) {
     LOG(ERROR) << "AssignPictureBuffers(): Failed to provide requested picture"
                << " buffers. (Got " << buffers.size()
                << ", requested " << req_buffer_count << ")";
@@ skipping 183 matching lines @@
 
 bool V4L2VideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
     const base::WeakPtr<Client>& decode_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   decode_client_ = decode_client;
   decode_task_runner_ = decode_task_runner;
   return true;
 }
 
 // static
-media::VideoDecodeAccelerator::SupportedProfiles
+VideoDecodeAccelerator::SupportedProfiles
 V4L2VideoDecodeAccelerator::GetSupportedProfiles() {
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (!device)
     return SupportedProfiles();
 
   return device->GetSupportedDecodeProfiles(arraysize(supported_input_fourccs_),
                                             supported_input_fourccs_);
 }
 
 void V4L2VideoDecodeAccelerator::DecodeTask(
-    const media::BitstreamBuffer& bitstream_buffer) {
+    const BitstreamBuffer& bitstream_buffer) {
   DVLOG(3) << "DecodeTask(): input_id=" << bitstream_buffer.id();
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT1("Video Decoder", "V4L2VDA::DecodeTask", "input_id",
                bitstream_buffer.id());
 
   std::unique_ptr<BitstreamBufferRef> bitstream_record(new BitstreamBufferRef(
       decode_client_, decode_task_runner_,
       std::unique_ptr<SharedMemoryRegion>(
           new SharedMemoryRegion(bitstream_buffer, true)),
@@ skipping 143 matching lines @@
       // BitstreamBufferRef destructor calls NotifyEndOfBitstreamBuffer().
       decoder_current_bitstream_buffer_.reset();
     }
     ScheduleDecodeBufferTaskIfNeeded();
   }
 }
 
 bool V4L2VideoDecodeAccelerator::AdvanceFrameFragment(const uint8_t* data,
                                                       size_t size,
                                                       size_t* endpos) {
-  if (video_profile_ >= media::H264PROFILE_MIN &&
-      video_profile_ <= media::H264PROFILE_MAX) {
+  if (video_profile_ >= H264PROFILE_MIN && video_profile_ <= H264PROFILE_MAX) {
     // For H264, we need to feed HW one frame at a time.  This is going to take
     // some parsing of our input stream.
     decoder_h264_parser_->SetStream(data, size);
-    media::H264NALU nalu;
-    media::H264Parser::Result result;
+    H264NALU nalu;
+    H264Parser::Result result;
     *endpos = 0;
 
     // Keep on peeking the next NALs while they don't indicate a frame
     // boundary.
     for (;;) {
       bool end_of_frame = false;
       result = decoder_h264_parser_->AdvanceToNextNALU(&nalu);
-      if (result == media::H264Parser::kInvalidStream ||
-          result == media::H264Parser::kUnsupportedStream)
+      if (result == H264Parser::kInvalidStream ||
+          result == H264Parser::kUnsupportedStream)
         return false;
-      if (result == media::H264Parser::kEOStream) {
+      if (result == H264Parser::kEOStream) {
         // We've reached the end of the buffer before finding a frame boundary.
         decoder_partial_frame_pending_ = true;
         return true;
       }
       switch (nalu.nal_unit_type) {
-        case media::H264NALU::kNonIDRSlice:
-        case media::H264NALU::kIDRSlice:
+        case H264NALU::kNonIDRSlice:
+        case H264NALU::kIDRSlice:
           if (nalu.size < 1)
             return false;
           // For these two, if the "first_mb_in_slice" field is zero, start a
           // new frame and return.  This field is Exp-Golomb coded starting on
           // the eighth data bit of the NAL; a zero value is encoded with a
           // leading '1' bit in the byte, which we can detect as the byte being
           // (unsigned) greater than or equal to 0x80.
           if (nalu.data[1] >= 0x80) {
             end_of_frame = true;
             break;
           }
           break;
-        case media::H264NALU::kSEIMessage:
-        case media::H264NALU::kSPS:
-        case media::H264NALU::kPPS:
-        case media::H264NALU::kAUD:
-        case media::H264NALU::kEOSeq:
-        case media::H264NALU::kEOStream:
-        case media::H264NALU::kReserved14:
-        case media::H264NALU::kReserved15:
-        case media::H264NALU::kReserved16:
-        case media::H264NALU::kReserved17:
-        case media::H264NALU::kReserved18:
+        case H264NALU::kSEIMessage:
+        case H264NALU::kSPS:
+        case H264NALU::kPPS:
+        case H264NALU::kAUD:
+        case H264NALU::kEOSeq:
+        case H264NALU::kEOStream:
+        case H264NALU::kReserved14:
+        case H264NALU::kReserved15:
+        case H264NALU::kReserved16:
+        case H264NALU::kReserved17:
+        case H264NALU::kReserved18:
           // These unconditionally signal a frame boundary.
           end_of_frame = true;
           break;
         default:
           // For all others, keep going.
           break;
       }
       if (end_of_frame) {
         if (!decoder_partial_frame_pending_ && *endpos == 0) {
           // The frame was previously restarted, and we haven't filled the
           // current frame with any contents yet.  Start the new frame here and
           // continue parsing NALs.
         } else {
           // The frame wasn't previously restarted and/or we have contents for
           // the current frame; signal the start of a new frame here: we don't
           // have a partial frame anymore.
           decoder_partial_frame_pending_ = false;
           return true;
         }
       }
       *endpos = (nalu.data + nalu.size) - data;
     }
     NOTREACHED();
     return false;
   } else {
-    DCHECK_GE(video_profile_, media::VP8PROFILE_MIN);
-    DCHECK_LE(video_profile_, media::VP9PROFILE_MAX);
+    DCHECK_GE(video_profile_, VP8PROFILE_MIN);
+    DCHECK_LE(video_profile_, VP9PROFILE_MAX);
     // For VP8/9, we can just dump the entire buffer.  No fragmentation needed,
     // and we never return a partial frame.
     *endpos = size;
     decoder_partial_frame_pending_ = false;
     return true;
   }
 }
 
 void V4L2VideoDecodeAccelerator::ScheduleDecodeBufferTaskIfNeeded() {
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
@@ skipping 385 matching lines @@
       DCHECK_GE(bitstream_buffer_id, 0);
       DVLOG(3) << "Dequeue output buffer: dqbuf index=" << dqbuf.index
                << " bitstream input_id=" << bitstream_buffer_id;
       if (image_processor_device_) {
         output_record.state = kAtProcessor;
         image_processor_bitstream_buffer_ids_.push(bitstream_buffer_id);
         std::vector<int> fds;
         for (auto& fd : output_record.fds) {
           fds.push_back(fd.get());
         }
-        scoped_refptr<media::VideoFrame> frame =
-            media::VideoFrame::WrapExternalDmabufs(
-                V4L2Device::V4L2PixFmtToVideoPixelFormat(output_format_fourcc_),
-                coded_size_, gfx::Rect(visible_size_), visible_size_, fds,
-                base::TimeDelta());
+        scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalDmabufs(
+            V4L2Device::V4L2PixFmtToVideoPixelFormat(output_format_fourcc_),
+            coded_size_, gfx::Rect(visible_size_), visible_size_, fds,
+            base::TimeDelta());
         // Unretained is safe because |this| owns image processor and there will
         // be no callbacks after processor destroys. Also, this class ensures it
         // is safe to post a task from child thread to decoder thread using
         // Unretained.
         image_processor_->Process(
             frame, dqbuf.index,
-            media::BindToCurrentLoop(
+            BindToCurrentLoop(
                 base::Bind(&V4L2VideoDecodeAccelerator::FrameProcessed,
                            base::Unretained(this), bitstream_buffer_id)));
       } else {
         output_record.state = kAtClient;
         decoder_frames_at_client_++;
-        const media::Picture picture(output_record.picture_id,
-                                     bitstream_buffer_id,
-                                     gfx::Rect(visible_size_), false);
+        const Picture picture(output_record.picture_id, bitstream_buffer_id,
+                              gfx::Rect(visible_size_), false);
         pending_picture_ready_.push(
             PictureRecord(output_record.cleared, picture));
         SendPictureReady();
         output_record.cleared = true;
       }
     }
   }
 
   NotifyFlushDoneIfNeeded();
 }
@@ skipping 270 matching lines @@
 
   if (decoder_state_ == kError) {
     DVLOG(2) << "ResetDoneTask(): early out: kError state";
     return;
   }
 
   if (!StartDevicePoll())
     return;
 
   // Reset format-specific bits.
-  if (video_profile_ >= media::H264PROFILE_MIN &&
-      video_profile_ <= media::H264PROFILE_MAX) {
-    decoder_h264_parser_.reset(new media::H264Parser());
+  if (video_profile_ >= H264PROFILE_MIN && video_profile_ <= H264PROFILE_MAX) {
+    decoder_h264_parser_.reset(new H264Parser());
   }
 
   // Jobs drained, we're finished resetting.
   DCHECK_EQ(decoder_state_, kResetting);
   if (output_buffer_map_.empty()) {
     // We must have gotten Reset() before we had a chance to request buffers
     // from the client.
     decoder_state_ = kInitialized;
   } else {
     decoder_state_ = kAfterReset;
@@ skipping 650 matching lines @@
                             base::Unretained(this)));
 }
 
 void V4L2VideoDecodeAccelerator::SendPictureReady() {
   DVLOG(3) << "SendPictureReady()";
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   bool resetting_or_flushing =
       (decoder_state_ == kResetting || decoder_flushing_);
   while (pending_picture_ready_.size() > 0) {
     bool cleared = pending_picture_ready_.front().cleared;
-    const media::Picture& picture = pending_picture_ready_.front().picture;
+    const Picture& picture = pending_picture_ready_.front().picture;
     if (cleared && picture_clearing_count_ == 0) {
       // This picture is cleared. It can be posted to a thread different than
       // the main GPU thread to reduce latency. This should be the case after
       // all pictures are cleared at the beginning.
       decode_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&Client::PictureReady, decode_client_, picture));
       pending_picture_ready_.pop();
     } else if (!cleared || resetting_or_flushing) {
       DVLOG(3) << "SendPictureReady()"
@@ skipping 42 matching lines @@
   DCHECK_EQ(output_record.state, kAtProcessor);
   if (!image_processor_bitstream_buffer_ids_.empty() &&
       image_processor_bitstream_buffer_ids_.front() == bitstream_buffer_id) {
     DVLOG(3) << __func__ << ": picture_id=" << output_record.picture_id;
     DCHECK_NE(output_record.egl_image, EGL_NO_IMAGE_KHR);
     DCHECK_NE(output_record.picture_id, -1);
     // Send the processed frame to render.
     output_record.state = kAtClient;
     decoder_frames_at_client_++;
     image_processor_bitstream_buffer_ids_.pop();
-    const media::Picture picture(output_record.picture_id, bitstream_buffer_id,
-                                 gfx::Rect(visible_size_), false);
+    const Picture picture(output_record.picture_id, bitstream_buffer_id,
+                          gfx::Rect(visible_size_), false);
     pending_picture_ready_.push(PictureRecord(output_record.cleared, picture));
     SendPictureReady();
     output_record.cleared = true;
     // Flush or resolution change may be waiting image processor to finish.
     if (image_processor_bitstream_buffer_ids_.empty()) {
       NotifyFlushDoneIfNeeded();
       if (decoder_state_ == kChangingResolution)
         StartResolutionChange();
     }
   } else {
     DVLOG(2) << "Bitstream buffer id " << bitstream_buffer_id << " not found "
              << "because of Reset. Drop the buffer";
     output_record.state = kFree;
     free_output_buffers_.push(output_buffer_index);
     Enqueue();
   }
 }
 
 void V4L2VideoDecodeAccelerator::ImageProcessorError() {
   LOG(ERROR) << "Image processor error";
   NOTIFY_ERROR(PLATFORM_FAILURE);
 }
 
 }  // namespace media