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

media/gpu/vaapi_video_encode_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/vaapi_video_encode_accelerator.h"
 
 #include <string.h>
 
 #include <memory>
 #include <utility>
@@ skipping 73 matching lines @@
   DCHECK((alignment + (alignment - 1)) == (alignment | (alignment - 1)));
   return ((value + (alignment - 1)) & ~(alignment - 1));
 }
 
 static void ReportToUMA(VAVEAEncoderFailure failure) {
   UMA_HISTOGRAM_ENUMERATION("Media.VAVEA.EncoderFailure", failure,
                             VAVEA_ENCODER_FAILURES_MAX + 1);
 }
 
 struct VaapiVideoEncodeAccelerator::InputFrameRef {
-  InputFrameRef(const scoped_refptr<media::VideoFrame>& frame,
-                bool force_keyframe)
+  InputFrameRef(const scoped_refptr<VideoFrame>& frame, bool force_keyframe)
       : frame(frame), force_keyframe(force_keyframe) {}
-  const scoped_refptr<media::VideoFrame> frame;
+  const scoped_refptr<VideoFrame> frame;
   const bool force_keyframe;
 };
 
 struct VaapiVideoEncodeAccelerator::BitstreamBufferRef {
   BitstreamBufferRef(int32_t id, std::unique_ptr<SharedMemoryRegion> shm)
       : id(id), shm(std::move(shm)) {}
   const int32_t id;
   const std::unique_ptr<SharedMemoryRegion> shm;
 };
 
-media::VideoEncodeAccelerator::SupportedProfiles
+VideoEncodeAccelerator::SupportedProfiles
 VaapiVideoEncodeAccelerator::GetSupportedProfiles() {
   return VaapiWrapper::GetSupportedEncodeProfiles();
 }
 
 static unsigned int Log2OfPowerOf2(unsigned int x) {
   CHECK_GT(x, 0u);
   DCHECK_EQ(x & (x - 1), 0u);
 
   int log = 0;
   while (x > 1) {
     x >>= 1;
     ++log;
   }
   return log;
 }
 
 VaapiVideoEncodeAccelerator::VaapiVideoEncodeAccelerator()
-    : profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
+    : profile_(VIDEO_CODEC_PROFILE_UNKNOWN),
       mb_width_(0),
       mb_height_(0),
       output_buffer_byte_size_(0),
       state_(kUninitialized),
       frame_num_(0),
       idr_pic_id_(0),
       bitrate_(0),
       framerate_(0),
       cpb_size_(0),
       encoding_parameters_changed_(false),
@@ skipping 10 matching lines @@
   ip_period_ = kIPPeriod;
 }
 
 VaapiVideoEncodeAccelerator::~VaapiVideoEncodeAccelerator() {
   DVLOGF(4);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!encoder_thread_.IsRunning());
 }
 
 bool VaapiVideoEncodeAccelerator::Initialize(
-    media::VideoPixelFormat format,
+    VideoPixelFormat format,
     const gfx::Size& input_visible_size,
-    media::VideoCodecProfile output_profile,
+    VideoCodecProfile output_profile,
     uint32_t initial_bitrate,
     Client* client) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!encoder_thread_.IsRunning());
   DCHECK_EQ(state_, kUninitialized);
 
   DVLOGF(1) << "Initializing VAVEA, input_format: "
-            << media::VideoPixelFormatToString(format)
+            << VideoPixelFormatToString(format)
             << ", input_visible_size: " << input_visible_size.ToString()
             << ", output_profile: " << output_profile
             << ", initial_bitrate: " << initial_bitrate;
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
 
   const SupportedProfiles& profiles = GetSupportedProfiles();
   auto profile = find_if(profiles.begin(), profiles.end(),
                          [output_profile](const SupportedProfile& profile) {
                            return profile.profile == output_profile;
                          });
   if (profile == profiles.end()) {
     DVLOGF(1) << "Unsupported output profile " << output_profile;
     return false;
   }
   if (input_visible_size.width() > profile->max_resolution.width() ||
       input_visible_size.height() > profile->max_resolution.height()) {
     DVLOGF(1) << "Input size too big: " << input_visible_size.ToString()
               << ", max supported size: " << profile->max_resolution.ToString();
     return false;
   }
 
-  if (format != media::PIXEL_FORMAT_I420) {
+  if (format != PIXEL_FORMAT_I420) {
     DVLOGF(1) << "Unsupported input format: "
-              << media::VideoPixelFormatToString(format);
+              << VideoPixelFormatToString(format);
     return false;
   }
 
   profile_ = output_profile;
   visible_size_ = input_visible_size;
   // 4:2:0 format has to be 2-aligned.
   DCHECK_EQ(visible_size_.width() % 2, 0);
   DCHECK_EQ(visible_size_.height() % 2, 0);
   coded_size_ = gfx::Size(RoundUpToPowerOf2(visible_size_.width(), 16),
                           RoundUpToPowerOf2(visible_size_.height(), 16));
@@ skipping 23 matching lines @@
                             base::Unretained(this)));
 
   return true;
 }
 
 void VaapiVideoEncodeAccelerator::InitializeTask() {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kUninitialized);
   DVLOGF(4);
 
-  va_surface_release_cb_ = media::BindToCurrentLoop(
+  va_surface_release_cb_ = BindToCurrentLoop(
       base::Bind(&VaapiVideoEncodeAccelerator::RecycleVASurfaceID,
                  base::Unretained(this)));
 
   if (!vaapi_wrapper_->CreateSurfaces(VA_RT_FORMAT_YUV420, coded_size_,
                                       kNumSurfaces,
                                       &available_va_surface_ids_)) {
     NOTIFY_ERROR(kPlatformFailureError, "Failed creating VASurfaces");
     return;
   }
 
@@ skipping 31 matching lines @@
   frame_num_ %= idr_period_;
 
   if (current_pic_->frame_num == 0) {
     current_pic_->idr = true;
     // H264 spec mandates idr_pic_id to differ between two consecutive IDRs.
     idr_pic_id_ ^= 1;
     ref_pic_list0_.clear();
   }
 
   if (current_pic_->frame_num % i_period_ == 0)
-    current_pic_->type = media::H264SliceHeader::kISlice;
+    current_pic_->type = H264SliceHeader::kISlice;
   else
-    current_pic_->type = media::H264SliceHeader::kPSlice;
+    current_pic_->type = H264SliceHeader::kPSlice;
 
-  if (current_pic_->type != media::H264SliceHeader::kBSlice)
+  if (current_pic_->type != H264SliceHeader::kBSlice)
     current_pic_->ref = true;
 
   current_pic_->pic_order_cnt = current_pic_->frame_num * 2;
   current_pic_->top_field_order_cnt = current_pic_->pic_order_cnt;
   current_pic_->pic_order_cnt_lsb = current_pic_->pic_order_cnt;
 
   current_encode_job_->keyframe = current_pic_->idr;
 
   DVLOGF(4) << "Starting a new frame, type: " << current_pic_->type
             << (force_keyframe ? " (forced keyframe)" : "")
@@ skipping 166 matching lines @@
   hrd_param.initial_buffer_fullness = cpb_size_ / 2;
   if (!vaapi_wrapper_->SubmitVAEncMiscParamBuffer(
           VAEncMiscParameterTypeHRD, sizeof(hrd_param), &hrd_param))
     return false;
 
   return true;
 }
 
 bool VaapiVideoEncodeAccelerator::SubmitHeadersIfNeeded() {
   DCHECK(current_pic_);
-  if (current_pic_->type != media::H264SliceHeader::kISlice)
+  if (current_pic_->type != H264SliceHeader::kISlice)
     return true;
 
   // Submit PPS.
   VAEncPackedHeaderParameterBuffer par_buffer;
   memset(&par_buffer, 0, sizeof(par_buffer));
   par_buffer.type = VAEncPackedHeaderSequence;
   par_buffer.bit_length = packed_sps_.BytesInBuffer() * 8;
 
   if (!vaapi_wrapper_->SubmitBuffer(VAEncPackedHeaderParameterBufferType,
                                     sizeof(par_buffer), &par_buffer))
@@ skipping 22 matching lines @@
 }
 
 bool VaapiVideoEncodeAccelerator::ExecuteEncode() {
   DCHECK(current_pic_);
   DVLOGF(3) << "Encoding frame_num: " << current_pic_->frame_num;
   return vaapi_wrapper_->ExecuteAndDestroyPendingBuffers(
       current_encode_job_->input_surface->id());
 }
 
 bool VaapiVideoEncodeAccelerator::UploadFrame(
-    const scoped_refptr<media::VideoFrame>& frame) {
+    const scoped_refptr<VideoFrame>& frame) {
   return vaapi_wrapper_->UploadVideoFrameToSurface(
       frame, current_encode_job_->input_surface->id());
 }
 
 void VaapiVideoEncodeAccelerator::TryToReturnBitstreamBuffer() {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (state_ != kEncoding)
     return;
 
@@ skipping 19 matching lines @@
   DVLOGF(3) << "Returning bitstream buffer "
             << (encode_job->keyframe ? "(keyframe)" : "")
             << " id: " << buffer->id << " size: " << data_size;
 
   child_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Client::BitstreamBufferReady, client_, buffer->id, data_size,
                  encode_job->keyframe, encode_job->timestamp));
 }
 
-void VaapiVideoEncodeAccelerator::Encode(
-    const scoped_refptr<media::VideoFrame>& frame,
-    bool force_keyframe) {
+void VaapiVideoEncodeAccelerator::Encode(const scoped_refptr<VideoFrame>& frame,
+                                         bool force_keyframe) {
   DVLOGF(3) << "Frame timestamp: " << frame->timestamp().InMilliseconds()
             << " force_keyframe: " << force_keyframe;
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   encoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VaapiVideoEncodeAccelerator::EncodeTask,
                             base::Unretained(this), frame, force_keyframe));
 }
 
 bool VaapiVideoEncodeAccelerator::PrepareNextJob(base::TimeDelta timestamp) {
@@ skipping 23 matching lines @@
 
   // Reference surfaces are needed until the job is done, but they get
   // removed from ref_pic_list0_ when it's full at the end of job submission.
   // Keep refs to them along with the job and only release after sync.
   current_encode_job_->reference_surfaces = ref_pic_list0_;
 
   return true;
 }
 
 void VaapiVideoEncodeAccelerator::EncodeTask(
-    const scoped_refptr<media::VideoFrame>& frame,
+    const scoped_refptr<VideoFrame>& frame,
     bool force_keyframe) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(state_, kUninitialized);
 
   encoder_input_queue_.push(
       make_linked_ptr(new InputFrameRef(frame, force_keyframe)));
   EncodeFrameTask();
 }
 
 void VaapiVideoEncodeAccelerator::EncodeFrameTask() {
@@ skipping 31 matching lines @@
   if (!ExecuteEncode()) {
     NOTIFY_ERROR(kPlatformFailureError, "Failed submitting encode job to HW.");
     return;
   }
 
   EndFrame();
   TryToReturnBitstreamBuffer();
 }
 
 void VaapiVideoEncodeAccelerator::UseOutputBitstreamBuffer(
-    const media::BitstreamBuffer& buffer) {
+    const BitstreamBuffer& buffer) {
   DVLOGF(4) << "id: " << buffer.id();
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (buffer.size() < output_buffer_byte_size_) {
     NOTIFY_ERROR(kInvalidArgumentError, "Provided bitstream buffer too small");
     return;
   }
 
   std::unique_ptr<SharedMemoryRegion> shm(
       new SharedMemoryRegion(buffer, false));
@@ skipping 91 matching lines @@
   delete this;
 }
 
 void VaapiVideoEncodeAccelerator::DestroyTask() {
   DVLOGF(2);
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
   SetState(kError);
 }
 
 void VaapiVideoEncodeAccelerator::UpdateSPS() {
-  memset(&current_sps_, 0, sizeof(media::H264SPS));
+  memset(&current_sps_, 0, sizeof(H264SPS));
 
   // Spec A.2 and A.3.
   switch (profile_) {
-    case media::H264PROFILE_BASELINE:
+    case H264PROFILE_BASELINE:
       // Due to crbug.com/345569, we don't distinguish between constrained
       // and non-constrained baseline profiles. Since many codecs can't do
       // non-constrained, and constrained is usually what we mean (and it's a
       // subset of non-constrained), default to it.
-      current_sps_.profile_idc = media::H264SPS::kProfileIDCBaseline;
+      current_sps_.profile_idc = H264SPS::kProfileIDCBaseline;
       current_sps_.constraint_set0_flag = true;
       break;
-    case media::H264PROFILE_MAIN:
-      current_sps_.profile_idc = media::H264SPS::kProfileIDCMain;
+    case H264PROFILE_MAIN:
+      current_sps_.profile_idc = H264SPS::kProfileIDCMain;
       current_sps_.constraint_set1_flag = true;
       break;
-    case media::H264PROFILE_HIGH:
-      current_sps_.profile_idc = media::H264SPS::kProfileIDCHigh;
+    case H264PROFILE_HIGH:
+      current_sps_.profile_idc = H264SPS::kProfileIDCHigh;
       break;
     default:
       NOTIMPLEMENTED();
       return;
   }
 
   current_sps_.level_idc = kDefaultLevelIDC;
   current_sps_.seq_parameter_set_id = 0;
   current_sps_.chroma_format_idc = kChromaFormatIDC;
 
@@ skipping 34 matching lines @@
   current_sps_.num_units_in_tick = 1;
   current_sps_.time_scale = framerate_ * 2;  // See equation D-2 in spec.
   current_sps_.fixed_frame_rate_flag = true;
 
   current_sps_.nal_hrd_parameters_present_flag = true;
   // H.264 spec ch. E.2.2.
   current_sps_.cpb_cnt_minus1 = 0;
   current_sps_.bit_rate_scale = kBitRateScale;
   current_sps_.cpb_size_scale = kCPBSizeScale;
   current_sps_.bit_rate_value_minus1[0] =
-      (bitrate_ >>
-       (kBitRateScale + media::H264SPS::kBitRateScaleConstantTerm)) -
-      1;
+      (bitrate_ >> (kBitRateScale + H264SPS::kBitRateScaleConstantTerm)) - 1;
   current_sps_.cpb_size_value_minus1[0] =
-      (cpb_size_ >>
-       (kCPBSizeScale + media::H264SPS::kCPBSizeScaleConstantTerm)) -
-      1;
+      (cpb_size_ >> (kCPBSizeScale + H264SPS::kCPBSizeScaleConstantTerm)) - 1;
   current_sps_.cbr_flag[0] = true;
   current_sps_.initial_cpb_removal_delay_length_minus_1 =
-      media::H264SPS::kDefaultInitialCPBRemovalDelayLength - 1;
+      H264SPS::kDefaultInitialCPBRemovalDelayLength - 1;
   current_sps_.cpb_removal_delay_length_minus1 =
-      media::H264SPS::kDefaultInitialCPBRemovalDelayLength - 1;
+      H264SPS::kDefaultInitialCPBRemovalDelayLength - 1;
   current_sps_.dpb_output_delay_length_minus1 =
-      media::H264SPS::kDefaultDPBOutputDelayLength - 1;
-  current_sps_.time_offset_length = media::H264SPS::kDefaultTimeOffsetLength;
+      H264SPS::kDefaultDPBOutputDelayLength - 1;
+  current_sps_.time_offset_length = H264SPS::kDefaultTimeOffsetLength;
   current_sps_.low_delay_hrd_flag = false;
 }
 
 void VaapiVideoEncodeAccelerator::GeneratePackedSPS() {
   packed_sps_.Reset();
 
-  packed_sps_.BeginNALU(media::H264NALU::kSPS, 3);
+  packed_sps_.BeginNALU(H264NALU::kSPS, 3);
 
   packed_sps_.AppendBits(8, current_sps_.profile_idc);
   packed_sps_.AppendBool(current_sps_.constraint_set0_flag);
   packed_sps_.AppendBool(current_sps_.constraint_set1_flag);
   packed_sps_.AppendBool(current_sps_.constraint_set2_flag);
   packed_sps_.AppendBool(current_sps_.constraint_set3_flag);
   packed_sps_.AppendBool(current_sps_.constraint_set4_flag);
   packed_sps_.AppendBool(current_sps_.constraint_set5_flag);
   packed_sps_.AppendBits(2, 0);  // reserved_zero_2bits
   packed_sps_.AppendBits(8, current_sps_.level_idc);
   packed_sps_.AppendUE(current_sps_.seq_parameter_set_id);
 
-  if (current_sps_.profile_idc == media::H264SPS::kProfileIDCHigh) {
+  if (current_sps_.profile_idc == H264SPS::kProfileIDCHigh) {
     packed_sps_.AppendUE(current_sps_.chroma_format_idc);
     if (current_sps_.chroma_format_idc == 3)
       packed_sps_.AppendBool(current_sps_.separate_colour_plane_flag);
     packed_sps_.AppendUE(current_sps_.bit_depth_luma_minus8);
     packed_sps_.AppendUE(current_sps_.bit_depth_chroma_minus8);
     packed_sps_.AppendBool(current_sps_.qpprime_y_zero_transform_bypass_flag);
     packed_sps_.AppendBool(current_sps_.seq_scaling_matrix_present_flag);
     CHECK(!current_sps_.seq_scaling_matrix_present_flag);
   }
 
@@ skipping 78 matching lines @@
     // max_num_ref_frames.
     const unsigned int max_dec_frame_buffering =
         current_sps_.max_num_ref_frames;
     packed_sps_.AppendUE(max_dec_frame_buffering);
   }
 
   packed_sps_.FinishNALU();
 }
 
 void VaapiVideoEncodeAccelerator::UpdatePPS() {
-  memset(&current_pps_, 0, sizeof(media::H264PPS));
+  memset(&current_pps_, 0, sizeof(H264PPS));
 
   current_pps_.seq_parameter_set_id = current_sps_.seq_parameter_set_id;
   current_pps_.pic_parameter_set_id = 0;
 
   current_pps_.entropy_coding_mode_flag =
-      current_sps_.profile_idc >= media::H264SPS::kProfileIDCMain;
+      current_sps_.profile_idc >= H264SPS::kProfileIDCMain;
 
   CHECK_GT(max_ref_idx_l0_size_, 0u);
   current_pps_.num_ref_idx_l0_default_active_minus1 = max_ref_idx_l0_size_ - 1;
   current_pps_.num_ref_idx_l1_default_active_minus1 = 0;
   DCHECK_LE(qp_, 51u);
   current_pps_.pic_init_qp_minus26 = qp_ - 26;
   current_pps_.deblocking_filter_control_present_flag = true;
   current_pps_.transform_8x8_mode_flag =
-      (current_sps_.profile_idc == media::H264SPS::kProfileIDCHigh);
+      (current_sps_.profile_idc == H264SPS::kProfileIDCHigh);
 }
 
 void VaapiVideoEncodeAccelerator::GeneratePackedPPS() {
   packed_pps_.Reset();
 
-  packed_pps_.BeginNALU(media::H264NALU::kPPS, 3);
+  packed_pps_.BeginNALU(H264NALU::kPPS, 3);
 
   packed_pps_.AppendUE(current_pps_.pic_parameter_set_id);
   packed_pps_.AppendUE(current_pps_.seq_parameter_set_id);
   packed_pps_.AppendBool(current_pps_.entropy_coding_mode_flag);
   packed_pps_.AppendBool(
       current_pps_.bottom_field_pic_order_in_frame_present_flag);
   CHECK_EQ(current_pps_.num_slice_groups_minus1, 0);
   packed_pps_.AppendUE(current_pps_.num_slice_groups_minus1);
 
   packed_pps_.AppendUE(current_pps_.num_ref_idx_l0_default_active_minus1);
@@ skipping 45 matching lines @@
     client_ptr_factory_.reset();
   }
 }
 
 VaapiVideoEncodeAccelerator::EncodeJob::EncodeJob()
     : coded_buffer(VA_INVALID_ID), keyframe(false) {}
 
 VaapiVideoEncodeAccelerator::EncodeJob::~EncodeJob() {}
 
 }  // namespace media