VAVDA: Use the new, generic video decoder and accelerator infrastructure.

content/common/gpu/media/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 "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
@@ skipping 242 matching lines @@
 void VaapiVideoEncodeAccelerator::RecycleVASurfaceID(
     VASurfaceID va_surface_id) {
   DVLOGF(4) << "va_surface_id: " << va_surface_id;
   DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
 
   available_va_surface_ids_.push_back(va_surface_id);
   EncodeFrameTask();
 }
 
 void VaapiVideoEncodeAccelerator::BeginFrame(bool force_keyframe) {
-  memset(&current_pic_, 0, sizeof(current_pic_));
+  current_pic_ = new H264Picture();
 
   // If the current picture is an IDR picture, frame_num shall be equal to 0.
   if (force_keyframe)
     frame_num_ = 0;
 
-  current_pic_.frame_num = frame_num_++;
+  current_pic_->frame_num = frame_num_++;
   frame_num_ %= idr_period_;
 
-  if (current_pic_.frame_num == 0) {
-    current_pic_.idr = true;
+  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;
+  if (current_pic_->frame_num % i_period_ == 0)
+    current_pic_->type = media::H264SliceHeader::kISlice;
   else
-    current_pic_.type = media::H264SliceHeader::kPSlice;
+    current_pic_->type = media::H264SliceHeader::kPSlice;
 
-  if (current_pic_.type != media::H264SliceHeader::kBSlice)
-    current_pic_.ref = true;
+  if (current_pic_->type != media::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_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;
+  current_encode_job_->keyframe = current_pic_->idr;
 
-  DVLOGF(4) << "Starting a new frame, type: " << current_pic_.type
+  DVLOGF(4) << "Starting a new frame, type: " << current_pic_->type
             << (force_keyframe ? " (forced keyframe)" : "")
-            << " frame_num: " << current_pic_.frame_num
-            << " POC: " << current_pic_.pic_order_cnt;
+            << " frame_num: " << current_pic_->frame_num
+            << " POC: " << current_pic_->pic_order_cnt;
 }
 
 void VaapiVideoEncodeAccelerator::EndFrame() {
+  DCHECK(current_pic_);
   // Store the picture on the list of reference pictures and keep the list
   // below maximum size, dropping oldest references.
-  if (current_pic_.ref)
+  if (current_pic_->ref)
     ref_pic_list0_.push_front(current_encode_job_->recon_surface);
   size_t max_num_ref_frames =
       base::checked_cast<size_t>(current_sps_.max_num_ref_frames);
   while (ref_pic_list0_.size() > max_num_ref_frames)
     ref_pic_list0_.pop_back();
 
   submitted_encode_jobs_.push(make_linked_ptr(current_encode_job_.release()));
 }
 
 static void InitVAPicture(VAPictureH264* va_pic) {
   memset(va_pic, 0, sizeof(*va_pic));
   va_pic->picture_id = VA_INVALID_ID;
   va_pic->flags = VA_PICTURE_H264_INVALID;
 }
 
 bool VaapiVideoEncodeAccelerator::SubmitFrameParameters() {
+  DCHECK(current_pic_);
   VAEncSequenceParameterBufferH264 seq_param;
   memset(&seq_param, 0, sizeof(seq_param));
 
 #define SPS_TO_SP(a) seq_param.a = current_sps_.a;
   SPS_TO_SP(seq_parameter_set_id);
   SPS_TO_SP(level_idc);
 
   seq_param.intra_period = i_period_;
   seq_param.intra_idr_period = idr_period_;
   seq_param.ip_period = ip_period_;
@@ skipping 32 matching lines @@
 
   if (!vaapi_wrapper_->SubmitBuffer(VAEncSequenceParameterBufferType,
                                     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.TopFieldOrderCnt = current_pic_->top_field_order_cnt;
+  pic_param.CurrPic.BottomFieldOrderCnt = current_pic_->bottom_field_order_cnt;
   pic_param.CurrPic.flags = 0;
 
   for (size_t i = 0; i < arraysize(pic_param.ReferenceFrames); ++i)
     InitVAPicture(&pic_param.ReferenceFrames[i]);
 
   DCHECK_LE(ref_pic_list0_.size(), arraysize(pic_param.ReferenceFrames));
   RefPicList::const_iterator iter = ref_pic_list0_.begin();
   for (size_t i = 0;
        i < arraysize(pic_param.ReferenceFrames) && iter != ref_pic_list0_.end();
        ++iter, ++i) {
     pic_param.ReferenceFrames[i].picture_id = (*iter)->id();
     pic_param.ReferenceFrames[i].flags = 0;
   }
 
   pic_param.coded_buf = current_encode_job_->coded_buffer;
   pic_param.pic_parameter_set_id = current_pps_.pic_parameter_set_id;
   pic_param.seq_parameter_set_id = current_pps_.seq_parameter_set_id;
-  pic_param.frame_num = current_pic_.frame_num;
+  pic_param.frame_num = current_pic_->frame_num;
   pic_param.pic_init_qp = qp_;
   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;
+  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))
     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.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_;
-  slice_param.pic_order_cnt_lsb = current_pic_.pic_order_cnt_lsb;
+  slice_param.pic_order_cnt_lsb = current_pic_->pic_order_cnt_lsb;
   slice_param.num_ref_idx_active_override_flag = true;
 
   for (size_t i = 0; i < arraysize(slice_param.RefPicList0); ++i)
     InitVAPicture(&slice_param.RefPicList0[i]);
 
   for (size_t i = 0; i < arraysize(slice_param.RefPicList1); ++i)
     InitVAPicture(&slice_param.RefPicList1[i]);
 
   DCHECK_LE(ref_pic_list0_.size(), arraysize(slice_param.RefPicList0));
   iter = ref_pic_list0_.begin();
@@ skipping 39 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() {
-  if (current_pic_.type != media::H264SliceHeader::kISlice)
+  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),
@@ skipping 17 matching lines @@
 
   if (!vaapi_wrapper_->SubmitBuffer(VAEncPackedHeaderDataBufferType,
                                     packed_pps_.BytesInBuffer(),
                                     packed_pps_.data()))
     return false;
 
   return true;
 }
 
 bool VaapiVideoEncodeAccelerator::ExecuteEncode() {
-  DVLOGF(3) << "Encoding frame_num: " << current_pic_.frame_num;
+  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) {
   return vaapi_wrapper_->UploadVideoFrameToSurface(
       frame, current_encode_job_->input_surface->id());
 }
 
@@ skipping 538 matching lines @@
 }
 
 VaapiVideoEncodeAccelerator::EncodeJob::EncodeJob()
     : coded_buffer(VA_INVALID_ID), keyframe(false) {
 }
 
 VaapiVideoEncodeAccelerator::EncodeJob::~EncodeJob() {
 }
 
 }  // namespace content