Add accelerated VP9 decode infrastructure and an implementation for VA-API.

content/common/gpu/media/vaapi_video_decode_accelerator.cc

 // Copyright (c) 2012 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_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/media/accelerated_video_decoder.h"
 #include "content/common/gpu/media/h264_decoder.h"
 #include "content/common/gpu/media/vaapi_picture.h"
 #include "content/common/gpu/media/vp8_decoder.h"
+#include "content/common/gpu/media/vp9_decoder.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/video/picture.h"
 #include "third_party/libva/va/va_dec_vp8.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_image.h"
 
 namespace content {
 
 namespace {
 // UMA errors that the VaapiVideoDecodeAccelerator class reports.
@@ skipping 162 matching lines @@
  private:
   scoped_refptr<VaapiDecodeSurface> VP8PictureToVaapiDecodeSurface(
       const scoped_refptr<VP8Picture>& pic);
 
   VaapiWrapper* vaapi_wrapper_;
   VaapiVideoDecodeAccelerator* vaapi_dec_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiVP8Accelerator);
 };
 
+class VaapiVP9Picture : public VP9Picture {
+ public:
+  VaapiVP9Picture(
+      const scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface>&
+          dec_surface);
+
+  VaapiVP9Picture* AsVaapiVP9Picture() override { return this; }
+  scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface> dec_surface() {
+    return dec_surface_;
+  }
+
+ private:
+  ~VaapiVP9Picture() override;
+
+  scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface> dec_surface_;
+
+  DISALLOW_COPY_AND_ASSIGN(VaapiVP9Picture);
+};
+
+VaapiVP9Picture::VaapiVP9Picture(
+    const scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface>&
+        dec_surface)
+    : dec_surface_(dec_surface) {}
+
+VaapiVP9Picture::~VaapiVP9Picture() {}
+
+class VaapiVideoDecodeAccelerator::VaapiVP9Accelerator
+    : public VP9Decoder::VP9Accelerator {
+ public:
+  VaapiVP9Accelerator(VaapiVideoDecodeAccelerator* vaapi_dec,
+                      VaapiWrapper* vaapi_wrapper);
+  ~VaapiVP9Accelerator() override;
+
+  // VP9Decoder::VP9Accelerator implementation.
+  scoped_refptr<VP9Picture> CreateVP9Picture() override;
+
+  bool SubmitDecode(
+      const scoped_refptr<VP9Picture>& pic,
+      const media::Vp9Segmentation& seg,
+      const media::Vp9LoopFilter& lf,
+      const std::vector<scoped_refptr<VP9Picture>>& ref_pictures) override;
+
+  bool OutputPicture(const scoped_refptr<VP9Picture>& pic) override;
+
+ private:
+  scoped_refptr<VaapiDecodeSurface> VP9PictureToVaapiDecodeSurface(
+      const scoped_refptr<VP9Picture>& pic);
+
+  VaapiWrapper* vaapi_wrapper_;
+  VaapiVideoDecodeAccelerator* vaapi_dec_;
+
+  DISALLOW_COPY_AND_ASSIGN(VaapiVP9Accelerator);
+};
+
 VaapiVideoDecodeAccelerator::InputBuffer::InputBuffer() : id(0), size(0) {
 }
 
 VaapiVideoDecodeAccelerator::InputBuffer::~InputBuffer() {
 }
 
 void VaapiVideoDecodeAccelerator::NotifyError(Error error) {
   if (message_loop_ != base::MessageLoop::current()) {
     DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
     message_loop_->PostTask(FROM_HERE, base::Bind(
@@ skipping 83 matching lines @@
   }
 
   if (profile >= media::H264PROFILE_MIN && profile <= media::H264PROFILE_MAX) {
     h264_accelerator_.reset(
         new VaapiH264Accelerator(this, vaapi_wrapper_.get()));
     decoder_.reset(new H264Decoder(h264_accelerator_.get()));
   } else if (profile >= media::VP8PROFILE_MIN &&
              profile <= media::VP8PROFILE_MAX) {
     vp8_accelerator_.reset(new VaapiVP8Accelerator(this, vaapi_wrapper_.get()));
     decoder_.reset(new VP8Decoder(vp8_accelerator_.get()));
+  } else if (profile >= media::VP9PROFILE_MIN &&
+             profile <= media::VP9PROFILE_MAX) {
+    vp9_accelerator_.reset(new VaapiVP9Accelerator(this, vaapi_wrapper_.get()));
+    decoder_.reset(new VP9Decoder(vp9_accelerator_.get()));
   } else {
     DLOG(ERROR) << "Unsupported profile " << profile;
     return false;
   }
 
   CHECK(decoder_thread_.Start());
   decoder_thread_task_runner_ = decoder_thread_.task_runner();
 
   state_ = kIdle;
   return true;
@@ skipping 666 matching lines @@
     const media::H264SPS* sps,
     const media::H264PPS* pps,
     const H264DPB& dpb,
     const H264Picture::Vector& ref_pic_listp0,
     const H264Picture::Vector& ref_pic_listb0,
     const H264Picture::Vector& ref_pic_listb1,
     const scoped_refptr<H264Picture>& pic) {
   VAPictureParameterBufferH264 pic_param;
   memset(&pic_param, 0, sizeof(pic_param));
 
-#define FROM_SPS_TO_PP(a) pic_param.a = sps->a;
-#define FROM_SPS_TO_PP2(a, b) pic_param.b = sps->a;
+#define FROM_SPS_TO_PP(a) pic_param.a = sps->a
+#define FROM_SPS_TO_PP2(a, b) pic_param.b = sps->a
   FROM_SPS_TO_PP2(pic_width_in_mbs_minus1, picture_width_in_mbs_minus1);
   // This assumes non-interlaced video
   FROM_SPS_TO_PP2(pic_height_in_map_units_minus1, picture_height_in_mbs_minus1);
   FROM_SPS_TO_PP(bit_depth_luma_minus8);
   FROM_SPS_TO_PP(bit_depth_chroma_minus8);
 #undef FROM_SPS_TO_PP
 #undef FROM_SPS_TO_PP2
 
-#define FROM_SPS_TO_PP_SF(a) pic_param.seq_fields.bits.a = sps->a;
-#define FROM_SPS_TO_PP_SF2(a, b) pic_param.seq_fields.bits.b = sps->a;
+#define FROM_SPS_TO_PP_SF(a) pic_param.seq_fields.bits.a = sps->a
+#define FROM_SPS_TO_PP_SF2(a, b) pic_param.seq_fields.bits.b = sps->a
   FROM_SPS_TO_PP_SF(chroma_format_idc);
   FROM_SPS_TO_PP_SF2(separate_colour_plane_flag,
                      residual_colour_transform_flag);
   FROM_SPS_TO_PP_SF(gaps_in_frame_num_value_allowed_flag);
   FROM_SPS_TO_PP_SF(frame_mbs_only_flag);
   FROM_SPS_TO_PP_SF(mb_adaptive_frame_field_flag);
   FROM_SPS_TO_PP_SF(direct_8x8_inference_flag);
   pic_param.seq_fields.bits.MinLumaBiPredSize8x8 = (sps->level_idc >= 31);
   FROM_SPS_TO_PP_SF(log2_max_frame_num_minus4);
   FROM_SPS_TO_PP_SF(pic_order_cnt_type);
   FROM_SPS_TO_PP_SF(log2_max_pic_order_cnt_lsb_minus4);
   FROM_SPS_TO_PP_SF(delta_pic_order_always_zero_flag);
 #undef FROM_SPS_TO_PP_SF
 #undef FROM_SPS_TO_PP_SF2
 
-#define FROM_PPS_TO_PP(a) pic_param.a = pps->a;
+#define FROM_PPS_TO_PP(a) pic_param.a = pps->a
   FROM_PPS_TO_PP(num_slice_groups_minus1);
   pic_param.slice_group_map_type = 0;
   pic_param.slice_group_change_rate_minus1 = 0;
   FROM_PPS_TO_PP(pic_init_qp_minus26);
   FROM_PPS_TO_PP(pic_init_qs_minus26);
   FROM_PPS_TO_PP(chroma_qp_index_offset);
   FROM_PPS_TO_PP(second_chroma_qp_index_offset);
 #undef FROM_PPS_TO_PP
 
-#define FROM_PPS_TO_PP_PF(a) pic_param.pic_fields.bits.a = pps->a;
-#define FROM_PPS_TO_PP_PF2(a, b) pic_param.pic_fields.bits.b = pps->a;
+#define FROM_PPS_TO_PP_PF(a) pic_param.pic_fields.bits.a = pps->a
+#define FROM_PPS_TO_PP_PF2(a, b) pic_param.pic_fields.bits.b = pps->a
   FROM_PPS_TO_PP_PF(entropy_coding_mode_flag);
   FROM_PPS_TO_PP_PF(weighted_pred_flag);
   FROM_PPS_TO_PP_PF(weighted_bipred_idc);
   FROM_PPS_TO_PP_PF(transform_8x8_mode_flag);
 
   pic_param.pic_fields.bits.field_pic_flag = 0;
   FROM_PPS_TO_PP_PF(constrained_intra_pred_flag);
   FROM_PPS_TO_PP_PF2(bottom_field_pic_order_in_frame_present_flag,
                      pic_order_present_flag);
   FROM_PPS_TO_PP_PF(deblocking_filter_control_present_flag);
@@ skipping 61 matching lines @@
     const uint8_t* data,
     size_t size) {
   VASliceParameterBufferH264 slice_param;
   memset(&slice_param, 0, sizeof(slice_param));
 
   slice_param.slice_data_size = slice_hdr->nalu_size;
   slice_param.slice_data_offset = 0;
   slice_param.slice_data_flag = VA_SLICE_DATA_FLAG_ALL;
   slice_param.slice_data_bit_offset = slice_hdr->header_bit_size;
 
-#define SHDRToSP(a) slice_param.a = slice_hdr->a;
+#define SHDRToSP(a) slice_param.a = slice_hdr->a
   SHDRToSP(first_mb_in_slice);
   slice_param.slice_type = slice_hdr->slice_type % 5;
   SHDRToSP(direct_spatial_mv_pred_flag);
 
   // TODO posciak: make sure parser sets those even when override flags
   // in slice header is off.
   SHDRToSP(num_ref_idx_l0_active_minus1);
   SHDRToSP(num_ref_idx_l1_active_minus1);
   SHDRToSP(cabac_init_idc);
   SHDRToSP(slice_qp_delta);
@@ skipping 262 matching lines @@
         VP8PictureToVaapiDecodeSurface(alt_frame);
     pic_param.alt_ref_frame = alt_frame_surface->va_surface()->id();
   } else {
     pic_param.alt_ref_frame = VA_INVALID_SURFACE;
   }
 
   pic_param.out_of_loop_frame = VA_INVALID_SURFACE;
 
   const media::Vp8LoopFilterHeader& lf_hdr = frame_hdr->loopfilter_hdr;
 
-#define FHDR_TO_PP_PF(a, b) pic_param.pic_fields.bits.a = (b);
+#define FHDR_TO_PP_PF(a, b) pic_param.pic_fields.bits.a = (b)
   FHDR_TO_PP_PF(key_frame, frame_hdr->IsKeyframe() ? 0 : 1);
   FHDR_TO_PP_PF(version, frame_hdr->version);
   FHDR_TO_PP_PF(segmentation_enabled, sgmnt_hdr.segmentation_enabled);
   FHDR_TO_PP_PF(update_mb_segmentation_map,
                 sgmnt_hdr.update_mb_segmentation_map);
   FHDR_TO_PP_PF(update_segment_feature_data,
                 sgmnt_hdr.update_segment_feature_data);
   FHDR_TO_PP_PF(filter_type, lf_hdr.type);
   FHDR_TO_PP_PF(sharpness_level, lf_hdr.sharpness_level);
   FHDR_TO_PP_PF(loop_filter_adj_enable, lf_hdr.loop_filter_adj_enable);
@@ skipping 29 matching lines @@
                 arraysize(lf_hdr.mb_mode_delta) ==
                     arraysize(pic_param.loop_filter_deltas_mode) &&
                 arraysize(lf_hdr.ref_frame_delta) ==
                     arraysize(lf_hdr.mb_mode_delta),
                 "loop filter deltas arrays size mismatch");
   for (size_t i = 0; i < arraysize(lf_hdr.ref_frame_delta); ++i) {
     pic_param.loop_filter_deltas_ref_frame[i] = lf_hdr.ref_frame_delta[i];
     pic_param.loop_filter_deltas_mode[i] = lf_hdr.mb_mode_delta[i];
   }
 
-#define FHDR_TO_PP(a) pic_param.a = frame_hdr->a;
+#define FHDR_TO_PP(a) pic_param.a = frame_hdr->a
   FHDR_TO_PP(prob_skip_false);
   FHDR_TO_PP(prob_intra);
   FHDR_TO_PP(prob_last);
   FHDR_TO_PP(prob_gf);
 #undef FHDR_TO_PP
 
   ARRAY_MEMCPY_CHECKED(pic_param.y_mode_probs, entr_hdr.y_mode_probs);
   ARRAY_MEMCPY_CHECKED(pic_param.uv_mode_probs, entr_hdr.uv_mode_probs);
   ARRAY_MEMCPY_CHECKED(pic_param.mv_probs, entr_hdr.mv_probs);
 
   pic_param.bool_coder_ctx.range = frame_hdr->bool_dec_range;
   pic_param.bool_coder_ctx.value = frame_hdr->bool_dec_value;
   pic_param.bool_coder_ctx.count = frame_hdr->bool_dec_count;
 
   if (!vaapi_wrapper_->SubmitBuffer(VAPictureParameterBufferType,
-                                    sizeof(VAPictureParameterBufferVP8),
-                                    &pic_param))
+                                    sizeof(pic_param), &pic_param))
     return false;
 
   VASliceParameterBufferVP8 slice_param;
-  memset(&slice_param, 0, sizeof(VASliceParameterBufferVP8));
+  memset(&slice_param, 0, sizeof(slice_param));
   slice_param.slice_data_size = frame_hdr->frame_size;
   slice_param.slice_data_offset = frame_hdr->first_part_offset;
   slice_param.slice_data_flag = VA_SLICE_DATA_FLAG_ALL;
   slice_param.macroblock_offset = frame_hdr->macroblock_bit_offset;
   // Number of DCT partitions plus control partition.
   slice_param.num_of_partitions = frame_hdr->num_of_dct_partitions + 1;
 
   // Per VAAPI, this size only includes the size of the macroblock data in
   // the first partition (in bytes), so we have to subtract the header size.
   slice_param.partition_size[0] =
@@ skipping 29 matching lines @@
 }
 
 scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface>
 VaapiVideoDecodeAccelerator::VaapiVP8Accelerator::
     VP8PictureToVaapiDecodeSurface(const scoped_refptr<VP8Picture>& pic) {
   VaapiVP8Picture* vaapi_pic = pic->AsVaapiVP8Picture();
   CHECK(vaapi_pic);
   return vaapi_pic->dec_surface();
 }
 
+VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::VaapiVP9Accelerator(
+    VaapiVideoDecodeAccelerator* vaapi_dec,
+    VaapiWrapper* vaapi_wrapper)
+    : vaapi_wrapper_(vaapi_wrapper), vaapi_dec_(vaapi_dec) {
+  DCHECK(vaapi_wrapper_);
+  DCHECK(vaapi_dec_);
+}
+
+VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::~VaapiVP9Accelerator() {}
+
+scoped_refptr<VP9Picture>
+VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::CreateVP9Picture() {
+  scoped_refptr<VaapiDecodeSurface> va_surface = vaapi_dec_->CreateSurface();
+  if (!va_surface)
+    return nullptr;
+
+  return new VaapiVP9Picture(va_surface);
+}
+
+bool VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::SubmitDecode(
+    const scoped_refptr<VP9Picture>& pic,
+    const media::Vp9Segmentation& seg,
+    const media::Vp9LoopFilter& lf,
+    const std::vector<scoped_refptr<VP9Picture>>& ref_pictures) {
+  VADecPictureParameterBufferVP9 pic_param;
+  memset(&pic_param, 0, sizeof(pic_param));
+
+  const media::Vp9FrameHeader* frame_hdr = pic->frame_hdr.get();
+  DCHECK(frame_hdr);
+
+  if (frame_hdr->profile != 0) {
+    DVLOG(1) << "Unsupported profile";

[kcwu, 2015/09/09 09:02:53]

<< frame_hdr->profile

[Pawel Osciak, 2015/09/09 10:19:27]

Done.

+    return false;
+  }
+
+  pic_param.frame_width = base::checked_cast<uint16_t>(frame_hdr->width);
+  pic_param.frame_height = base::checked_cast<uint16_t>(frame_hdr->height);
+
+  CHECK_EQ(ref_pictures.size(), arraysize(pic_param.reference_frames));
+  for (size_t i = 0; i < arraysize(pic_param.reference_frames); ++i) {
+    VASurfaceID va_surface_id;
+    if (ref_pictures[i]) {
+      scoped_refptr<VaapiDecodeSurface> surface =
+          VP9PictureToVaapiDecodeSurface(ref_pictures[i]);
+      va_surface_id = surface->va_surface()->id();
+    } else {
+      va_surface_id = VA_INVALID_SURFACE;
+    }
+
+    pic_param.reference_frames[i] = va_surface_id;
+  }
+
+#define FHDR_TO_PP_PF1(a) pic_param.pic_fields.bits.a = frame_hdr->a
+#define FHDR_TO_PP_PF2(a, b) pic_param.pic_fields.bits.a = b
+  FHDR_TO_PP_PF2(subsampling_x, frame_hdr->subsampling_x == 1);
+  FHDR_TO_PP_PF2(subsampling_y, frame_hdr->subsampling_y == 1);
+  FHDR_TO_PP_PF2(frame_type, frame_hdr->IsKeyframe() ? 0 : 1);
+  FHDR_TO_PP_PF1(show_frame);
+  FHDR_TO_PP_PF1(error_resilient_mode);
+  FHDR_TO_PP_PF1(intra_only);
+  FHDR_TO_PP_PF1(allow_high_precision_mv);
+  FHDR_TO_PP_PF2(mcomp_filter_type, frame_hdr->interp_filter);
+  FHDR_TO_PP_PF1(frame_parallel_decoding_mode);
+  FHDR_TO_PP_PF2(reset_frame_context, frame_hdr->reset_context);
+  FHDR_TO_PP_PF1(refresh_frame_context);
+  FHDR_TO_PP_PF1(frame_context_idx);
+  FHDR_TO_PP_PF2(segmentation_enabled, seg.enabled);
+  FHDR_TO_PP_PF2(segmentation_temporal_update, seg.temporal_update);
+  FHDR_TO_PP_PF2(segmentation_update_map, seg.update_map);
+  FHDR_TO_PP_PF2(last_ref_frame, frame_hdr->frame_refs[0]);
+  FHDR_TO_PP_PF2(last_ref_frame_sign_bias, frame_hdr->ref_sign_biases[0]);
+  FHDR_TO_PP_PF2(golden_ref_frame, frame_hdr->frame_refs[1]);
+  FHDR_TO_PP_PF2(golden_ref_frame_sign_bias, frame_hdr->ref_sign_biases[1]);
+  FHDR_TO_PP_PF2(alt_ref_frame, frame_hdr->frame_refs[2]);
+  FHDR_TO_PP_PF2(alt_ref_frame_sign_bias, frame_hdr->ref_sign_biases[2]);
+  FHDR_TO_PP_PF2(lossless_flag, frame_hdr->quant_params.IsLossless());
+#undef FHDR_TO_PP_PF2
+#undef FHDR_TO_PP_PF1
+
+  pic_param.filter_level = lf.filter_level;
+  pic_param.sharpness_level = lf.sharpness_level;
+  pic_param.log2_tile_rows = frame_hdr->log2_tile_rows;
+  pic_param.log2_tile_columns = frame_hdr->log2_tile_cols;
+  pic_param.frame_header_length_in_bytes = frame_hdr->uncompressed_header_size;
+  pic_param.first_partition_size = frame_hdr->first_partition_size;
+
+  ARRAY_MEMCPY_CHECKED(pic_param.mb_segment_tree_probs, seg.tree_probs);
+  ARRAY_MEMCPY_CHECKED(pic_param.segment_pred_probs, seg.pred_probs);
+
+  pic_param.profile = frame_hdr->profile;
+
+  if (!vaapi_wrapper_->SubmitBuffer(VAPictureParameterBufferType,
+                                    sizeof(pic_param), &pic_param))
+    return false;
+
+  VASliceParameterBufferVP9 slice_param;
+  memset(&slice_param, 0, sizeof(slice_param));
+  slice_param.slice_data_size = frame_hdr->frame_size;
+  slice_param.slice_data_offset = 0;
+  slice_param.slice_data_flag = VA_SLICE_DATA_FLAG_ALL;
+
+  static_assert(arraysize(media::Vp9Segmentation::feature_enabled) ==
+                    arraysize(slice_param.seg_param),
+                "seg_param array of incorrect size");
+  for (size_t i = 0; i < arraysize(slice_param.seg_param); ++i) {
+    VASegmentParameterVP9& seg_param = slice_param.seg_param[i];
+#define SEG_TO_SP_SF(a, b) seg_param.segment_flags.fields.a = b
+    SEG_TO_SP_SF(
+        segment_reference_enabled,
+        seg.FeatureEnabled(i, media::Vp9Segmentation::SEG_LVL_REF_FRAME));
+    SEG_TO_SP_SF(segment_reference,
+                 seg.FeatureData(i, media::Vp9Segmentation::SEG_LVL_REF_FRAME));
+    SEG_TO_SP_SF(segment_reference_skipped,
+                 seg.FeatureEnabled(i, media::Vp9Segmentation::SEG_LVL_SKIP));
+#undef SEG_TO_SP_SF
+
+    ARRAY_MEMCPY_CHECKED(seg_param.filter_level, lf.lvl[i]);
+
+    seg_param.luma_dc_quant_scale = seg.y_dequant[i][0];
+    seg_param.luma_ac_quant_scale = seg.y_dequant[i][1];
+    seg_param.chroma_dc_quant_scale = seg.uv_dequant[i][0];
+    seg_param.chroma_ac_quant_scale = seg.uv_dequant[i][1];
+  }
+
+  if (!vaapi_wrapper_->SubmitBuffer(VASliceParameterBufferType,
+                                    sizeof(slice_param), &slice_param))
+    return false;
+
+  void* non_const_ptr = const_cast<uint8*>(frame_hdr->data);
+  if (!vaapi_wrapper_->SubmitBuffer(VASliceDataBufferType,
+                                    frame_hdr->frame_size, non_const_ptr))
+    return false;
+
+  scoped_refptr<VaapiDecodeSurface> dec_surface =
+      VP9PictureToVaapiDecodeSurface(pic);
+
+  return vaapi_dec_->DecodeSurface(dec_surface);
+}
+
+bool VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::OutputPicture(
+    const scoped_refptr<VP9Picture>& pic) {
+  scoped_refptr<VaapiDecodeSurface> dec_surface =
+      VP9PictureToVaapiDecodeSurface(pic);
+
+  vaapi_dec_->SurfaceReady(dec_surface);
+  return true;
+}
+
+scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface>
+VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::
+    VP9PictureToVaapiDecodeSurface(const scoped_refptr<VP9Picture>& pic) {
+  VaapiVP9Picture* vaapi_pic = pic->AsVaapiVP9Picture();
+  CHECK(vaapi_pic);
+  return vaapi_pic->dec_surface();
+}
+
 // static
 media::VideoDecodeAccelerator::SupportedProfiles
 VaapiVideoDecodeAccelerator::GetSupportedProfiles() {
   return VaapiWrapper::GetSupportedDecodeProfiles();
 }
 
 }  // namespace content