Migrate content/common/gpu/media code to 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 "content/common/gpu/media/vaapi_video_encode_accelerator.h"
+#include "media/gpu/vaapi_video_encode_accelerator.h"
 
 #include <string.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
-#include "content/common/gpu/media/h264_dpb.h"
-#include "content/common/gpu/media/shared_memory_region.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/gpu/h264_dpb.h"
+#include "media/gpu/shared_memory_region.h"
 #include "third_party/libva/va/va_enc_h264.h"
 
 #define DVLOGF(level) DVLOG(level) << __FUNCTION__ << "(): "
 
-#define NOTIFY_ERROR(error, msg)                         \
-  do {                                                   \
-    SetState(kError);                                    \
-    LOG(ERROR) << msg;                                   \
-    LOG(ERROR) << "Calling NotifyError(" << error << ")";\
-    NotifyError(error);                                  \
+#define NOTIFY_ERROR(error, msg)                          \
+  do {                                                    \
+    SetState(kError);                                     \
+    LOG(ERROR) << msg;                                    \
+    LOG(ERROR) << "Calling NotifyError(" << error << ")"; \
+    NotifyError(error);                                   \
   } while (0)
 
-namespace content {
+namespace media {
 
 namespace {
 // Need 2 surfaces for each frame: one for input data and one for
 // reconstructed picture, which is later used for reference.
 const size_t kMinSurfacesToEncode = 2;
 
 // Subjectively chosen.
 const size_t kNumInputBuffers = 4;
 const size_t kMaxNumReferenceFrames = 4;
 
@@ skipping 24 matching lines @@
 // All Intel codecs can do at least 4.1.
 const int kDefaultLevelIDC = 41;
 const int kChromaFormatIDC = 1;  // 4:2:0
 
 // Arbitrarily chosen bitrate window size for rate control, in ms.
 const int kCPBWindowSizeMs = 1500;
 
 // UMA errors that the VaapiVideoEncodeAccelerator class reports.
 enum VAVEAEncoderFailure {
   VAAPI_ERROR = 0,
-  // UMA requires that max must be greater than 1.
-  VAVEA_ENCODER_FAILURES_MAX = 2,
+  VAVEA_ENCODER_FAILURES_MAX,

[Pawel Osciak, 2016/04/19 09:22:55]

Could we please keep the comment at the new location? However, to be honest, it
feels to me that +1 belonged here, since we won't need it anymore if more values
are added...

[Mark Dittmer, 2016/05/02 03:51:24]

Ditto to other comment. UMA requirements appear to have either changed or
originally been misinterpreted when =2 was used. The comment no longer applies.

 };
-
 }
 
 // Round |value| up to |alignment|, which must be a power of 2.
 static inline size_t RoundUpToPowerOf2(size_t value, size_t alignment) {
   // Check that |alignment| is a power of 2.
   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);
+  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)
       : frame(frame), force_keyframe(force_keyframe) {}
   const scoped_refptr<media::VideoFrame> frame;
   const bool force_keyframe;
 };
 
@@ skipping 66 matching lines @@
             << media::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;
-      });
+                         [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()) {
+      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) {
     DVLOGF(1) << "Unsupported input format: "
               << media::VideoPixelFormatToString(format);
     return false;
   }
@@ skipping 168 matching lines @@
 
   SPS_TO_SP(vui_parameters_present_flag);
 #define SPS_TO_SP_VF(a) seq_param.vui_fields.bits.a = current_sps_.a;
   SPS_TO_SP_VF(timing_info_present_flag);
 #undef SPS_TO_SP_VF
   SPS_TO_SP(num_units_in_tick);
   SPS_TO_SP(time_scale);
 #undef SPS_TO_SP
 
   if (!vaapi_wrapper_->SubmitBuffer(VAEncSequenceParameterBufferType,
-                                    sizeof(seq_param),
-                                    &seq_param))
+                                    sizeof(seq_param), &seq_param))
     return false;
 
   VAEncPictureParameterBufferH264 pic_param;
   memset(&pic_param, 0, sizeof(pic_param));
 
   pic_param.CurrPic.picture_id = current_encode_job_->recon_surface->id();
   pic_param.CurrPic.TopFieldOrderCnt = current_pic_->top_field_order_cnt;
   pic_param.CurrPic.BottomFieldOrderCnt = current_pic_->bottom_field_order_cnt;
   pic_param.CurrPic.flags = 0;
 
@@ skipping 17 matching lines @@
   pic_param.num_ref_idx_l0_active_minus1 = max_ref_idx_l0_size_ - 1;
   pic_param.pic_fields.bits.idr_pic_flag = current_pic_->idr;
   pic_param.pic_fields.bits.reference_pic_flag = current_pic_->ref;
 #define PPS_TO_PP_PF(a) pic_param.pic_fields.bits.a = current_pps_.a;
   PPS_TO_PP_PF(entropy_coding_mode_flag);
   PPS_TO_PP_PF(transform_8x8_mode_flag);
   PPS_TO_PP_PF(deblocking_filter_control_present_flag);
 #undef PPS_TO_PP_PF
 
   if (!vaapi_wrapper_->SubmitBuffer(VAEncPictureParameterBufferType,
-                                    sizeof(pic_param),
-                                    &pic_param))
+                                    sizeof(pic_param), &pic_param))
     return false;
 
   VAEncSliceParameterBufferH264 slice_param;
   memset(&slice_param, 0, sizeof(slice_param));
 
   slice_param.num_macroblocks = mb_width_ * mb_height_;
   slice_param.macroblock_info = VA_INVALID_ID;
   slice_param.slice_type = current_pic_->type;
   slice_param.pic_parameter_set_id = current_pps_.pic_parameter_set_id;
   slice_param.idr_pic_id = idr_pic_id_;
@@ skipping 10 matching lines @@
   iter = ref_pic_list0_.begin();
   for (size_t i = 0;
        i < arraysize(slice_param.RefPicList0) && iter != ref_pic_list0_.end();
        ++iter, ++i) {
     InitVAPicture(&slice_param.RefPicList0[i]);
     slice_param.RefPicList0[i].picture_id = (*iter)->id();
     slice_param.RefPicList0[i].flags = 0;
   }
 
   if (!vaapi_wrapper_->SubmitBuffer(VAEncSliceParameterBufferType,
-                                    sizeof(slice_param),
-                                    &slice_param))
+                                    sizeof(slice_param), &slice_param))
     return false;
 
   VAEncMiscParameterRateControl rate_control_param;
   memset(&rate_control_param, 0, sizeof(rate_control_param));
   rate_control_param.bits_per_second = bitrate_;
   rate_control_param.target_percentage = 90;
   rate_control_param.window_size = kCPBWindowSizeMs;
   rate_control_param.initial_qp = qp_;
   rate_control_param.rc_flags.bits.disable_frame_skip = true;
 
   if (!vaapi_wrapper_->SubmitVAEncMiscParamBuffer(
-          VAEncMiscParameterTypeRateControl,
-          sizeof(rate_control_param),
+          VAEncMiscParameterTypeRateControl, sizeof(rate_control_param),
           &rate_control_param))
     return false;
 
   VAEncMiscParameterFrameRate framerate_param;
   memset(&framerate_param, 0, sizeof(framerate_param));
   framerate_param.framerate = framerate_;
   if (!vaapi_wrapper_->SubmitVAEncMiscParamBuffer(
-          VAEncMiscParameterTypeFrameRate,
-          sizeof(framerate_param),
+          VAEncMiscParameterTypeFrameRate, sizeof(framerate_param),
           &framerate_param))
     return false;
 
   VAEncMiscParameterHRD hrd_param;
   memset(&hrd_param, 0, sizeof(hrd_param));
   hrd_param.buffer_size = cpb_size_;
   hrd_param.initial_buffer_fullness = cpb_size_ / 2;
-  if (!vaapi_wrapper_->SubmitVAEncMiscParamBuffer(VAEncMiscParameterTypeHRD,
-                                                  sizeof(hrd_param),
-                                                  &hrd_param))
+  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)
     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))
+                                    sizeof(par_buffer), &par_buffer))
     return false;
 
   if (!vaapi_wrapper_->SubmitBuffer(VAEncPackedHeaderDataBufferType,
                                     packed_sps_.BytesInBuffer(),
                                     packed_sps_.data()))
     return false;
 
   // Submit PPS.
   memset(&par_buffer, 0, sizeof(par_buffer));
   par_buffer.type = VAEncPackedHeaderPicture;
   par_buffer.bit_length = packed_pps_.BytesInBuffer() * 8;
 
   if (!vaapi_wrapper_->SubmitBuffer(VAEncPackedHeaderParameterBufferType,
-                                    sizeof(par_buffer),
-                                    &par_buffer))
+                                    sizeof(par_buffer), &par_buffer))
     return false;
 
   if (!vaapi_wrapper_->SubmitBuffer(VAEncPackedHeaderDataBufferType,
                                     packed_pps_.BytesInBuffer(),
                                     packed_pps_.data()))
     return false;
 
   return true;
 }
 
@@ skipping 230 matching lines @@
 void VaapiVideoEncodeAccelerator::Destroy() {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   // Can't call client anymore after Destroy() returns.
   client_ptr_factory_.reset();
   weak_this_ptr_factory_.InvalidateWeakPtrs();
 
   // Early-exit encoder tasks if they are running and join the thread.
   if (encoder_thread_.IsRunning()) {
     encoder_thread_.message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&VaapiVideoEncodeAccelerator::DestroyTask,
-                   base::Unretained(this)));
+        FROM_HERE, base::Bind(&VaapiVideoEncodeAccelerator::DestroyTask,
+                              base::Unretained(this)));
     encoder_thread_.Stop();
   }
 
   delete this;
 }
 
 void VaapiVideoEncodeAccelerator::DestroyTask() {
   DVLOGF(2);
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
   SetState(kError);
@@ skipping 66 matching lines @@
   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;
+       (kBitRateScale + media::H264SPS::kBitRateScaleConstantTerm)) -
+      1;
   current_sps_.cpb_size_value_minus1[0] =
       (cpb_size_ >>
-          (kCPBSizeScale + media::H264SPS::kCPBSizeScaleConstantTerm)) - 1;
+       (kCPBSizeScale + media::H264SPS::kCPBSizeScaleConstantTerm)) -
+      1;
   current_sps_.cbr_flag[0] = true;
   current_sps_.initial_cpb_removal_delay_length_minus_1 =
       media::H264SPS::kDefaultInitialCPBRemovalDelayLength - 1;
   current_sps_.cpb_removal_delay_length_minus1 =
       media::H264SPS::kDefaultInitialCPBRemovalDelayLength - 1;
   current_sps_.dpb_output_delay_length_minus1 =
       media::H264SPS::kDefaultDPBOutputDelayLength - 1;
   current_sps_.time_offset_length = media::H264SPS::kDefaultTimeOffsetLength;
   current_sps_.low_delay_hrd_flag = false;
 }
@@ skipping 83 matching lines @@
       packed_sps_.AppendBits(5, current_sps_.cpb_removal_delay_length_minus1);
       packed_sps_.AppendBits(5, current_sps_.dpb_output_delay_length_minus1);
       packed_sps_.AppendBits(5, current_sps_.time_offset_length);
     }
 
     packed_sps_.AppendBool(false);  // vcl_hrd_parameters_flag
     if (current_sps_.nal_hrd_parameters_present_flag)
       packed_sps_.AppendBool(current_sps_.low_delay_hrd_flag);
 
     packed_sps_.AppendBool(false);  // pic_struct_present_flag
-    packed_sps_.AppendBool(true);  // bitstream_restriction_flag
+    packed_sps_.AppendBool(true);   // bitstream_restriction_flag
 
     packed_sps_.AppendBool(false);  // motion_vectors_over_pic_boundaries_flag
-    packed_sps_.AppendUE(2);  // max_bytes_per_pic_denom
-    packed_sps_.AppendUE(1);  // max_bits_per_mb_denom
-    packed_sps_.AppendUE(16);  // log2_max_mv_length_horizontal
-    packed_sps_.AppendUE(16);  // log2_max_mv_length_vertical
+    packed_sps_.AppendUE(2);        // max_bytes_per_pic_denom
+    packed_sps_.AppendUE(1);        // max_bits_per_mb_denom
+    packed_sps_.AppendUE(16);       // log2_max_mv_length_horizontal
+    packed_sps_.AppendUE(16);       // log2_max_mv_length_vertical
 
     // Explicitly set max_num_reorder_frames to 0 to allow the decoder to
     // output pictures early.
     packed_sps_.AppendUE(0);  // max_num_reorder_frames
 
     // The value of max_dec_frame_buffering shall be greater than or equal to
     // max_num_ref_frames.
     const unsigned int max_dec_frame_buffering =
         current_sps_.max_num_ref_frames;
     packed_sps_.AppendUE(max_dec_frame_buffering);
@@ skipping 78 matching lines @@
     return;
   }
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
 VaapiVideoEncodeAccelerator::EncodeJob::EncodeJob()
-    : coded_buffer(VA_INVALID_ID), keyframe(false) {
-}
+    : coded_buffer(VA_INVALID_ID), keyframe(false) {}
 
-VaapiVideoEncodeAccelerator::EncodeJob::~EncodeJob() {
-}
+VaapiVideoEncodeAccelerator::EncodeJob::~EncodeJob() {}
 
-}  // namespace content
+}  // namespace media