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

media/gpu/v4l2_slice_video_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_slice_video_decode_accelerator.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
@@ skipping 208 matching lines @@
 
 V4L2SliceVideoDecodeAccelerator::EGLSyncKHRRef::~EGLSyncKHRRef() {
   // We don't check for eglDestroySyncKHR failures, because if we get here
   // with a valid sync object, something went wrong and we are getting
   // destroyed anyway.
   if (egl_sync != EGL_NO_SYNC_KHR)
     eglDestroySyncKHR(egl_display, egl_sync);
 }
 
 struct V4L2SliceVideoDecodeAccelerator::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.
 };
 
 V4L2SliceVideoDecodeAccelerator::PictureRecord::PictureRecord(
     bool cleared,
-    const media::Picture& picture)
+    const Picture& picture)
     : cleared(cleared), picture(picture) {}
 
 V4L2SliceVideoDecodeAccelerator::PictureRecord::~PictureRecord() {}
 
 class V4L2SliceVideoDecodeAccelerator::V4L2H264Accelerator
     : public H264Decoder::H264Accelerator {
  public:
   V4L2H264Accelerator(V4L2SliceVideoDecodeAccelerator* v4l2_dec);
   ~V4L2H264Accelerator() override;
 
   // H264Decoder::H264Accelerator implementation.
   scoped_refptr<H264Picture> CreateH264Picture() override;
 
-  bool SubmitFrameMetadata(const media::H264SPS* sps,
-                           const media::H264PPS* pps,
+  bool SubmitFrameMetadata(const H264SPS* sps,
+                           const H264PPS* pps,
                            const H264DPB& dpb,
                            const H264Picture::Vector& ref_pic_listp0,
                            const H264Picture::Vector& ref_pic_listb0,
                            const H264Picture::Vector& ref_pic_listb1,
                            const scoped_refptr<H264Picture>& pic) override;
 
-  bool SubmitSlice(const media::H264PPS* pps,
-                   const media::H264SliceHeader* slice_hdr,
+  bool SubmitSlice(const H264PPS* pps,
+                   const H264SliceHeader* slice_hdr,
                    const H264Picture::Vector& ref_pic_list0,
                    const H264Picture::Vector& ref_pic_list1,
                    const scoped_refptr<H264Picture>& pic,
                    const uint8_t* data,
                    size_t size) override;
 
   bool SubmitDecode(const scoped_refptr<H264Picture>& pic) override;
   bool OutputPicture(const scoped_refptr<H264Picture>& pic) override;
 
   void Reset() override;
@@ skipping 25 matching lines @@
 class V4L2SliceVideoDecodeAccelerator::V4L2VP8Accelerator
     : public VP8Decoder::VP8Accelerator {
  public:
   V4L2VP8Accelerator(V4L2SliceVideoDecodeAccelerator* v4l2_dec);
   ~V4L2VP8Accelerator() override;
 
   // VP8Decoder::VP8Accelerator implementation.
   scoped_refptr<VP8Picture> CreateVP8Picture() override;
 
   bool SubmitDecode(const scoped_refptr<VP8Picture>& pic,
-                    const media::Vp8FrameHeader* frame_hdr,
+                    const Vp8FrameHeader* frame_hdr,
                     const scoped_refptr<VP8Picture>& last_frame,
                     const scoped_refptr<VP8Picture>& golden_frame,
                     const scoped_refptr<VP8Picture>& alt_frame) override;
 
   bool OutputPicture(const scoped_refptr<VP8Picture>& pic) override;
 
  private:
   scoped_refptr<V4L2DecodeSurface> VP8PictureToV4L2DecodeSurface(
       const scoped_refptr<VP8Picture>& pic);
 
@@ skipping 68 matching lines @@
     : input_planes_count_(0),
       output_planes_count_(0),
       child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       device_(device),
       decoder_thread_("V4L2SliceVideoDecodeAcceleratorThread"),
       device_poll_thread_("V4L2SliceVideoDecodeAcceleratorDevicePollThread"),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       output_streamon_(false),
       output_buffer_queued_count_(0),
-      video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
+      video_profile_(VIDEO_CODEC_PROFILE_UNKNOWN),
       output_format_fourcc_(0),
       state_(kUninitialized),
       output_mode_(Config::OutputMode::ALLOCATE),
       decoder_flushing_(false),
       decoder_resetting_(false),
       surface_set_change_pending_(false),
       picture_clearing_count_(0),
       egl_display_(egl_display),
       get_gl_context_cb_(get_gl_context_cb),
       make_context_current_cb_(make_context_current_cb),
@@ skipping 57 matching lines @@
   // TryToSetupDecodeOnSeparateThread(), use the main thread/client for
   // decode tasks.
   if (!decode_task_runner_) {
     decode_task_runner_ = child_task_runner_;
     DCHECK(!decode_client_);
     decode_client_ = client_;
   }
 
   video_profile_ = config.profile;
 
-  if (video_profile_ >= media::H264PROFILE_MIN &&
-      video_profile_ <= media::H264PROFILE_MAX) {
+  if (video_profile_ >= H264PROFILE_MIN && video_profile_ <= H264PROFILE_MAX) {
     h264_accelerator_.reset(new V4L2H264Accelerator(this));
     decoder_.reset(new H264Decoder(h264_accelerator_.get()));
-  } else if (video_profile_ >= media::VP8PROFILE_MIN &&
-             video_profile_ <= media::VP8PROFILE_MAX) {
+  } else if (video_profile_ >= VP8PROFILE_MIN &&
+             video_profile_ <= VP8PROFILE_MAX) {
     vp8_accelerator_.reset(new V4L2VP8Accelerator(this));
     decoder_.reset(new VP8Decoder(vp8_accelerator_.get()));
   } else {
     NOTREACHED() << "Unsupported profile " << video_profile_;
     return false;
   }
 
   // TODO(posciak): This needs to be queried once supported.
   input_planes_count_ = 1;
   output_planes_count_ = 1;
@@ skipping 745 matching lines @@
   // Drop all surfaces that were awaiting decode before being displayed,
   // since we've just cancelled all outstanding decodes.
   while (!decoder_display_queue_.empty())
     decoder_display_queue_.pop();
 
   DVLOGF(3) << "Device poll stopped";
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::Decode(
-    const media::BitstreamBuffer& bitstream_buffer) {
+    const BitstreamBuffer& bitstream_buffer) {
   DVLOGF(3) << "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;
   }
 
   decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::DecodeTask,
                             base::Unretained(this), bitstream_buffer));
 }
 
 void V4L2SliceVideoDecodeAccelerator::DecodeTask(
-    const media::BitstreamBuffer& bitstream_buffer) {
+    const BitstreamBuffer& bitstream_buffer) {
   DVLOGF(3) << "input_id=" << bitstream_buffer.id()
             << " size=" << bitstream_buffer.size();
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   std::unique_ptr<BitstreamBufferRef> bitstream_record(new BitstreamBufferRef(
       decode_client_, decode_task_runner_,
       new SharedMemoryRegion(bitstream_buffer, true), bitstream_buffer.id()));
 
   // Skip empty buffer.
   if (bitstream_buffer.size() == 0)
@@ skipping 214 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_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
 
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::AssignPictureBuffers(
-    const std::vector<media::PictureBuffer>& buffers) {
+    const std::vector<PictureBuffer>& buffers) {
   DVLOGF(3);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&V4L2SliceVideoDecodeAccelerator::AssignPictureBuffersTask,
                  base::Unretained(this), buffers));
 }
 
 void V4L2SliceVideoDecodeAccelerator::AssignPictureBuffersTask(
-    const std::vector<media::PictureBuffer>& buffers) {
+    const std::vector<PictureBuffer>& buffers) {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kAwaitingPictureBuffers);
 
   const uint32_t req_buffer_count = decoder_->GetRequiredNumOfPictures();
 
   if (buffers.size() < req_buffer_count) {
     DLOG(ERROR) << "Failed to provide requested picture buffers. "
                 << "(Got " << buffers.size()
                 << ", requested " << req_buffer_count << ")";
@@ skipping 529 matching lines @@
     entry.frame_num = pic->frame_num;
     entry.pic_num = pic->pic_num;
     entry.top_field_order_cnt = pic->top_field_order_cnt;
     entry.bottom_field_order_cnt = pic->bottom_field_order_cnt;
     entry.flags = (pic->ref ? V4L2_H264_DPB_ENTRY_FLAG_ACTIVE : 0) |
                   (pic->long_term ? V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM : 0);
   }
 }
 
 bool V4L2SliceVideoDecodeAccelerator::V4L2H264Accelerator::SubmitFrameMetadata(
-    const media::H264SPS* sps,
-    const media::H264PPS* pps,
+    const H264SPS* sps,
+    const H264PPS* pps,
     const H264DPB& dpb,
     const H264Picture::Vector& ref_pic_listp0,
     const H264Picture::Vector& ref_pic_listb0,
     const H264Picture::Vector& ref_pic_listb1,
     const scoped_refptr<H264Picture>& pic) {
   struct v4l2_ext_control ctrl;
   std::vector<struct v4l2_ext_control> ctrls;
 
   struct v4l2_ctrl_h264_sps v4l2_sps;
   memset(&v4l2_sps, 0, sizeof(v4l2_sps));
@@ skipping 137 matching lines @@
                                   v4l2_decode_param_.ref_pic_list_b1);
 
   std::vector<scoped_refptr<V4L2DecodeSurface>> ref_surfaces;
   H264DPBToV4L2DPB(dpb, &ref_surfaces);
   dec_surface->SetReferenceSurfaces(ref_surfaces);
 
   return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::V4L2H264Accelerator::SubmitSlice(
-    const media::H264PPS* pps,
-    const media::H264SliceHeader* slice_hdr,
+    const H264PPS* pps,
+    const H264SliceHeader* slice_hdr,
     const H264Picture::Vector& ref_pic_list0,
     const H264Picture::Vector& ref_pic_list1,
     const scoped_refptr<H264Picture>& pic,
     const uint8_t* data,
     size_t size) {
   if (num_slices_ == kMaxSlices) {
     LOGF(ERROR) << "Over limit of supported slices per frame";
     return false;
   }
 
@@ skipping 209 matching lines @@
 }
 
 #define ARRAY_MEMCPY_CHECKED(to, from)                               \
   do {                                                               \
     static_assert(sizeof(to) == sizeof(from),                        \
                   #from " and " #to " arrays must be of same size"); \
     memcpy(to, from, sizeof(to));                                    \
   } while (0)
 
 static void FillV4L2SegmentationHeader(
-    const media::Vp8SegmentationHeader& vp8_sgmnt_hdr,
+    const Vp8SegmentationHeader& vp8_sgmnt_hdr,
     struct v4l2_vp8_sgmnt_hdr* v4l2_sgmnt_hdr) {
 #define SET_V4L2_SGMNT_HDR_FLAG_IF(cond, flag) \
   v4l2_sgmnt_hdr->flags |= ((vp8_sgmnt_hdr.cond) ? (flag) : 0)
   SET_V4L2_SGMNT_HDR_FLAG_IF(segmentation_enabled,
                              V4L2_VP8_SEGMNT_HDR_FLAG_ENABLED);
   SET_V4L2_SGMNT_HDR_FLAG_IF(update_mb_segmentation_map,
                              V4L2_VP8_SEGMNT_HDR_FLAG_UPDATE_MAP);
   SET_V4L2_SGMNT_HDR_FLAG_IF(update_segment_feature_data,
                              V4L2_VP8_SEGMNT_HDR_FLAG_UPDATE_FEATURE_DATA);
 #undef SET_V4L2_SPARM_FLAG_IF
   v4l2_sgmnt_hdr->segment_feature_mode = vp8_sgmnt_hdr.segment_feature_mode;
 
   ARRAY_MEMCPY_CHECKED(v4l2_sgmnt_hdr->quant_update,
                        vp8_sgmnt_hdr.quantizer_update_value);
   ARRAY_MEMCPY_CHECKED(v4l2_sgmnt_hdr->lf_update,
                        vp8_sgmnt_hdr.lf_update_value);
   ARRAY_MEMCPY_CHECKED(v4l2_sgmnt_hdr->segment_probs,
                        vp8_sgmnt_hdr.segment_prob);
 }
 
 static void FillV4L2LoopfilterHeader(
-    const media::Vp8LoopFilterHeader& vp8_loopfilter_hdr,
+    const Vp8LoopFilterHeader& vp8_loopfilter_hdr,
     struct v4l2_vp8_loopfilter_hdr* v4l2_lf_hdr) {
 #define SET_V4L2_LF_HDR_FLAG_IF(cond, flag) \
   v4l2_lf_hdr->flags |= ((vp8_loopfilter_hdr.cond) ? (flag) : 0)
   SET_V4L2_LF_HDR_FLAG_IF(loop_filter_adj_enable, V4L2_VP8_LF_HDR_ADJ_ENABLE);
   SET_V4L2_LF_HDR_FLAG_IF(mode_ref_lf_delta_update,
                           V4L2_VP8_LF_HDR_DELTA_UPDATE);
 #undef SET_V4L2_SGMNT_HDR_FLAG_IF
 
 #define LF_HDR_TO_V4L2_LF_HDR(a) v4l2_lf_hdr->a = vp8_loopfilter_hdr.a;
   LF_HDR_TO_V4L2_LF_HDR(type);
   LF_HDR_TO_V4L2_LF_HDR(level);
   LF_HDR_TO_V4L2_LF_HDR(sharpness_level);
 #undef LF_HDR_TO_V4L2_LF_HDR
 
   ARRAY_MEMCPY_CHECKED(v4l2_lf_hdr->ref_frm_delta_magnitude,
                        vp8_loopfilter_hdr.ref_frame_delta);
   ARRAY_MEMCPY_CHECKED(v4l2_lf_hdr->mb_mode_delta_magnitude,
                        vp8_loopfilter_hdr.mb_mode_delta);
 }
 
 static void FillV4L2QuantizationHeader(
-    const media::Vp8QuantizationHeader& vp8_quant_hdr,
+    const Vp8QuantizationHeader& vp8_quant_hdr,
     struct v4l2_vp8_quantization_hdr* v4l2_quant_hdr) {
   v4l2_quant_hdr->y_ac_qi = vp8_quant_hdr.y_ac_qi;
   v4l2_quant_hdr->y_dc_delta = vp8_quant_hdr.y_dc_delta;
   v4l2_quant_hdr->y2_dc_delta = vp8_quant_hdr.y2_dc_delta;
   v4l2_quant_hdr->y2_ac_delta = vp8_quant_hdr.y2_ac_delta;
   v4l2_quant_hdr->uv_dc_delta = vp8_quant_hdr.uv_dc_delta;
   v4l2_quant_hdr->uv_ac_delta = vp8_quant_hdr.uv_ac_delta;
 }
 
 static void FillV4L2EntropyHeader(
-    const media::Vp8EntropyHeader& vp8_entropy_hdr,
+    const Vp8EntropyHeader& vp8_entropy_hdr,
     struct v4l2_vp8_entropy_hdr* v4l2_entropy_hdr) {
   ARRAY_MEMCPY_CHECKED(v4l2_entropy_hdr->coeff_probs,
                        vp8_entropy_hdr.coeff_probs);
   ARRAY_MEMCPY_CHECKED(v4l2_entropy_hdr->y_mode_probs,
                        vp8_entropy_hdr.y_mode_probs);
   ARRAY_MEMCPY_CHECKED(v4l2_entropy_hdr->uv_mode_probs,
                        vp8_entropy_hdr.uv_mode_probs);
   ARRAY_MEMCPY_CHECKED(v4l2_entropy_hdr->mv_probs, vp8_entropy_hdr.mv_probs);
 }
 
 bool V4L2SliceVideoDecodeAccelerator::V4L2VP8Accelerator::SubmitDecode(
     const scoped_refptr<VP8Picture>& pic,
-    const media::Vp8FrameHeader* frame_hdr,
+    const Vp8FrameHeader* frame_hdr,
     const scoped_refptr<VP8Picture>& last_frame,
     const scoped_refptr<VP8Picture>& golden_frame,
     const scoped_refptr<VP8Picture>& alt_frame) {
   struct v4l2_ctrl_vp8_frame_hdr v4l2_frame_hdr;
   memset(&v4l2_frame_hdr, 0, sizeof(v4l2_frame_hdr));
 
 #define FHDR_TO_V4L2_FHDR(a) v4l2_frame_hdr.a = frame_hdr->a
   FHDR_TO_V4L2_FHDR(key_frame);
   FHDR_TO_V4L2_FHDR(version);
   FHDR_TO_V4L2_FHDR(width);
@@ skipping 163 matching lines @@
   DCHECK(inserted);
 
   DCHECK(!output_record.at_client);
   DCHECK(!output_record.at_device);
   DCHECK_NE(output_record.picture_id, -1);
   output_record.at_client = true;
 
   // TODO(posciak): Use visible size from decoder here instead
   // (crbug.com/402760). Passing (0, 0) results in the client using the
   // visible size extracted from the container instead.
-  media::Picture picture(output_record.picture_id, dec_surface->bitstream_id(),
-                         gfx::Rect(0, 0), false);
+  Picture picture(output_record.picture_id, dec_surface->bitstream_id(),
+                  gfx::Rect(0, 0), false);
   DVLOGF(3) << dec_surface->ToString()
             << ", bitstream_id: " << picture.bitstream_buffer_id()
             << ", picture_id: " << picture.picture_buffer_id();
   pending_picture_ready_.push(PictureRecord(output_record.cleared, picture));
   SendPictureReady();
   output_record.cleared = true;
 }
 
 scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>
 V4L2SliceVideoDecodeAccelerator::CreateSurface() {
@@ skipping 22 matching lines @@
   DVLOGF(4) << "Created surface " << input << " -> " << output;
   return dec_surface;
 }
 
 void V4L2SliceVideoDecodeAccelerator::SendPictureReady() {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   bool resetting_or_flushing = (decoder_resetting_ || decoder_flushing_);
   while (!pending_picture_ready_.empty()) {
     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) {
       DVLOGF(4) << "Posting picture ready to decode task runner for: "
                 << picture.picture_buffer_id();
       // 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();
@@ skipping 35 matching lines @@
 
 bool V4L2SliceVideoDecodeAccelerator::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
 V4L2SliceVideoDecodeAccelerator::GetSupportedProfiles() {
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (!device)
     return SupportedProfiles();
 
   return device->GetSupportedDecodeProfiles(arraysize(supported_input_fourccs_),
                                             supported_input_fourccs_);
 }
 
 }  // namespace media