Add VaapiVideoEncodeAccelerator for HW-accelerated video encode.

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/command_line.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/metrics/histogram.h"
+#include "base/numerics/safe_conversions.h"
+#include "content/common/gpu/media/h264_dpb.h"
+#include "content/public/common/content_switches.h"
+#include "media/base/bind_to_current_loop.h"
+#include "third_party/libva/va/va_enc_h264.h"
+
+#define DVLOGF(level) DVLOG(level) << __FUNCTION__ << "(): "
+
+#define NOTIFY_ERROR(error, msg)                         \
+  do {                                                   \
+    SetState(kError);                                    \
+    DVLOGF(1) << msg;                                    \
+    DVLOGF(1) << "Calling NotifyError(" << error << ")"; \
+    NotifyError(error);                                  \
+  } while (0)
+
+namespace content {
+
+namespace {
+// Need 2 surfaces for each frame: one for input data and one for
+// reconstructed picture, which is later used for reference.
+const int kMinSurfacesToEncode = 2;
+
+// Subjectively chosen.
+const int kNumInputBuffers = 4;
+const int kMaxNumReferenceFrames = 4;
+
+// We need up to kMaxNumReferenceFrames surfaces for reference, plus one
+// for input and one for encode (which will be added to the set of reference
+// frames for subsequent frames). Actual execution of HW encode is done
+// in parallel, and we want to process more frames in the meantime.
+// To have kNumInputBuffers in flight, we need a full set of reference +
+// encode surfaces (i.e. kMaxNumReferenceFrames + kMinSurfacesToEncode), and
+// (kNumInputBuffers - 1) of kMinSurfacesToEncode for the remaining frames
+// in flight.
+const int kNumSurfaces = kMaxNumReferenceFrames + kMinSurfacesToEncode +
+                         kMinSurfacesToEncode * (kNumInputBuffers - 1);
+
+// An IDR every 128 frames, an I frame every 30 and no B frames.
+const int kIDRPeriod = 128;
+const int kIPeriod = 30;
+const int kIPPeriod = 1;
+
+const int kDefaultFramerate = 30;
+
+// HRD parameters (ch. E.2.2 in spec).
+const int kBitRateScale = 0;  // bit_rate_scale for SPS HRD parameters.
+const int kCPBSizeScale = 0;  // cpb_size_scale for SPS HRD parameters.
+
+const int kDefaultQP = 26;
+// 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;
+}
+
+// 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(
+    VaapiVideoEncodeAccelerator::VAVEAEncoderFailure failure) {
+  UMA_HISTOGRAM_ENUMERATION(
+      "Media.VAVEA.EncoderFailure",
+      failure,
+      VaapiVideoEncodeAccelerator::VAVEA_ENCODER_FAILURES_MAX);
+}
+
+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;
+};
+
+struct VaapiVideoEncodeAccelerator::BitstreamBufferRef {
+  BitstreamBufferRef(int32 id, scoped_ptr<base::SharedMemory> shm, size_t size)
+      : id(id), shm(shm.Pass()), size(size) {}
+  const int32 id;
+  const scoped_ptr<base::SharedMemory> shm;
+  const size_t size;
+};
+
+// static
+std::vector<media::VideoEncodeAccelerator::SupportedProfile>
+VaapiVideoEncodeAccelerator::GetSupportedProfiles() {
+  std::vector<SupportedProfile> profiles;
+
+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+  if (!cmd_line->HasSwitch(switches::kEnableVaapiAcceleratedVideoEncode))
+    return profiles;
+
+  SupportedProfile profile;
+  profile.profile = media::H264PROFILE_MAIN;
+  profile.max_resolution.SetSize(1920, 1088);
+  profile.max_framerate.numerator = kDefaultFramerate;
+  profile.max_framerate.denominator = 1;
+  profiles.push_back(profile);
+
+  // This is actually only constrained (see crbug.com/345569).
+  profile.profile = media::H264PROFILE_BASELINE;
+  profiles.push_back(profile);
+
+  profile.profile = media::H264PROFILE_HIGH;
+  profiles.push_back(profile);
+
+  return profiles;
+}
+
+static unsigned int Log2OfPowerOf2(unsigned int x) {
+  CHECK_GT(x, 0);
+  DCHECK_EQ(x & (x - 1), 0);
+
+  int log = 0;
+  while (x) {
+    x >>= 1;
+    ++log;
+  }
+  return log;
+}
+
+VaapiVideoEncodeAccelerator::VaapiVideoEncodeAccelerator(Display* x_display)
+    : profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
+      mb_width_(0),
+      mb_height_(0),
+      output_buffer_byte_size_(0),
+      x_display_(x_display),
+      state_(kUninitialized),
+      frame_num_(0),
+      last_idr_frame_num_(0),
+      bitrate_(0),
+      framerate_(0),
+      cpb_size_(0),
+      encoding_parameters_changed_(false),
+      encoder_thread_("VAVEAEncoderThread"),
+      child_message_loop_proxy_(base::MessageLoopProxy::current()),
+      weak_this_ptr_factory_(this) {
+  DVLOGF(4);
+  weak_this_ = weak_this_ptr_factory_.GetWeakPtr();
+
+  max_ref_idx_l0_size_ = kMaxNumReferenceFrames;
+  qp_ = kDefaultQP;
+  idr_period_ = kIDRPeriod;
+  i_period_ = kIPeriod;
+  ip_period_ = kIPPeriod;
+}
+
+VaapiVideoEncodeAccelerator::~VaapiVideoEncodeAccelerator() {
+  DVLOGF(4);
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(!encoder_thread_.IsRunning());
+}
+
+bool VaapiVideoEncodeAccelerator::Initialize(
+    media::VideoFrame::Format format,
+    const gfx::Size& input_visible_size,
+    media::VideoCodecProfile output_profile,
+    uint32 initial_bitrate,
+    Client* client) {
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(!encoder_thread_.IsRunning());
+  DCHECK_EQ(state_, kUninitialized);
+
+  DVLOGF(1) << "Initializing VAVEA, input_format: "
+            << media::VideoFrame::FormatToString(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();
+
+  if (output_profile < media::H264PROFILE_BASELINE ||
+      output_profile > media::H264PROFILE_MAIN) {
+    DVLOGF(1) << "Unsupported output profile: " << output_profile;
+    return false;
+  }
+
+  if (format != media::VideoFrame::I420) {
+    DVLOGF(1) << "Unsupported input format: "
+              << media::VideoFrame::FormatToString(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));
+  mb_width_ = coded_size_.width() / 16;
+  mb_height_ = coded_size_.height() / 16;
+  output_buffer_byte_size_ = coded_size_.GetArea();
+
+  UpdateRates(initial_bitrate, kDefaultFramerate);
+
+  vaapi_wrapper_ = VaapiWrapper::Create(VaapiWrapper::kEncode,
+                                        output_profile,
+                                        x_display_,
+                                        base::Bind(&ReportToUMA, VAAPI_ERROR));
+  if (!vaapi_wrapper_) {
+    DVLOGF(1) << "Failed initializing VAAPI";
+    return false;
+  }
+
+  if (!encoder_thread_.Start()) {
+    DVLOGF(1) << "Failed to start encoder thread";
+    return false;
+  }
+  encoder_thread_proxy_ = encoder_thread_.message_loop_proxy();
+
+  // Finish the remaining initialization on the encoder thread.
+  encoder_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&VaapiVideoEncodeAccelerator::InitializeTask,
+                 base::Unretained(this)));
+
+  return true;
+}
+
+void VaapiVideoEncodeAccelerator::InitializeTask() {
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK_EQ(state_, kUninitialized);
+  DVLOGF(4);
+
+  va_surface_release_cb_ = media::BindToCurrentLoop(
+      base::Bind(&VaapiVideoEncodeAccelerator::RecycleVASurfaceID,
+                 base::Unretained(this)));
+
+  if (!vaapi_wrapper_->CreateSurfaces(
+          coded_size_, kNumSurfaces, &available_va_surface_ids_)) {
+    NOTIFY_ERROR(kPlatformFailureError, "Failed creating VASurfaces");
+    return;
+  }
+
+  UpdateSPS();
+  GeneratePackedSPS();
+
+  UpdatePPS();
+  GeneratePackedPPS();
+
+  child_message_loop_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&Client::RequireBitstreamBuffers,
+                 client_,
+                 kNumInputBuffers,
+                 coded_size_,
+                 output_buffer_byte_size_));
+
+  SetState(kEncoding);
+}
+
+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_.frame_num = frame_num_++;
+  frame_num_ %= idr_period_;
+
+  if (current_pic_.frame_num % i_period_ == 0 || force_keyframe)
+    current_pic_.type = media::H264SliceHeader::kISlice;
+  else
+    current_pic_.type = media::H264SliceHeader::kPSlice;
+
+  if (current_pic_.frame_num % idr_period_ == 0) {
+    current_pic_.idr = true;
+    last_idr_frame_num_ = current_pic_.frame_num;
+    ref_pic_list0_.clear();
+  }
+
+  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_encode_job_->keyframe =
+      (current_pic_.type == media::H264SliceHeader::kISlice);
+
+  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;
+}
+
+void VaapiVideoEncodeAccelerator::EndFrame() {
+  // Store the picture on the list of reference pictures and keep the list
+  // below maximum size, dropping oldest references.
+  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() {
+  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_;
+  seq_param.bits_per_second = bitrate_;
+
+  SPS_TO_SP(max_num_ref_frames);
+  seq_param.picture_width_in_mbs = mb_width_;
+  seq_param.picture_height_in_mbs = mb_height_;
+
+#define SPS_TO_SP_FS(a) seq_param.seq_fields.bits.a = current_sps_.a;
+  SPS_TO_SP_FS(chroma_format_idc);
+  SPS_TO_SP_FS(frame_mbs_only_flag);
+  SPS_TO_SP_FS(log2_max_frame_num_minus4);
+  SPS_TO_SP_FS(pic_order_cnt_type);
+  SPS_TO_SP_FS(log2_max_pic_order_cnt_lsb_minus4);
+#undef SPS_TO_SP_FS
+
+  SPS_TO_SP(bit_depth_luma_minus8);
+  SPS_TO_SP(bit_depth_chroma_minus8);
+
+  SPS_TO_SP(frame_cropping_flag);
+  if (current_sps_.frame_cropping_flag) {
+    SPS_TO_SP(frame_crop_left_offset);
+    SPS_TO_SP(frame_crop_right_offset);
+    SPS_TO_SP(frame_crop_top_offset);
+    SPS_TO_SP(frame_crop_bottom_offset);
+  }
+
+  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))
+    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;
+
+  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.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;
+#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.pic_parameter_set_id = current_pps_.pic_parameter_set_id;
+  slice_param.idr_pic_id = last_idr_frame_num_;
+  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();
+  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))
+    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),
+          &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),
+          &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))
+    return false;
+
+  return true;
+}
+
+bool VaapiVideoEncodeAccelerator::SubmitHeadersIfNeeded() {
+  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))
+    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))
+    return false;
+
+  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;
+  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());
+}
+
+void VaapiVideoEncodeAccelerator::TryToReturnBitstreamBuffer() {
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
+
+  if (state_ != kEncoding)
+    return;
+
+  if (submitted_encode_jobs_.empty() || available_bitstream_buffers_.empty())
+    return;
+
+  linked_ptr<BitstreamBufferRef> buffer = available_bitstream_buffers_.front();
+  available_bitstream_buffers_.pop();
+
+  uint8* target_data = reinterpret_cast<uint8*>(buffer->shm->memory());
+
+  linked_ptr<EncodeJob> encode_job = submitted_encode_jobs_.front();
+  submitted_encode_jobs_.pop();
+
+  size_t data_size = 0;
+  if (!vaapi_wrapper_->DownloadAndDestroyCodedBuffer(
+          encode_job->coded_buffer,
+          encode_job->input_surface->id(),
+          target_data,
+          buffer->size,
+          &data_size)) {
+    NOTIFY_ERROR(kPlatformFailureError, "Failed downloading coded buffer");
+    return;
+  }
+
+  DVLOGF(3) << "Returning bitstream buffer "
+            << (encode_job->keyframe ? "(keyframe)" : "")
+            << " id: " << buffer->id << " size: " << data_size;
+
+  child_message_loop_proxy_->PostTask(FROM_HERE,
+                                      base::Bind(&Client::BitstreamBufferReady,
+                                                 client_,
+                                                 buffer->id,
+                                                 data_size,
+                                                 encode_job->keyframe));
+}
+
+void VaapiVideoEncodeAccelerator::Encode(
+    const scoped_refptr<media::VideoFrame>& frame,
+    bool force_keyframe) {
+  DVLOGF(3) << "Frame timestamp: " << frame->timestamp().InMilliseconds()
+            << " force_keyframe: " << force_keyframe;
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+
+  encoder_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&VaapiVideoEncodeAccelerator::EncodeTask,
+                 base::Unretained(this),
+                 frame,
+                 force_keyframe));
+}
+
+bool VaapiVideoEncodeAccelerator::PrepareNextJob() {
+  if (available_va_surface_ids_.size() < kMinSurfacesToEncode)
+    return false;
+
+  DCHECK(!current_encode_job_);
+  current_encode_job_.reset(new EncodeJob());
+
+  if (!vaapi_wrapper_->CreateCodedBuffer(output_buffer_byte_size_,
+                                         &current_encode_job_->coded_buffer)) {
+    NOTIFY_ERROR(kPlatformFailureError, "Failed creating coded buffer");
+    return false;
+  }
+
+  current_encode_job_->input_surface =
+      new VASurface(available_va_surface_ids_.back(), va_surface_release_cb_);
+  available_va_surface_ids_.pop_back();
+
+  current_encode_job_->recon_surface =
+      new VASurface(available_va_surface_ids_.back(), va_surface_release_cb_);
+  available_va_surface_ids_.pop_back();
+
+  // 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,
+    bool force_keyframe) {
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK_NE(state_, kUninitialized);
+
+  encoder_input_queue_.push(
+      make_linked_ptr(new InputFrameRef(frame, force_keyframe)));
+  EncodeFrameTask();
+}
+
+void VaapiVideoEncodeAccelerator::EncodeFrameTask() {
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
+
+  if (state_ != kEncoding || encoder_input_queue_.empty())
+    return;
+
+  if (!PrepareNextJob()) {
+    DVLOGF(4) << "Not ready for next frame yet";
+    return;
+  }
+
+  linked_ptr<InputFrameRef> frame_ref = encoder_input_queue_.front();
+  encoder_input_queue_.pop();
+
+  if (!UploadFrame(frame_ref->frame)) {
+    NOTIFY_ERROR(kPlatformFailureError, "Failed uploading source frame to HW.");
+    return;
+  }
+
+  BeginFrame(frame_ref->force_keyframe || encoding_parameters_changed_);
+  encoding_parameters_changed_ = false;
+
+  if (!SubmitFrameParameters()) {
+    NOTIFY_ERROR(kPlatformFailureError, "Failed submitting frame parameters.");
+    return;
+  }
+
+  if (!SubmitHeadersIfNeeded()) {
+    NOTIFY_ERROR(kPlatformFailureError, "Failed submitting frame headers.");
+    return;
+  }
+
+  if (!ExecuteEncode()) {
+    NOTIFY_ERROR(kPlatformFailureError, "Failed submitting encode job to HW.");
+    return;
+  }
+
+  EndFrame();
+  TryToReturnBitstreamBuffer();
+}
+
+void VaapiVideoEncodeAccelerator::UseOutputBitstreamBuffer(
+    const media::BitstreamBuffer& buffer) {
+  DVLOGF(4) << "id: " << buffer.id();
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+
+  if (buffer.size() < output_buffer_byte_size_) {
+    NOTIFY_ERROR(kInvalidArgumentError, "Provided bitstream buffer too small");
+    return;
+  }
+
+  scoped_ptr<base::SharedMemory> shm(
+      new base::SharedMemory(buffer.handle(), false));
+  if (!shm->Map(buffer.size())) {
+    NOTIFY_ERROR(kPlatformFailureError, "Failed mapping shared memory.");
+    return;
+  }
+
+  scoped_ptr<BitstreamBufferRef> buffer_ref(
+      new BitstreamBufferRef(buffer.id(), shm.Pass(), buffer.size()));
+
+  encoder_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&VaapiVideoEncodeAccelerator::UseOutputBitstreamBufferTask,
+                 base::Unretained(this),
+                 base::Passed(&buffer_ref)));
+}
+
+void VaapiVideoEncodeAccelerator::UseOutputBitstreamBufferTask(
+    scoped_ptr<BitstreamBufferRef> buffer_ref) {
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK_NE(state_, kUninitialized);
+
+  available_bitstream_buffers_.push(make_linked_ptr(buffer_ref.release()));
+  TryToReturnBitstreamBuffer();
+}
+
+void VaapiVideoEncodeAccelerator::RequestEncodingParametersChange(
+    uint32 bitrate,
+    uint32 framerate) {
+  DVLOGF(2) << "bitrate: " << bitrate << " framerate: " << framerate;
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+
+  encoder_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &VaapiVideoEncodeAccelerator::RequestEncodingParametersChangeTask,
+          base::Unretained(this),
+          bitrate,
+          framerate));
+}
+
+void VaapiVideoEncodeAccelerator::UpdateRates(uint32 bitrate,
+                                              uint32 framerate) {
+  if (encoder_thread_.IsRunning())
+    DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK_NE(bitrate, 0);
+  DCHECK_NE(framerate, 0);
+  bitrate_ = bitrate;
+  framerate_ = framerate;
+  cpb_size_ = bitrate_ * kCPBWindowSizeMs / 1000;
+}
+
+void VaapiVideoEncodeAccelerator::RequestEncodingParametersChangeTask(
+    uint32 bitrate,
+    uint32 framerate) {
+  DVLOGF(2) << "bitrate: " << bitrate << " framerate: " << framerate;
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
+  DCHECK_NE(state_, kUninitialized);
+
+  UpdateRates(bitrate, framerate);
+
+  UpdateSPS();
+  GeneratePackedSPS();
+
+  // Submit new parameters along with next frame that will be processed.
+  encoding_parameters_changed_ = true;
+}
+
+void VaapiVideoEncodeAccelerator::Destroy() {
+  DCHECK(child_message_loop_proxy_->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)));
+    encoder_thread_.Stop();
+  }
+
+  delete this;
+}
+
+void VaapiVideoEncodeAccelerator::DestroyTask() {
+  DVLOGF(2);
+  DCHECK(encoder_thread_proxy_->BelongsToCurrentThread());
+  SetState(kError);
+}
+
+void VaapiVideoEncodeAccelerator::UpdateSPS() {
+  memset(&current_sps_, 0, sizeof(media::H264SPS));
+
+  // Spec A.2 and A.3.
+  switch (profile_) {
+    case media::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_.constraint_set0_flag = true;
+      break;
+    case media::H264PROFILE_MAIN:
+      current_sps_.profile_idc = media::H264SPS::kProfileIDCMain;
+      current_sps_.constraint_set1_flag = true;
+      break;
+    case media::H264PROFILE_HIGH:
+      current_sps_.profile_idc = media::H264SPS::kProfileIDCHigh;
+      break;
+    default:
+      NOTIMPLEMENTED();
+      return;
+  }
+
+  current_sps_.level_idc = kDefaultLevelIDC;
+  current_sps_.seq_parameter_set_id = 0;
+  current_sps_.chroma_format_idc = kChromaFormatIDC;
+
+  DCHECK_GE(idr_period_, 1 << 4);
+  current_sps_.log2_max_frame_num_minus4 = Log2OfPowerOf2(idr_period_) - 4;
+  current_sps_.pic_order_cnt_type = 0;
+  current_sps_.log2_max_pic_order_cnt_lsb_minus4 =
+      Log2OfPowerOf2(idr_period_ * 2) - 4;
+  current_sps_.max_num_ref_frames = max_ref_idx_l0_size_;
+
+  current_sps_.frame_mbs_only_flag = true;
+
+  DCHECK_GT(mb_width_, 0);
+  DCHECK_GT(mb_height_, 0);
+  current_sps_.pic_width_in_mbs_minus1 = mb_width_ - 1;
+  DCHECK(current_sps_.frame_mbs_only_flag);
+  current_sps_.pic_height_in_map_units_minus1 = mb_height_ - 1;
+
+  if (visible_size_ != coded_size_) {
+    // Visible size differs from coded size, fill crop information.
+    current_sps_.frame_cropping_flag = true;
+    DCHECK(!current_sps_.separate_colour_plane_flag);
+    // Spec table 6-1. Only 4:2:0 for now.
+    DCHECK_EQ(current_sps_.chroma_format_idc, 1);
+    // Spec 7.4.2.1.1. Crop is in crop units, which is 2 pixels for 4:2:0.
+    const unsigned int crop_unit_x = 2;
+    const unsigned int crop_unit_y = 2 * (2 - current_sps_.frame_mbs_only_flag);
+    current_sps_.frame_crop_left_offset = 0;
+    current_sps_.frame_crop_right_offset =
+        (coded_size_.width() - visible_size_.width()) / crop_unit_x;
+    current_sps_.frame_crop_top_offset = 0;
+    current_sps_.frame_crop_bottom_offset =
+        (coded_size_.height() - visible_size_.height()) / crop_unit_y;
+  }
+
+  current_sps_.vui_parameters_present_flag = true;
+  current_sps_.timing_info_present_flag = true;
+  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;
+  current_sps_.cpb_size_value_minus1[0] =
+      (cpb_size_ >>
+          (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;
+}
+
+void VaapiVideoEncodeAccelerator::GeneratePackedSPS() {
+  packed_sps_.Reset();
+
+  packed_sps_.BeginNALU(media::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) {
+    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);
+  }
+
+  packed_sps_.AppendUE(current_sps_.log2_max_frame_num_minus4);
+  packed_sps_.AppendUE(current_sps_.pic_order_cnt_type);
+  if (current_sps_.pic_order_cnt_type == 0)
+    packed_sps_.AppendUE(current_sps_.log2_max_pic_order_cnt_lsb_minus4);
+  else if (current_sps_.pic_order_cnt_type == 1) {
+    CHECK(1);
+  }
+
+  packed_sps_.AppendUE(current_sps_.max_num_ref_frames);
+  packed_sps_.AppendBool(current_sps_.gaps_in_frame_num_value_allowed_flag);
+  packed_sps_.AppendUE(current_sps_.pic_width_in_mbs_minus1);
+  packed_sps_.AppendUE(current_sps_.pic_height_in_map_units_minus1);
+
+  packed_sps_.AppendBool(current_sps_.frame_mbs_only_flag);
+  if (!current_sps_.frame_mbs_only_flag)
+    packed_sps_.AppendBool(current_sps_.mb_adaptive_frame_field_flag);
+
+  packed_sps_.AppendBool(current_sps_.direct_8x8_inference_flag);
+
+  packed_sps_.AppendBool(current_sps_.frame_cropping_flag);
+  if (current_sps_.frame_cropping_flag) {
+    packed_sps_.AppendUE(current_sps_.frame_crop_left_offset);
+    packed_sps_.AppendUE(current_sps_.frame_crop_right_offset);
+    packed_sps_.AppendUE(current_sps_.frame_crop_top_offset);
+    packed_sps_.AppendUE(current_sps_.frame_crop_bottom_offset);
+  }
+
+  packed_sps_.AppendBool(current_sps_.vui_parameters_present_flag);
+  if (current_sps_.vui_parameters_present_flag) {
+    packed_sps_.AppendBool(false);  // aspect_ratio_info_present_flag
+    packed_sps_.AppendBool(false);  // overscan_info_present_flag
+    packed_sps_.AppendBool(false);  // video_signal_type_present_flag
+    packed_sps_.AppendBool(false);  // chroma_loc_info_present_flag
+
+    packed_sps_.AppendBool(current_sps_.timing_info_present_flag);
+    if (current_sps_.timing_info_present_flag) {
+      packed_sps_.AppendBits(32, current_sps_.num_units_in_tick);
+      packed_sps_.AppendBits(32, current_sps_.time_scale);
+      packed_sps_.AppendBool(current_sps_.fixed_frame_rate_flag);
+    }
+
+    packed_sps_.AppendBool(current_sps_.nal_hrd_parameters_present_flag);
+    if (current_sps_.nal_hrd_parameters_present_flag) {
+      packed_sps_.AppendUE(current_sps_.cpb_cnt_minus1);
+      packed_sps_.AppendBits(4, current_sps_.bit_rate_scale);
+      packed_sps_.AppendBits(4, current_sps_.cpb_size_scale);
+      CHECK_LT(base::checked_cast<size_t>(current_sps_.cpb_cnt_minus1),
+               arraysize(current_sps_.bit_rate_value_minus1));
+      for (int i = 0; i <= current_sps_.cpb_cnt_minus1; ++i) {
+        packed_sps_.AppendUE(current_sps_.bit_rate_value_minus1[i]);
+        packed_sps_.AppendUE(current_sps_.cpb_size_value_minus1[i]);
+        packed_sps_.AppendBool(current_sps_.cbr_flag[i]);
+      }
+      packed_sps_.AppendBits(
+          5, current_sps_.initial_cpb_removal_delay_length_minus_1);
+      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(false);  // bitstream_restriction_flag
+  }
+
+  packed_sps_.FinishNALU();
+}
+
+void VaapiVideoEncodeAccelerator::UpdatePPS() {
+  memset(&current_pps_, 0, sizeof(media::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;
+
+  CHECK_GT(max_ref_idx_l0_size_, 0);
+  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_, 51);
+  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);
+}
+
+void VaapiVideoEncodeAccelerator::GeneratePackedPPS() {
+  packed_pps_.Reset();
+
+  packed_pps_.BeginNALU(media::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);
+  packed_pps_.AppendUE(current_pps_.num_ref_idx_l1_default_active_minus1);
+
+  packed_pps_.AppendBool(current_pps_.weighted_pred_flag);
+  packed_pps_.AppendBits(2, current_pps_.weighted_bipred_idc);
+
+  packed_pps_.AppendSE(current_pps_.pic_init_qp_minus26);
+  packed_pps_.AppendSE(current_pps_.pic_init_qs_minus26);
+  packed_pps_.AppendSE(current_pps_.chroma_qp_index_offset);
+
+  packed_pps_.AppendBool(current_pps_.deblocking_filter_control_present_flag);
+  packed_pps_.AppendBool(current_pps_.constrained_intra_pred_flag);
+  packed_pps_.AppendBool(current_pps_.redundant_pic_cnt_present_flag);
+
+  packed_pps_.AppendBool(current_pps_.transform_8x8_mode_flag);
+  packed_pps_.AppendBool(current_pps_.pic_scaling_matrix_present_flag);
+  DCHECK(!current_pps_.pic_scaling_matrix_present_flag);
+  packed_pps_.AppendSE(current_pps_.second_chroma_qp_index_offset);
+
+  packed_pps_.FinishNALU();
+}
+
+void VaapiVideoEncodeAccelerator::SetState(State state) {
+  // Only touch state on encoder thread, unless it's not running.
+  if (encoder_thread_.IsRunning() &&
+      !encoder_thread_proxy_->BelongsToCurrentThread()) {
+    encoder_thread_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&VaapiVideoEncodeAccelerator::SetState,
+                   base::Unretained(this),
+                   state));
+    return;
+  }
+
+  DVLOGF(1) << "setting state to: " << state;
+  state_ = state;
+}
+
+void VaapiVideoEncodeAccelerator::NotifyError(Error error) {
+  if (!child_message_loop_proxy_->BelongsToCurrentThread()) {
+    child_message_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &VaapiVideoEncodeAccelerator::NotifyError, weak_this_, error));
+    return;
+  }
+
+  if (client_) {
+    client_->NotifyError(error);
+    client_ptr_factory_.reset();
+  }
+}
+
+VaapiVideoEncodeAccelerator::EncodeJob::EncodeJob()
+    : coded_buffer(VA_INVALID_ID), keyframe(false) {
+}
+
+}  // namespace content