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

media/gpu/vaapi_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/vaapi_jpeg_decode_accelerator.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <memory>
@@ skipping 19 matching lines @@
   VAAPI_ERROR = 0,
   VAJDA_DECODER_FAILURES_MAX,
 };
 
 static void ReportToUMA(VAJDADecoderFailure failure) {
   UMA_HISTOGRAM_ENUMERATION("Media.VAJDA.DecoderFailure", failure,
                             VAJDA_DECODER_FAILURES_MAX + 1);
 }
 
 static unsigned int VaSurfaceFormatForJpeg(
-    const media::JpegFrameHeader& frame_header) {
+    const JpegFrameHeader& frame_header) {
   // The range of sampling factor is [1, 4]. Pack them into integer to make the
   // matching code simpler. For example, 0x211 means the sampling factor are 2,
   // 1, 1 for 3 components.
   unsigned int h = 0, v = 0;
   for (int i = 0; i < frame_header.num_components; i++) {
     DCHECK_LE(frame_header.components[i].horizontal_sampling_factor, 4);
     DCHECK_LE(frame_header.components[i].vertical_sampling_factor, 4);
     h = h << 4 | frame_header.components[i].horizontal_sampling_factor;
     v = v << 4 | frame_header.components[i].vertical_sampling_factor;
   }
@@ skipping 22 matching lines @@
            << ", v=" << v;
 
   return 0;
 }
 
 }  // namespace
 
 VaapiJpegDecodeAccelerator::DecodeRequest::DecodeRequest(
     int32_t bitstream_buffer_id,
     std::unique_ptr<SharedMemoryRegion> shm,
-    const scoped_refptr<media::VideoFrame>& video_frame)
+    const scoped_refptr<VideoFrame>& video_frame)
     : bitstream_buffer_id(bitstream_buffer_id),
       shm(std::move(shm)),
       video_frame(video_frame) {}
 
 VaapiJpegDecodeAccelerator::DecodeRequest::~DecodeRequest() {}
 
 void VaapiJpegDecodeAccelerator::NotifyError(int32_t bitstream_buffer_id,
                                              Error error) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DLOG(ERROR) << "Notifying of error " << error;
@@ skipping 52 matching lines @@
     return false;
   }
   decoder_task_runner_ = decoder_thread_.task_runner();
 
   return true;
 }
 
 bool VaapiJpegDecodeAccelerator::OutputPicture(
     VASurfaceID va_surface_id,
     int32_t input_buffer_id,
-    const scoped_refptr<media::VideoFrame>& video_frame) {
+    const scoped_refptr<VideoFrame>& video_frame) {
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
 
   TRACE_EVENT1("jpeg", "VaapiJpegDecodeAccelerator::OutputPicture",
                "input_buffer_id", input_buffer_id);
 
   DVLOG(3) << "Outputting VASurface " << va_surface_id
            << " into video_frame associated with input buffer id "
            << input_buffer_id;
 
   VAImage image;
@@ skipping 17 matching lines @@
   // The component order of VAImage I420 are Y, U, and V.
   DCHECK_EQ(image.num_planes, 3u);
   DCHECK_GE(image.width, coded_size.width());
   DCHECK_GE(image.height, coded_size.height());
   const uint8_t* src_y = mem + image.offsets[0];
   const uint8_t* src_u = mem + image.offsets[1];
   const uint8_t* src_v = mem + image.offsets[2];
   size_t src_y_stride = image.pitches[0];
   size_t src_u_stride = image.pitches[1];
   size_t src_v_stride = image.pitches[2];
-  uint8_t* dst_y = video_frame->data(media::VideoFrame::kYPlane);
-  uint8_t* dst_u = video_frame->data(media::VideoFrame::kUPlane);
-  uint8_t* dst_v = video_frame->data(media::VideoFrame::kVPlane);
-  size_t dst_y_stride = video_frame->stride(media::VideoFrame::kYPlane);
-  size_t dst_u_stride = video_frame->stride(media::VideoFrame::kUPlane);
-  size_t dst_v_stride = video_frame->stride(media::VideoFrame::kVPlane);
+  uint8_t* dst_y = video_frame->data(VideoFrame::kYPlane);
+  uint8_t* dst_u = video_frame->data(VideoFrame::kUPlane);
+  uint8_t* dst_v = video_frame->data(VideoFrame::kVPlane);
+  size_t dst_y_stride = video_frame->stride(VideoFrame::kYPlane);
+  size_t dst_u_stride = video_frame->stride(VideoFrame::kUPlane);
+  size_t dst_v_stride = video_frame->stride(VideoFrame::kVPlane);
 
   if (libyuv::I420Copy(src_y, src_y_stride,  // Y
                        src_u, src_u_stride,  // U
                        src_v, src_v_stride,  // V
                        dst_y, dst_y_stride,  // Y
                        dst_u, dst_u_stride,  // U
                        dst_v, dst_v_stride,  // V
                        coded_size.width(), coded_size.height())) {
     DLOG(ERROR) << "I420Copy failed";
     return false;
   }
 
   vaapi_wrapper_->ReturnVaImage(&image);
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&VaapiJpegDecodeAccelerator::VideoFrameReady,
                             weak_this_, input_buffer_id));
 
   return true;
 }
 
 void VaapiJpegDecodeAccelerator::DecodeTask(
     const std::unique_ptr<DecodeRequest>& request) {
   DVLOG(3) << __func__;
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("jpeg", "DecodeTask");
 
-  media::JpegParseResult parse_result;
-  if (!media::ParseJpegPicture(
+  JpegParseResult parse_result;
+  if (!ParseJpegPicture(
           reinterpret_cast<const uint8_t*>(request->shm->memory()),
           request->shm->size(), &parse_result)) {
     DLOG(ERROR) << "ParseJpegPicture failed";
     NotifyErrorFromDecoderThread(request->bitstream_buffer_id,
                                  PARSE_JPEG_FAILED);
     return;
   }
 
   unsigned int new_va_rt_format =
       VaSurfaceFormatForJpeg(parse_result.frame_header);
@@ skipping 36 matching lines @@
   if (!OutputPicture(va_surface_id_, request->bitstream_buffer_id,
                      request->video_frame)) {
     LOG(ERROR) << "Output picture failed";
     NotifyErrorFromDecoderThread(request->bitstream_buffer_id,
                                  PLATFORM_FAILURE);
     return;
   }
 }
 
 void VaapiJpegDecodeAccelerator::Decode(
-    const media::BitstreamBuffer& bitstream_buffer,
-    const scoped_refptr<media::VideoFrame>& video_frame) {
+    const BitstreamBuffer& bitstream_buffer,
+    const scoped_refptr<VideoFrame>& video_frame) {
   DVLOG(3) << __func__;
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT1("jpeg", "Decode", "input_id", bitstream_buffer.id());
 
   DVLOG(4) << "Mapping new input buffer id: " << bitstream_buffer.id()
            << " size: " << bitstream_buffer.size();
 
   // SharedMemoryRegion will take over the |bitstream_buffer.handle()|.
   std::unique_ptr<SharedMemoryRegion> shm(
       new SharedMemoryRegion(bitstream_buffer, true));
@@ skipping 16 matching lines @@
   decoder_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VaapiJpegDecodeAccelerator::DecodeTask,
                             base::Unretained(this), base::Passed(&request)));
 }
 
 bool VaapiJpegDecodeAccelerator::IsSupported() {
   return VaapiWrapper::IsJpegDecodeSupported();
 }
 
 }  // namespace media