/* * gstvaapidecoder_vp8.c - VP8 decoder * * Copyright (C) 2013-2014 Intel Corporation * Author: Halley Zhao <halley.zhao@intel.com> * Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com> * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 2.1 * of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301 USA */ /** * SECTION:gstvaapidecoder_vp8 * @short_description: VP8 decoder */ #include "sysdeps.h" #include <gst/codecparsers/gstvp8parser.h> #include "gstvaapidecoder_vp8.h" #include "gstvaapidecoder_objects.h" #include "gstvaapidecoder_priv.h" #include "gstvaapidisplay_priv.h" #include "gstvaapicompat.h" #define DEBUG 1 #include "gstvaapidebug.h" #define GST_VAAPI_DECODER_VP8_CAST(decoder) \ ((GstVaapiDecoderVp8 *)(decoder)) typedef struct _GstVaapiDecoderVp8Private GstVaapiDecoderVp8Private; typedef struct _GstVaapiDecoderVp8Class GstVaapiDecoderVp8Class; struct _GstVaapiDecoderVp8Private { GstVaapiProfile profile; guint width; guint height; GstVp8Parser parser; GstVp8FrameHdr frame_hdr; GstVaapiPicture *last_picture; GstVaapiPicture *golden_ref_picture; GstVaapiPicture *alt_ref_picture; GstVaapiPicture *current_picture; guint size_changed:1; }; /** * GstVaapiDecoderVp8: * * A decoder based on Vp8. */ struct _GstVaapiDecoderVp8 { /*< private > */ GstVaapiDecoder parent_instance; GstVaapiDecoderVp8Private priv; }; /** * GstVaapiDecoderVp8Class: * * A decoder class based on Vp8. */ struct _GstVaapiDecoderVp8Class { /*< private > */ GstVaapiDecoderClass parent_class; }; G_DEFINE_TYPE (GstVaapiDecoderVp8, gst_vaapi_decoder_vp8, GST_TYPE_VAAPI_DECODER); static GstVaapiDecoderStatus get_status (GstVp8ParserResult result) { GstVaapiDecoderStatus status; switch (result) { case GST_VP8_PARSER_OK: status = GST_VAAPI_DECODER_STATUS_SUCCESS; break; case GST_VP8_PARSER_ERROR: status = GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER; break; default: status = GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; break; } return status; } static void gst_vaapi_decoder_vp8_close (GstVaapiDecoderVp8 * decoder) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; gst_vaapi_picture_replace (&priv->last_picture, NULL); gst_vaapi_picture_replace (&priv->golden_ref_picture, NULL); gst_vaapi_picture_replace (&priv->alt_ref_picture, NULL); gst_vaapi_picture_replace (&priv->current_picture, NULL); } static gboolean gst_vaapi_decoder_vp8_open (GstVaapiDecoderVp8 * decoder) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; gst_vaapi_decoder_vp8_close (decoder); gst_vp8_parser_init (&priv->parser); return TRUE; } static void gst_vaapi_decoder_vp8_destroy (GstVaapiDecoder * base_decoder) { GstVaapiDecoderVp8 *const decoder = GST_VAAPI_DECODER_VP8_CAST (base_decoder); gst_vaapi_decoder_vp8_close (decoder); } static gboolean gst_vaapi_decoder_vp8_create (GstVaapiDecoder * base_decoder) { GstVaapiDecoderVp8 *const decoder = GST_VAAPI_DECODER_VP8_CAST (base_decoder); GstVaapiDecoderVp8Private *const priv = &decoder->priv; if (!gst_vaapi_decoder_vp8_open (decoder)) return FALSE; priv->profile = GST_VAAPI_PROFILE_UNKNOWN; return TRUE; } static GstVaapiDecoderStatus gst_vaapi_decoder_vp8_reset (GstVaapiDecoder * base_decoder) { gst_vaapi_decoder_vp8_destroy (base_decoder); if (gst_vaapi_decoder_vp8_create (base_decoder)) return GST_VAAPI_DECODER_STATUS_SUCCESS; return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; } static GstVaapiDecoderStatus ensure_context (GstVaapiDecoderVp8 * decoder) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; const GstVaapiProfile profile = GST_VAAPI_PROFILE_VP8; const GstVaapiEntrypoint entrypoint = GST_VAAPI_ENTRYPOINT_VLD; gboolean reset_context = FALSE; if (priv->profile != profile) { if (!gst_vaapi_display_has_decoder (GST_VAAPI_DECODER_DISPLAY (decoder), profile, entrypoint)) return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE; priv->profile = profile; reset_context = TRUE; } if (priv->size_changed) { GST_DEBUG ("size changed"); priv->size_changed = FALSE; reset_context = TRUE; } if (reset_context) { GstVaapiContextInfo info; /* *INDENT-OFF* */ info = (GstVaapiContextInfo) { .profile = priv->profile, .entrypoint = entrypoint, .chroma_type = GST_VAAPI_CHROMA_TYPE_YUV420, .width = priv->width, .height = priv->height, .ref_frames = 3, }; /* *INDENT-ON* */ reset_context = gst_vaapi_decoder_ensure_context (GST_VAAPI_DECODER (decoder), &info); if (!reset_context) return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; } return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus ensure_quant_matrix (GstVaapiDecoderVp8 * decoder, GstVaapiPicture * picture) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; GstVp8FrameHdr *const frame_hdr = &priv->frame_hdr; GstVp8Segmentation *const seg = &priv->parser.segmentation; VAIQMatrixBufferVP8 *iq_matrix; const gint8 QI_MAX = 127; gint8 qi, qi_base; gint i; picture->iq_matrix = GST_VAAPI_IQ_MATRIX_NEW (VP8, decoder); if (!picture->iq_matrix) { GST_ERROR ("failed to allocate IQ matrix"); return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED; } iq_matrix = picture->iq_matrix->param; /* Fill in VAIQMatrixBufferVP8 */ for (i = 0; i < 4; i++) { if (seg->segmentation_enabled) { qi_base = seg->quantizer_update_value[i]; if (!seg->segment_feature_mode) // 0 means delta update qi_base += frame_hdr->quant_indices.y_ac_qi; } else qi_base = frame_hdr->quant_indices.y_ac_qi; qi = qi_base; iq_matrix->quantization_index[i][0] = CLAMP (qi, 0, QI_MAX); qi = qi_base + frame_hdr->quant_indices.y_dc_delta; iq_matrix->quantization_index[i][1] = CLAMP (qi, 0, QI_MAX); qi = qi_base + frame_hdr->quant_indices.y2_dc_delta; iq_matrix->quantization_index[i][2] = CLAMP (qi, 0, QI_MAX); qi = qi_base + frame_hdr->quant_indices.y2_ac_delta; iq_matrix->quantization_index[i][3] = CLAMP (qi, 0, QI_MAX); qi = qi_base + frame_hdr->quant_indices.uv_dc_delta; iq_matrix->quantization_index[i][4] = CLAMP (qi, 0, QI_MAX); qi = qi_base + frame_hdr->quant_indices.uv_ac_delta; iq_matrix->quantization_index[i][5] = CLAMP (qi, 0, QI_MAX); } return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus ensure_probability_table (GstVaapiDecoderVp8 * decoder, GstVaapiPicture * picture) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; GstVp8FrameHdr *const frame_hdr = &priv->frame_hdr; VAProbabilityDataBufferVP8 *prob_table; picture->prob_table = GST_VAAPI_PROBABILITY_TABLE_NEW (VP8, decoder); if (!picture->prob_table) { GST_ERROR ("failed to allocate probality table"); return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED; } prob_table = picture->prob_table->param; /* Fill in VAProbabilityDataBufferVP8 */ memcpy (prob_table->dct_coeff_probs, frame_hdr->token_probs.prob, sizeof (frame_hdr->token_probs.prob)); return GST_VAAPI_DECODER_STATUS_SUCCESS; } static void init_picture (GstVaapiDecoderVp8 * decoder, GstVaapiPicture * picture) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; GstVp8FrameHdr *const frame_hdr = &priv->frame_hdr; picture->structure = GST_VAAPI_PICTURE_STRUCTURE_FRAME; picture->type = frame_hdr->key_frame ? GST_VAAPI_PICTURE_TYPE_I : GST_VAAPI_PICTURE_TYPE_P; picture->pts = GST_VAAPI_DECODER_CODEC_FRAME (decoder)->pts; if (!frame_hdr->show_frame) GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_SKIPPED); } static gboolean fill_picture (GstVaapiDecoderVp8 * decoder, GstVaapiPicture * picture) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; VAPictureParameterBufferVP8 *const pic_param = picture->param; GstVp8Parser *const parser = &priv->parser; GstVp8FrameHdr *const frame_hdr = &priv->frame_hdr; GstVp8Segmentation *const seg = &parser->segmentation; gint i; /* Fill in VAPictureParameterBufferVP8 */ pic_param->frame_width = priv->width; pic_param->frame_height = priv->height; pic_param->last_ref_frame = VA_INVALID_SURFACE; pic_param->golden_ref_frame = VA_INVALID_SURFACE; pic_param->alt_ref_frame = VA_INVALID_SURFACE; if (!frame_hdr->key_frame) { if (priv->last_picture) pic_param->last_ref_frame = priv->last_picture->surface_id; if (priv->golden_ref_picture) pic_param->golden_ref_frame = priv->golden_ref_picture->surface_id; if (priv->alt_ref_picture) pic_param->alt_ref_frame = priv->alt_ref_picture->surface_id; } pic_param->out_of_loop_frame = VA_INVALID_SURFACE; // not used currently pic_param->pic_fields.value = 0; pic_param->pic_fields.bits.key_frame = !frame_hdr->key_frame; pic_param->pic_fields.bits.version = frame_hdr->version; pic_param->pic_fields.bits.segmentation_enabled = seg->segmentation_enabled; pic_param->pic_fields.bits.update_mb_segmentation_map = seg->update_mb_segmentation_map; pic_param->pic_fields.bits.update_segment_feature_data = seg->update_segment_feature_data; pic_param->pic_fields.bits.filter_type = frame_hdr->filter_type; pic_param->pic_fields.bits.sharpness_level = frame_hdr->sharpness_level; pic_param->pic_fields.bits.loop_filter_adj_enable = parser->mb_lf_adjust.loop_filter_adj_enable; pic_param->pic_fields.bits.mode_ref_lf_delta_update = parser->mb_lf_adjust.mode_ref_lf_delta_update; pic_param->pic_fields.bits.sign_bias_golden = frame_hdr->sign_bias_golden; pic_param->pic_fields.bits.sign_bias_alternate = frame_hdr->sign_bias_alternate; pic_param->pic_fields.bits.mb_no_coeff_skip = frame_hdr->mb_no_skip_coeff; for (i = 0; i < 3; i++) pic_param->mb_segment_tree_probs[i] = seg->segment_prob[i]; for (i = 0; i < 4; i++) { gint8 level; if (seg->segmentation_enabled) { level = seg->lf_update_value[i]; if (!seg->segment_feature_mode) // 0 means delta update level += frame_hdr->loop_filter_level; } else level = frame_hdr->loop_filter_level; pic_param->loop_filter_level[i] = CLAMP (level, 0, 63); pic_param->loop_filter_deltas_ref_frame[i] = parser->mb_lf_adjust.ref_frame_delta[i]; pic_param->loop_filter_deltas_mode[i] = parser->mb_lf_adjust.mb_mode_delta[i]; } /* In decoding, the only loop filter settings that matter are those in the frame header (9.1) */ pic_param->pic_fields.bits.loop_filter_disable = frame_hdr->loop_filter_level == 0; pic_param->prob_skip_false = frame_hdr->prob_skip_false; pic_param->prob_intra = frame_hdr->prob_intra; pic_param->prob_last = frame_hdr->prob_last; pic_param->prob_gf = frame_hdr->prob_gf; memcpy (pic_param->y_mode_probs, frame_hdr->mode_probs.y_prob, sizeof (frame_hdr->mode_probs.y_prob)); memcpy (pic_param->uv_mode_probs, frame_hdr->mode_probs.uv_prob, sizeof (frame_hdr->mode_probs.uv_prob)); memcpy (pic_param->mv_probs, frame_hdr->mv_probs.prob, sizeof (frame_hdr->mv_probs)); pic_param->bool_coder_ctx.range = frame_hdr->rd_range; pic_param->bool_coder_ctx.value = frame_hdr->rd_value; pic_param->bool_coder_ctx.count = frame_hdr->rd_count; return TRUE; } static gboolean fill_slice (GstVaapiDecoderVp8 * decoder, GstVaapiSlice * slice) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; VASliceParameterBufferVP8 *const slice_param = slice->param; GstVp8FrameHdr *const frame_hdr = &priv->frame_hdr; gint i; /* Fill in VASliceParameterBufferVP8 */ slice_param->slice_data_offset = frame_hdr->data_chunk_size; slice_param->macroblock_offset = frame_hdr->header_size; slice_param->num_of_partitions = (1 << frame_hdr->log2_nbr_of_dct_partitions) + 1; slice_param->partition_size[0] = frame_hdr->first_part_size - ((slice_param->macroblock_offset + 7) >> 3); for (i = 1; i < slice_param->num_of_partitions; i++) slice_param->partition_size[i] = frame_hdr->partition_size[i - 1]; for (; i < G_N_ELEMENTS (slice_param->partition_size); i++) slice_param->partition_size[i] = 0; return TRUE; } static GstVaapiDecoderStatus decode_slice (GstVaapiDecoderVp8 * decoder, GstVaapiPicture * picture, const guchar * buf, guint buf_size) { GstVaapiSlice *slice; slice = GST_VAAPI_SLICE_NEW (VP8, decoder, buf, buf_size); if (!slice) { GST_ERROR ("failed to allocate slice"); return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED; } if (!fill_slice (decoder, slice)) { gst_vaapi_mini_object_unref (GST_VAAPI_MINI_OBJECT (slice)); return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; } gst_vaapi_picture_add_slice (GST_VAAPI_PICTURE_CAST (picture), slice); return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus decode_picture (GstVaapiDecoderVp8 * decoder, const guchar * buf, guint buf_size) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; GstVaapiPicture *picture; GstVaapiDecoderStatus status; status = ensure_context (decoder); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) return status; /* Create new picture */ picture = GST_VAAPI_PICTURE_NEW (VP8, decoder); if (!picture) { GST_ERROR ("failed to allocate picture"); return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED; } gst_vaapi_picture_replace (&priv->current_picture, picture); gst_vaapi_picture_unref (picture); status = ensure_quant_matrix (decoder, picture); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) return status; status = ensure_probability_table (decoder, picture); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) return status; init_picture (decoder, picture); if (!fill_picture (decoder, picture)) return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; return decode_slice (decoder, picture, buf, buf_size); } static void update_ref_frames (GstVaapiDecoderVp8 * decoder) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; GstVaapiPicture *picture = priv->current_picture; GstVp8FrameHdr *const frame_hdr = &priv->frame_hdr; // update picture reference if (frame_hdr->key_frame) { gst_vaapi_picture_replace (&priv->golden_ref_picture, picture); gst_vaapi_picture_replace (&priv->alt_ref_picture, picture); } else { // process refresh_alternate_frame/copy_buffer_to_alternate first if (frame_hdr->refresh_alternate_frame) { gst_vaapi_picture_replace (&priv->alt_ref_picture, picture); } else { switch (frame_hdr->copy_buffer_to_alternate) { case 0: // do nothing break; case 1: gst_vaapi_picture_replace (&priv->alt_ref_picture, priv->last_picture); break; case 2: gst_vaapi_picture_replace (&priv->alt_ref_picture, priv->golden_ref_picture); break; default: GST_WARNING ("WARNING: VP8 decoder: unrecognized copy_buffer_to_alternate"); } } if (frame_hdr->refresh_golden_frame) { gst_vaapi_picture_replace (&priv->golden_ref_picture, picture); } else { switch (frame_hdr->copy_buffer_to_golden) { case 0: // do nothing break; case 1: gst_vaapi_picture_replace (&priv->golden_ref_picture, priv->last_picture); break; case 2: gst_vaapi_picture_replace (&priv->golden_ref_picture, priv->alt_ref_picture); break; default: GST_WARNING ("WARNING: VP8 decoder: unrecognized copy_buffer_to_golden"); } } } if (frame_hdr->key_frame || frame_hdr->refresh_last) gst_vaapi_picture_replace (&priv->last_picture, picture); } static GstVaapiDecoderStatus decode_current_picture (GstVaapiDecoderVp8 * decoder) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; GstVaapiPicture *const picture = priv->current_picture; if (!picture) return GST_VAAPI_DECODER_STATUS_SUCCESS; update_ref_frames (decoder); if (!gst_vaapi_picture_decode (picture)) goto error; if (!gst_vaapi_picture_output (picture)) goto error; gst_vaapi_picture_replace (&priv->current_picture, NULL); return GST_VAAPI_DECODER_STATUS_SUCCESS; /* ERRORS */ error: { /* XXX: fix for cases where first field failed to be decoded */ gst_vaapi_picture_replace (&priv->current_picture, NULL); return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; } } static GstVaapiDecoderStatus parse_frame_header (GstVaapiDecoderVp8 * decoder, const guchar * buf, guint buf_size, GstVp8FrameHdr * frame_hdr) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; GstVp8ParserResult result; memset (frame_hdr, 0, sizeof (*frame_hdr)); result = gst_vp8_parser_parse_frame_header (&priv->parser, frame_hdr, buf, buf_size); if (result != GST_VP8_PARSER_OK) return get_status (result); if (frame_hdr->key_frame && (frame_hdr->width != priv->width || frame_hdr->height != priv->height)) { priv->width = frame_hdr->width; priv->height = frame_hdr->height; priv->size_changed = TRUE; } return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus gst_vaapi_decoder_vp8_parse (GstVaapiDecoder * base_decoder, GstAdapter * adapter, gboolean at_eos, GstVaapiDecoderUnit * unit) { guint flags = 0; unit->size = gst_adapter_available (adapter); /* The whole frame is available */ flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START; flags |= GST_VAAPI_DECODER_UNIT_FLAG_SLICE; flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_END; GST_VAAPI_DECODER_UNIT_FLAG_SET (unit, flags); return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus decode_buffer (GstVaapiDecoderVp8 * decoder, const guchar * buf, guint buf_size) { GstVaapiDecoderVp8Private *const priv = &decoder->priv; GstVaapiDecoderStatus status; status = parse_frame_header (decoder, buf, buf_size, &priv->frame_hdr); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) return status; return decode_picture (decoder, buf, buf_size); } static GstVaapiDecoderStatus gst_vaapi_decoder_vp8_decode (GstVaapiDecoder * base_decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderVp8 *const decoder = GST_VAAPI_DECODER_VP8_CAST (base_decoder); GstVaapiDecoderStatus status; GstBuffer *const buffer = GST_VAAPI_DECODER_CODEC_FRAME (decoder)->input_buffer; GstMapInfo map_info; if (!gst_buffer_map (buffer, &map_info, GST_MAP_READ)) { GST_ERROR ("failed to map buffer"); return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; } status = decode_buffer (decoder, map_info.data + unit->offset, unit->size); gst_buffer_unmap (buffer, &map_info); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) return status; return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus gst_vaapi_decoder_vp8_start_frame (GstVaapiDecoder * base_decoder, GstVaapiDecoderUnit * base_unit) { return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus gst_vaapi_decoder_vp8_end_frame (GstVaapiDecoder * base_decoder) { GstVaapiDecoderVp8 *const decoder = GST_VAAPI_DECODER_VP8_CAST (base_decoder); return decode_current_picture (decoder); } static GstVaapiDecoderStatus gst_vaapi_decoder_vp8_flush (GstVaapiDecoder * base_decoder) { return GST_VAAPI_DECODER_STATUS_SUCCESS; } static void gst_vaapi_decoder_vp8_finalize (GObject * object) { GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER (object); gst_vaapi_decoder_vp8_destroy (base_decoder); G_OBJECT_CLASS (gst_vaapi_decoder_vp8_parent_class)->finalize (object); } static void gst_vaapi_decoder_vp8_class_init (GstVaapiDecoderVp8Class * klass) { GObjectClass *const object_class = G_OBJECT_CLASS (klass); GstVaapiDecoderClass *const decoder_class = GST_VAAPI_DECODER_CLASS (klass); object_class->finalize = gst_vaapi_decoder_vp8_finalize; decoder_class->reset = gst_vaapi_decoder_vp8_reset; decoder_class->parse = gst_vaapi_decoder_vp8_parse; decoder_class->decode = gst_vaapi_decoder_vp8_decode; decoder_class->start_frame = gst_vaapi_decoder_vp8_start_frame; decoder_class->end_frame = gst_vaapi_decoder_vp8_end_frame; decoder_class->flush = gst_vaapi_decoder_vp8_flush; } static void gst_vaapi_decoder_vp8_init (GstVaapiDecoderVp8 * decoder) { GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER (decoder); gst_vaapi_decoder_vp8_create (base_decoder); } /** * gst_vaapi_decoder_vp8_new: * @display: a #GstVaapiDisplay * @caps: a #GstCaps holding codec information * * Creates a new #GstVaapiDecoder for VP8 decoding. The @caps can * hold extra information like codec-data and pictured coded size. * * Return value: the newly allocated #GstVaapiDecoder object */ GstVaapiDecoder * gst_vaapi_decoder_vp8_new (GstVaapiDisplay * display, GstCaps * caps) { return g_object_new (GST_TYPE_VAAPI_DECODER_VP8, "display", display, "caps", caps, NULL); }