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

media/gpu/ipc/service/gpu_video_encode_accelerator.cc

 // Copyright 2013 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/ipc/service/gpu_video_encode_accelerator.h"
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 41 matching lines @@
   }
 
   return true;
 }
 
 GpuVideoEncodeAccelerator::GpuVideoEncodeAccelerator(
     int32_t host_route_id,
     gpu::GpuCommandBufferStub* stub)
     : host_route_id_(host_route_id),
       stub_(stub),
-      input_format_(media::PIXEL_FORMAT_UNKNOWN),
+      input_format_(PIXEL_FORMAT_UNKNOWN),
       output_buffer_size_(0),
       weak_this_factory_(this) {
   stub_->AddDestructionObserver(this);
   make_context_current_ =
       base::Bind(&MakeDecoderContextCurrent, stub_->AsWeakPtr());
 }
 
 GpuVideoEncodeAccelerator::~GpuVideoEncodeAccelerator() {
   // This class can only be self-deleted from OnWillDestroyStub(), which means
   // the VEA has already been destroyed in there.
   DCHECK(!encoder_);
 }
 
-bool GpuVideoEncodeAccelerator::Initialize(
-    media::VideoPixelFormat input_format,
-    const gfx::Size& input_visible_size,
-    media::VideoCodecProfile output_profile,
-    uint32_t initial_bitrate) {
+bool GpuVideoEncodeAccelerator::Initialize(VideoPixelFormat input_format,
+                                           const gfx::Size& input_visible_size,
+                                           VideoCodecProfile output_profile,
+                                           uint32_t initial_bitrate) {
   DVLOG(2) << "GpuVideoEncodeAccelerator::Initialize(): "
            << "input_format=" << input_format
            << ", input_visible_size=" << input_visible_size.ToString()
            << ", output_profile=" << output_profile
            << ", initial_bitrate=" << initial_bitrate;
   DCHECK(!encoder_);
 
   if (!stub_->channel()->AddRoute(host_route_id_, stub_->stream_id(), this)) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::Initialize(): "
                    "failed to add route";
     return false;
   }
 
-  if (input_visible_size.width() > media::limits::kMaxDimension ||
-      input_visible_size.height() > media::limits::kMaxDimension ||
-      input_visible_size.GetArea() > media::limits::kMaxCanvas) {
+  if (input_visible_size.width() > limits::kMaxDimension ||
+      input_visible_size.height() > limits::kMaxDimension ||
+      input_visible_size.GetArea() > limits::kMaxCanvas) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::Initialize(): "
                 << "input_visible_size " << input_visible_size.ToString()
                 << " too large";
     return false;
   }
 
   const gpu::GpuPreferences& gpu_preferences =
       stub_->channel()->gpu_channel_manager()->gpu_preferences();
 
   std::vector<GpuVideoEncodeAccelerator::CreateVEAFp> create_vea_fps =
@@ skipping 44 matching lines @@
 void GpuVideoEncodeAccelerator::BitstreamBufferReady(
     int32_t bitstream_buffer_id,
     size_t payload_size,
     bool key_frame,
     base::TimeDelta timestamp) {
   Send(new AcceleratedVideoEncoderHostMsg_BitstreamBufferReady(
       host_route_id_, bitstream_buffer_id, payload_size, key_frame, timestamp));
 }
 
 void GpuVideoEncodeAccelerator::NotifyError(
-    media::VideoEncodeAccelerator::Error error) {
+    VideoEncodeAccelerator::Error error) {
   Send(new AcceleratedVideoEncoderHostMsg_NotifyError(host_route_id_, error));
 }
 
 void GpuVideoEncodeAccelerator::OnWillDestroyStub() {
   DCHECK(stub_);
   stub_->channel()->RemoveRoute(host_route_id_);
   stub_->RemoveDestructionObserver(this);
   encoder_.reset();
   delete this;
 }
 
 // static
 gpu::VideoEncodeAcceleratorSupportedProfiles
 GpuVideoEncodeAccelerator::GetSupportedProfiles(
     const gpu::GpuPreferences& gpu_preferences) {
-  media::VideoEncodeAccelerator::SupportedProfiles profiles;
+  VideoEncodeAccelerator::SupportedProfiles profiles;
   std::vector<GpuVideoEncodeAccelerator::CreateVEAFp> create_vea_fps =
       CreateVEAFps(gpu_preferences);
 
   for (size_t i = 0; i < create_vea_fps.size(); ++i) {
-    std::unique_ptr<media::VideoEncodeAccelerator> encoder =
-        (*create_vea_fps[i])();
+    std::unique_ptr<VideoEncodeAccelerator> encoder = (*create_vea_fps[i])();
     if (!encoder)
       continue;
-    media::VideoEncodeAccelerator::SupportedProfiles vea_profiles =
+    VideoEncodeAccelerator::SupportedProfiles vea_profiles =
         encoder->GetSupportedProfiles();
-    media::GpuVideoAcceleratorUtil::InsertUniqueEncodeProfiles(vea_profiles,
-                                                               &profiles);
+    GpuVideoAcceleratorUtil::InsertUniqueEncodeProfiles(vea_profiles,
+                                                        &profiles);
   }
-  return media::GpuVideoAcceleratorUtil::ConvertMediaToGpuEncodeProfiles(
-      profiles);
+  return GpuVideoAcceleratorUtil::ConvertMediaToGpuEncodeProfiles(profiles);
 }
 
 // static
 std::vector<GpuVideoEncodeAccelerator::CreateVEAFp>
 GpuVideoEncodeAccelerator::CreateVEAFps(
     const gpu::GpuPreferences& gpu_preferences) {
   std::vector<GpuVideoEncodeAccelerator::CreateVEAFp> create_vea_fps;
 #if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
   create_vea_fps.push_back(&GpuVideoEncodeAccelerator::CreateV4L2VEA);
 #endif
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   if (!gpu_preferences.disable_vaapi_accelerated_video_encode)
     create_vea_fps.push_back(&GpuVideoEncodeAccelerator::CreateVaapiVEA);
 #endif
 #if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
   if (!gpu_preferences.disable_web_rtc_hw_encoding)
     create_vea_fps.push_back(&GpuVideoEncodeAccelerator::CreateAndroidVEA);
 #endif
 #if defined(OS_MACOSX)
   create_vea_fps.push_back(&GpuVideoEncodeAccelerator::CreateVTVEA);
 #endif
   return create_vea_fps;
 }
 
 #if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
 // static
-std::unique_ptr<media::VideoEncodeAccelerator>
+std::unique_ptr<VideoEncodeAccelerator>
 GpuVideoEncodeAccelerator::CreateV4L2VEA() {
-  std::unique_ptr<media::VideoEncodeAccelerator> encoder;
+  std::unique_ptr<VideoEncodeAccelerator> encoder;
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kEncoder);
   if (device)
     encoder.reset(new V4L2VideoEncodeAccelerator(device));
   return encoder;
 }
 #endif
 
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
 // static
-std::unique_ptr<media::VideoEncodeAccelerator>
+std::unique_ptr<VideoEncodeAccelerator>
 GpuVideoEncodeAccelerator::CreateVaapiVEA() {
-  return base::WrapUnique<media::VideoEncodeAccelerator>(
+  return base::WrapUnique<VideoEncodeAccelerator>(
       new VaapiVideoEncodeAccelerator());
 }
 #endif
 
 #if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
 // static
-std::unique_ptr<media::VideoEncodeAccelerator>
+std::unique_ptr<VideoEncodeAccelerator>
 GpuVideoEncodeAccelerator::CreateAndroidVEA() {
-  return base::WrapUnique<media::VideoEncodeAccelerator>(
+  return base::WrapUnique<VideoEncodeAccelerator>(
       new AndroidVideoEncodeAccelerator());
 }
 #endif
 
 #if defined(OS_MACOSX)
 // static
-std::unique_ptr<media::VideoEncodeAccelerator>
+std::unique_ptr<VideoEncodeAccelerator>
 GpuVideoEncodeAccelerator::CreateVTVEA() {
-  return base::WrapUnique<media::VideoEncodeAccelerator>(
+  return base::WrapUnique<VideoEncodeAccelerator>(
       new VTVideoEncodeAccelerator());
 }
 #endif
 
 void GpuVideoEncodeAccelerator::OnEncode(
     const AcceleratedVideoEncoderMsg_Encode_Params& params) {
   DVLOG(3) << "GpuVideoEncodeAccelerator::OnEncode: frame_id = "
            << params.frame_id << ", buffer_size=" << params.buffer_size
            << ", force_keyframe=" << params.force_keyframe;
-  DCHECK_EQ(media::PIXEL_FORMAT_I420, input_format_);
+  DCHECK_EQ(PIXEL_FORMAT_I420, input_format_);
 
   // Wrap into a SharedMemory in the beginning, so that |params.buffer_handle|
   // is cleaned properly in case of an early return.
   std::unique_ptr<base::SharedMemory> shm(
       new base::SharedMemory(params.buffer_handle, true));
 
   if (!encoder_)
     return;
 
   if (params.frame_id < 0) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnEncode(): invalid "
                 << "frame_id=" << params.frame_id;
-    NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
+    NotifyError(VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
 
   const uint32_t aligned_offset =
       params.buffer_offset % base::SysInfo::VMAllocationGranularity();
   base::CheckedNumeric<off_t> map_offset = params.buffer_offset;
   map_offset -= aligned_offset;
   base::CheckedNumeric<size_t> map_size = params.buffer_size;
   map_size += aligned_offset;
 
   if (!map_offset.IsValid() || !map_size.IsValid()) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnEncode():"
                 << " invalid (buffer_offset,buffer_size)";
-    NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
+    NotifyError(VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
 
   if (!shm->MapAt(map_offset.ValueOrDie(), map_size.ValueOrDie())) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnEncode(): "
                 << "could not map frame_id=" << params.frame_id;
-    NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
+    NotifyError(VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
 
   uint8_t* shm_memory =
       reinterpret_cast<uint8_t*>(shm->memory()) + aligned_offset;
-  scoped_refptr<media::VideoFrame> frame =
-      media::VideoFrame::WrapExternalSharedMemory(
-          input_format_, input_coded_size_, gfx::Rect(input_visible_size_),
-          input_visible_size_, shm_memory, params.buffer_size,
-          params.buffer_handle, params.buffer_offset, params.timestamp);
+  scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalSharedMemory(
+      input_format_, input_coded_size_, gfx::Rect(input_visible_size_),
+      input_visible_size_, shm_memory, params.buffer_size, params.buffer_handle,
+      params.buffer_offset, params.timestamp);
   if (!frame) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnEncode(): "
                 << "could not create a frame";
-    NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
+    NotifyError(VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
-  frame->AddDestructionObserver(media::BindToCurrentLoop(base::Bind(
+  frame->AddDestructionObserver(BindToCurrentLoop(base::Bind(
       &GpuVideoEncodeAccelerator::EncodeFrameFinished,
       weak_this_factory_.GetWeakPtr(), params.frame_id, base::Passed(&shm))));
   encoder_->Encode(frame, params.force_keyframe);
 }
 
 void GpuVideoEncodeAccelerator::OnEncode2(
     const AcceleratedVideoEncoderMsg_Encode_Params2& params) {
   DVLOG(3) << "GpuVideoEncodeAccelerator::OnEncode2: "
            << "frame_id = " << params.frame_id
            << ", size=" << params.size.ToString()
            << ", force_keyframe=" << params.force_keyframe
            << ", handle type=" << params.gpu_memory_buffer_handles[0].type;
   // Encoding GpuMemoryBuffer backed frames is not supported.
   NOTREACHED();
 }
 
 void GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(
     int32_t buffer_id,
     base::SharedMemoryHandle buffer_handle,
     uint32_t buffer_size) {
   DVLOG(3) << "GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(): "
            << "buffer_id=" << buffer_id << ", buffer_size=" << buffer_size;
   if (!encoder_)
     return;
   if (buffer_id < 0) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(): "
                 << "invalid buffer_id=" << buffer_id;
-    NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
+    NotifyError(VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
   if (buffer_size < output_buffer_size_) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(): "
                 << "buffer too small for buffer_id=" << buffer_id;
-    NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
+    NotifyError(VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
   encoder_->UseOutputBitstreamBuffer(
-      media::BitstreamBuffer(buffer_id, buffer_handle, buffer_size));
+      BitstreamBuffer(buffer_id, buffer_handle, buffer_size));
 }
 
 void GpuVideoEncodeAccelerator::OnDestroy() {
   DVLOG(2) << "GpuVideoEncodeAccelerator::OnDestroy()";
   OnWillDestroyStub();
 }
 
 void GpuVideoEncodeAccelerator::OnRequestEncodingParametersChange(
     uint32_t bitrate,
     uint32_t framerate) {
@@ skipping 10 matching lines @@
   Send(new AcceleratedVideoEncoderHostMsg_NotifyInputDone(host_route_id_,
                                                           frame_id));
   // Just let |shm| fall out of scope.
 }
 
 void GpuVideoEncodeAccelerator::Send(IPC::Message* message) {
   stub_->channel()->Send(message);
 }
 
 }  // namespace media