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 243 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();

[kcwu, 2015/03/31 15:20:09]

Is EndFrame() always paired with BeginFrame() ?
If so, how about delete the reference to current_pic_ in EndFrame() ?

[Pawel Osciak, 2015/04/03 07:06:00]

Yes, I considered that, but I thought it would be better not to make functional
changes to VEA in this CL, in an unlikely case anything broke. That could make
the whole unrelated VDA change be reverted for a VEA issue.
I'll also keep this for later if you would be ok with that, sorry!

 
   // 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