mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-19 16:21:17 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/sys/va/gstvaav1dec.c

1017 lines
34 KiB
C
Raw Blame History

/* GStreamer
* Copyright (C) 2020 Intel Corporation
* Author: He Junyan <junyan.he@intel.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the0
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/**
* SECTION:element-vaav1dec
* @title: vaav1dec
* @short_description: A VA-API based AV1 video decoder
*
* vaav1dec decodes AV1 bitstreams to VA surfaces using the
* installed and chosen [VA-API](https://01.org/linuxmedia/vaapi)
* driver.
*
* The decoding surfaces can be mapped onto main memory as video
* frames.
*
* ## Example launch line
* ```
* gst-launch-1.0 filesrc location=sample.av1 ! ivfparse ! av1parse ! vaav1dec ! autovideosink
* ```
*
* Since: 1.20
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gst/va/gstva.h>
#include "gstvaav1dec.h"
#include "gstvabasedec.h"
GST_DEBUG_CATEGORY_STATIC (gst_va_av1dec_debug);
#ifndef GST_DISABLE_GST_DEBUG
#define GST_CAT_DEFAULT gst_va_av1dec_debug
#else
#define GST_CAT_DEFAULT NULL
#endif
#define GST_VA_AV1_DEC(obj) ((GstVaAV1Dec *) obj)
#define GST_VA_AV1_DEC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_TYPE_FROM_INSTANCE (obj), GstVaAV1DecClass))
#define GST_VA_AV1_DEC_CLASS(klass) ((GstVaAV1DecClass *) klass)
typedef struct _GstVaAV1Dec GstVaAV1Dec;
typedef struct _GstVaAV1DecClass GstVaAV1DecClass;
struct _GstVaAV1DecClass
{
GstVaBaseDecClass parent_class;
};
struct _GstVaAV1Dec
{
GstVaBaseDec parent;
GstFlowReturn last_ret;
GstAV1SequenceHeaderOBU seq;
gint max_width;
gint max_height;
};
static GstElementClass *parent_class = NULL;
/* *INDENT-OFF* */
static const gchar *src_caps_str =
GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_MEMORY_VA,
"{ NV12, P010_10LE }") " ;"
GST_VIDEO_CAPS_MAKE ("{ NV12, P010_10LE }");
/* *INDENT-ON* */
static const gchar *sink_caps_str = "video/x-av1";
static gboolean
gst_va_av1_dec_negotiate (GstVideoDecoder * decoder)
{
GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
GstAV1Decoder *av1dec = GST_AV1_DECODER (decoder);
GstVideoFormat format = GST_VIDEO_FORMAT_UNKNOWN;
GstCapsFeatures *capsfeatures = NULL;
/* Ignore downstream renegotiation request. */
if (!base->need_negotiation)
return TRUE;
base->need_negotiation = FALSE;
/* Do not re-create the context if only the frame size changes */
if (!gst_va_decoder_config_is_equal (base->decoder, base->profile,
base->rt_format, self->max_width, self->max_height)) {
if (gst_va_decoder_is_open (base->decoder)
&& !gst_va_decoder_close (base->decoder))
return FALSE;
if (!gst_va_decoder_open (base->decoder, base->profile, base->rt_format))
return FALSE;
if (!gst_va_decoder_set_frame_size (base->decoder, self->max_width,
self->max_height))
return FALSE;
}
if (base->output_state)
gst_video_codec_state_unref (base->output_state);
gst_va_base_dec_get_preferred_format_and_caps_features (base, &format,
&capsfeatures);
base->output_state = gst_video_decoder_set_output_state (decoder, format,
base->width, base->height, av1dec->input_state);
base->output_state->caps = gst_video_info_to_caps (&base->output_state->info);
if (capsfeatures)
gst_caps_set_features_simple (base->output_state->caps, capsfeatures);
GST_INFO_OBJECT (self, "Negotiated caps %" GST_PTR_FORMAT,
base->output_state->caps);
return GST_VIDEO_DECODER_CLASS (parent_class)->negotiate (decoder);
}
static GstCaps *
_complete_sink_caps (GstCaps * sinkcaps)
{
GstCaps *caps = gst_caps_copy (sinkcaps);
GValue val = G_VALUE_INIT;
g_value_init (&val, G_TYPE_STRING);
g_value_set_string (&val, "frame");
gst_caps_set_value (caps, "alignment", &val);
g_value_unset (&val);
return caps;
}
static VAProfile
_get_profile (GstVaAV1Dec * self, const GstAV1SequenceHeaderOBU * seq_hdr)
{
GstVaBaseDec *base = GST_VA_BASE_DEC (self);
VAProfile profile = VAProfileNone;
switch (seq_hdr->seq_profile) {
case GST_AV1_PROFILE_0:
profile = VAProfileAV1Profile0;
break;
case GST_AV1_PROFILE_1:
profile = VAProfileAV1Profile1;
break;
default:
GST_ERROR_OBJECT (self, "Unsupported av1 profile value %d",
seq_hdr->seq_profile);
return VAProfileNone;
}
if (!gst_va_decoder_has_profile (base->decoder, profile)) {
GST_ERROR_OBJECT (self, "Profile %s is not supported by HW",
gst_va_profile_name (profile));
return VAProfileNone;
}
return profile;
}
static guint
_get_rtformat (GstVaAV1Dec * self, VAProfile profile,
const GstAV1SequenceHeaderOBU * seq_header)
{
/* 6.4.1:
seq_profile Bit depth Monochrome support Chroma subsampling
0 8 or 10 Yes YUV 4:2:0
1 8 or 10 No YUV 4:4:4
2 8 or 10 Yes YUV 4:2:2
2 12 Yes YUV 4:2:0,YUV 4:2:2,YUV 4:4:4
*/
/* TODO: consider Monochrome case. Just return 4:2:0 for Monochrome now. */
switch (profile) {
case VAProfileAV1Profile0:
if (seq_header->bit_depth == 8) {
return VA_RT_FORMAT_YUV420;
} else if (seq_header->bit_depth == 10) {
return VA_RT_FORMAT_YUV420_10;
}
break;
case VAProfileAV1Profile1:
if (seq_header->bit_depth == 8) {
return VA_RT_FORMAT_YUV444;
} else if (seq_header->bit_depth == 10) {
return VA_RT_FORMAT_YUV444_10;
}
break;
default:
break;
}
GST_ERROR_OBJECT (self, "Fail to find rtformat for profile:%s, bit_depth:%d",
gst_va_profile_name (profile), seq_header->bit_depth);
return 0;
}
static GstCaps *
gst_va_av1_dec_getcaps (GstVideoDecoder * decoder, GstCaps * filter)
{
GstCaps *sinkcaps, *caps = NULL, *tmp;
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
if (base->decoder)
caps = gst_va_decoder_get_sinkpad_caps (base->decoder);
if (caps) {
sinkcaps = _complete_sink_caps (caps);
gst_caps_unref (caps);
if (filter) {
tmp = gst_caps_intersect_full (filter, sinkcaps,
GST_CAPS_INTERSECT_FIRST);
gst_caps_unref (sinkcaps);
caps = tmp;
} else {
caps = sinkcaps;
}
GST_LOG_OBJECT (base, "Returning caps %" GST_PTR_FORMAT, caps);
} else if (!caps) {
caps = gst_video_decoder_proxy_getcaps (decoder, NULL, filter);
}
return caps;
}
static GstFlowReturn
gst_va_av1_dec_new_sequence (GstAV1Decoder * decoder,
const GstAV1SequenceHeaderOBU * seq_hdr)
{
GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
VAProfile profile;
guint rt_format;
GST_LOG_OBJECT (self, "new sequence");
profile = _get_profile (self, seq_hdr);
if (profile == VAProfileNone)
return GST_FLOW_NOT_NEGOTIATED;
rt_format = _get_rtformat (self, profile, seq_hdr);
if (!rt_format)
return GST_FLOW_NOT_NEGOTIATED;
self->seq = *seq_hdr;
if (!gst_va_decoder_config_is_equal (base->decoder, profile,
rt_format, seq_hdr->max_frame_width_minus_1 + 1,
seq_hdr->max_frame_height_minus_1 + 1)) {
base->profile = profile;
base->rt_format = rt_format;
self->max_width = seq_hdr->max_frame_width_minus_1 + 1;
self->max_height = seq_hdr->max_frame_height_minus_1 + 1;
base->need_negotiation = TRUE;
base->min_buffers = 7 + 4; /* dpb size + scratch surfaces */
/* May be changed by frame header */
base->width = self->max_width;
base->height = self->max_height;
base->need_valign = FALSE;
}
return GST_FLOW_OK;
}
static GstFlowReturn
gst_va_av1_dec_new_picture (GstAV1Decoder * decoder,
GstVideoCodecFrame * frame, GstAV1Picture * picture)
{
GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
GstVaDecodePicture *pic;
GstVideoDecoder *vdec = GST_VIDEO_DECODER (decoder);
GstAV1FrameHeaderOBU *frame_hdr = &picture->frame_hdr;
if (frame_hdr->upscaled_width != base->width
|| frame_hdr->frame_height != base->height) {
base->width = frame_hdr->upscaled_width;
base->height = frame_hdr->frame_height;
if (base->width < self->max_width || base->height < self->max_height) {
base->need_valign = TRUE;
/* *INDENT-OFF* */
base->valign = (GstVideoAlignment){
.padding_bottom = self->max_height - base->height,
.padding_right = self->max_width - base->width,
};
/* *INDENT-ON* */
}
base->need_negotiation = TRUE;
}
if (base->need_negotiation) {
if (!gst_video_decoder_negotiate (GST_VIDEO_DECODER (self))) {
GST_ERROR_OBJECT (self, "Failed to negotiate with downstream");
return GST_FLOW_NOT_NEGOTIATED;
}
}
self->last_ret = gst_video_decoder_allocate_output_frame (vdec, frame);
if (self->last_ret != GST_FLOW_OK) {
GST_WARNING_OBJECT (self,
"Failed to allocated output buffer, return %s",
gst_flow_get_name (self->last_ret));
return self->last_ret;
}
if (picture->apply_grain) {
if (!gst_va_buffer_create_aux_surface (frame->output_buffer)) {
GST_WARNING_OBJECT (self,
"Failed to allocated aux surface for buffer %p",
frame->output_buffer);
return GST_FLOW_ERROR;
}
}
pic = gst_va_decode_picture_new (base->decoder, frame->output_buffer);
gst_av1_picture_set_user_data (picture, pic,
(GDestroyNotify) gst_va_decode_picture_free);
if (picture->apply_grain) {
GST_LOG_OBJECT (self, "New va decode picture %p - %#x(aux: %#x)", pic,
gst_va_decode_picture_get_surface (pic),
gst_va_decode_picture_get_aux_surface (pic));
} else {
GST_LOG_OBJECT (self, "New va decode picture %p - %#x", pic,
gst_va_decode_picture_get_surface (pic));
}
return GST_FLOW_OK;
}
static GstAV1Picture *
gst_va_av1_dec_duplicate_picture (GstAV1Decoder * decoder,
GstVideoCodecFrame * frame, GstAV1Picture * picture)
{
GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
GstVaDecodePicture *pic;
GstVaDecodePicture *new_pic;
GstAV1Picture *new_picture;
pic = gst_av1_picture_get_user_data (picture);
if (!pic) {
GST_ERROR_OBJECT (self, "Parent picture does not have a va picture");
return NULL;
}
new_picture = gst_av1_picture_new ();
g_assert (pic->gstbuffer);
new_pic = gst_va_decode_picture_new (base->decoder, pic->gstbuffer);
GST_LOG_OBJECT (self, "Duplicate output with buffer %" GST_PTR_FORMAT
" (surface %#x)", pic, gst_va_decode_picture_get_surface (pic));
gst_av1_picture_set_user_data (new_picture, new_pic,
(GDestroyNotify) gst_va_decode_picture_free);
return new_picture;
}
static void
_setup_segment_info (VADecPictureParameterBufferAV1 * pic_param,
GstAV1FrameHeaderOBU * frame_header)
{
guint i, j;
uint8_t feature_mask;
for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++)
for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++)
pic_param->seg_info.feature_data[i][j] =
frame_header->segmentation_params.feature_data[i][j];
for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++) {
feature_mask = 0;
for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++) {
if (frame_header->segmentation_params.feature_enabled[i][j])
feature_mask |= 1 << j;
}
pic_param->seg_info.feature_mask[i] = feature_mask;
}
}
static void
_setup_film_grain_info (VADecPictureParameterBufferAV1 * pic_param,
GstAV1FrameHeaderOBU * frame_header)
{
guint i;
if (!frame_header->film_grain_params.apply_grain)
return;
pic_param->film_grain_info.num_y_points =
frame_header->film_grain_params.num_y_points;
for (i = 0; i < frame_header->film_grain_params.num_y_points; i++) {
pic_param->film_grain_info.point_y_value[i] =
frame_header->film_grain_params.point_y_value[i];
pic_param->film_grain_info.point_y_scaling[i] =
frame_header->film_grain_params.point_y_scaling[i];
}
pic_param->film_grain_info.num_cb_points =
frame_header->film_grain_params.num_cb_points;
for (i = 0; i < frame_header->film_grain_params.num_cb_points; i++) {
pic_param->film_grain_info.point_cb_value[i] =
frame_header->film_grain_params.point_cb_value[i];
pic_param->film_grain_info.point_cb_scaling[i] =
frame_header->film_grain_params.point_cb_scaling[i];
}
pic_param->film_grain_info.num_cr_points =
frame_header->film_grain_params.num_cr_points;
for (i = 0; i < frame_header->film_grain_params.num_cr_points; i++) {
pic_param->film_grain_info.point_cr_value[i] =
frame_header->film_grain_params.point_cr_value[i];
pic_param->film_grain_info.point_cr_scaling[i] =
frame_header->film_grain_params.point_cr_scaling[i];
}
if (pic_param->film_grain_info.num_y_points) {
for (i = 0; i < 24; i++) {
pic_param->film_grain_info.ar_coeffs_y[i] =
frame_header->film_grain_params.ar_coeffs_y_plus_128[i] - 128;
}
}
if (frame_header->film_grain_params.chroma_scaling_from_luma
|| pic_param->film_grain_info.num_cb_points) {
for (i = 0; i < GST_AV1_MAX_NUM_POS_LUMA; i++) {
pic_param->film_grain_info.ar_coeffs_cb[i] =
frame_header->film_grain_params.ar_coeffs_cb_plus_128[i] - 128;
}
}
if (frame_header->film_grain_params.chroma_scaling_from_luma
|| pic_param->film_grain_info.num_cr_points) {
for (i = 0; i < GST_AV1_MAX_NUM_POS_LUMA; i++) {
pic_param->film_grain_info.ar_coeffs_cr[i] =
frame_header->film_grain_params.ar_coeffs_cr_plus_128[i] - 128;
}
}
}
static void
_setup_loop_filter_info (VADecPictureParameterBufferAV1 * pic_param,
GstAV1FrameHeaderOBU * frame_header)
{
guint i;
pic_param->filter_level[0] =
frame_header->loop_filter_params.loop_filter_level[0];
pic_param->filter_level[1] =
frame_header->loop_filter_params.loop_filter_level[1];
pic_param->filter_level_u =
frame_header->loop_filter_params.loop_filter_level[2];
pic_param->filter_level_v =
frame_header->loop_filter_params.loop_filter_level[3];
for (i = 0; i < GST_AV1_TOTAL_REFS_PER_FRAME; i++)
pic_param->ref_deltas[i] =
frame_header->loop_filter_params.loop_filter_ref_deltas[i];
for (i = 0; i < 2; i++)
pic_param->mode_deltas[i] =
frame_header->loop_filter_params.loop_filter_mode_deltas[i];
}
static void
_setup_quantization_info (VADecPictureParameterBufferAV1 * pic_param,
GstAV1FrameHeaderOBU * frame_header)
{
pic_param->qmatrix_fields.bits.using_qmatrix =
frame_header->quantization_params.using_qmatrix;
if (frame_header->quantization_params.using_qmatrix) {
pic_param->qmatrix_fields.bits.qm_y =
frame_header->quantization_params.qm_y;
pic_param->qmatrix_fields.bits.qm_u =
frame_header->quantization_params.qm_u;
pic_param->qmatrix_fields.bits.qm_v =
frame_header->quantization_params.qm_v;
} else {
pic_param->qmatrix_fields.bits.qm_y = 0;
pic_param->qmatrix_fields.bits.qm_u = 0;
pic_param->qmatrix_fields.bits.qm_v = 0;
}
}
static void
_setup_cdef_info (VADecPictureParameterBufferAV1 * pic_param,
GstAV1FrameHeaderOBU * frame_header, guint8 num_planes)
{
guint8 sec_strength;
guint i;
pic_param->cdef_damping_minus_3 = frame_header->cdef_params.cdef_damping - 3;
pic_param->cdef_bits = frame_header->cdef_params.cdef_bits;
for (i = 0; i < GST_AV1_CDEF_MAX; i++) {
sec_strength = frame_header->cdef_params.cdef_y_sec_strength[i];
g_assert (sec_strength <= 4);
/* may need to minus 1 in order to merge with primary value. */
if (sec_strength == 4)
sec_strength--;
pic_param->cdef_y_strengths[i] =
((frame_header->cdef_params.cdef_y_pri_strength[i] & 0xf) << 2) |
(sec_strength & 0x03);
}
if (num_planes > 1) {
for (i = 0; i < GST_AV1_CDEF_MAX; i++) {
sec_strength = frame_header->cdef_params.cdef_uv_sec_strength[i];
g_assert (sec_strength <= 4);
/* may need to minus 1 in order to merge with primary value. */
if (sec_strength == 4)
sec_strength--;
pic_param->cdef_uv_strengths[i] =
((frame_header->cdef_params.cdef_uv_pri_strength[i] & 0xf) << 2) |
(sec_strength & 0x03);
}
} else {
for (i = 0; i < GST_AV1_CDEF_MAX; i++) {
pic_param->cdef_uv_strengths[i] = 0;
}
}
}
static void
_setup_global_motion_info (VADecPictureParameterBufferAV1 * pic_param,
GstAV1FrameHeaderOBU * frame_header)
{
guint i, j;
for (i = 0; i < 7; i++) {
/* assuming VAAV1TransformationType and GstAV1WarpModelType are
* equivalent */
pic_param->wm[i].wmtype = (VAAV1TransformationType)
frame_header->global_motion_params.gm_type[GST_AV1_REF_LAST_FRAME + i];
for (j = 0; j < 6; j++)
pic_param->wm[i].wmmat[j] =
frame_header->global_motion_params.gm_params
[GST_AV1_REF_LAST_FRAME + i][j];
pic_param->wm[i].wmmat[6] = 0;
pic_param->wm[i].wmmat[7] = 0;
pic_param->wm[i].invalid =
frame_header->global_motion_params.invalid[GST_AV1_REF_LAST_FRAME + i];
}
}
static GstFlowReturn
gst_va_av1_dec_start_picture (GstAV1Decoder * decoder, GstAV1Picture * picture,
GstAV1Dpb * dpb)
{
GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
GstAV1FrameHeaderOBU *frame_header = &picture->frame_hdr;
GstAV1SequenceHeaderOBU *seq_header = &self->seq;
VADecPictureParameterBufferAV1 pic_param = { };
GstVaDecodePicture *va_pic;
guint i;
va_pic = gst_av1_picture_get_user_data (picture);
g_assert (va_pic);
/* *INDENT-OFF* */
pic_param = (VADecPictureParameterBufferAV1){
.profile = seq_header->seq_profile,
.order_hint_bits_minus_1 = seq_header->order_hint_bits_minus_1,
.matrix_coefficients = seq_header->color_config.matrix_coefficients,
.seq_info_fields.fields = {
.still_picture = seq_header->still_picture,
.use_128x128_superblock = seq_header->use_128x128_superblock,
.enable_filter_intra = seq_header->enable_filter_intra,
.enable_intra_edge_filter = seq_header->enable_intra_edge_filter,
.enable_interintra_compound = seq_header->enable_interintra_compound,
.enable_masked_compound = seq_header->enable_masked_compound,
.enable_dual_filter = seq_header->enable_dual_filter,
.enable_order_hint = seq_header->enable_order_hint,
.enable_jnt_comp = seq_header->enable_jnt_comp,
.enable_cdef = seq_header->enable_cdef,
.mono_chrome = seq_header->color_config.mono_chrome,
.color_range = seq_header->color_config.color_range,
.subsampling_x = seq_header->color_config.subsampling_x,
.subsampling_y = seq_header->color_config.subsampling_y,
.film_grain_params_present = seq_header->film_grain_params_present,
},
.anchor_frames_num = 0,
.anchor_frames_list = NULL,
.frame_width_minus1 = frame_header->upscaled_width - 1,
.frame_height_minus1 = frame_header->frame_height - 1,
.output_frame_width_in_tiles_minus_1 = 0,
.output_frame_height_in_tiles_minus_1 = 0,
.order_hint = frame_header->order_hint,
/* Segmentation */
.seg_info.segment_info_fields.bits = {
.enabled = frame_header->segmentation_params.segmentation_enabled,
.update_map = frame_header->segmentation_params.segmentation_update_map,
.temporal_update =
frame_header->segmentation_params.segmentation_temporal_update,
.update_data =
frame_header->segmentation_params.segmentation_update_data,
},
/* FilmGrain */
.film_grain_info = {
.film_grain_info_fields.bits = {
.apply_grain = frame_header->film_grain_params.apply_grain,
.chroma_scaling_from_luma =
frame_header->film_grain_params.chroma_scaling_from_luma,
.grain_scaling_minus_8 =
frame_header->film_grain_params.grain_scaling_minus_8,
.ar_coeff_lag = frame_header->film_grain_params.ar_coeff_lag,
.ar_coeff_shift_minus_6 =
frame_header->film_grain_params.ar_coeff_shift_minus_6,
.grain_scale_shift = frame_header->film_grain_params.grain_scale_shift,
.overlap_flag = frame_header->film_grain_params.overlap_flag,
.clip_to_restricted_range =
frame_header->film_grain_params.clip_to_restricted_range,
},
.grain_seed = frame_header->film_grain_params.grain_seed,
.cb_mult = frame_header->film_grain_params.cb_mult,
.cb_luma_mult = frame_header->film_grain_params.cb_luma_mult,
.cb_offset = frame_header->film_grain_params.cb_offset,
.cr_mult = frame_header->film_grain_params.cr_mult,
.cr_luma_mult = frame_header->film_grain_params.cr_luma_mult,
.cr_offset = frame_header->film_grain_params.cr_offset,
},
.tile_cols = frame_header->tile_info.tile_cols,
.tile_rows = frame_header->tile_info.tile_rows,
.context_update_tile_id = frame_header->tile_info.context_update_tile_id,
.pic_info_fields.bits = {
.frame_type = frame_header->frame_type,
.show_frame = frame_header->show_frame,
.showable_frame = frame_header->showable_frame,
.error_resilient_mode = frame_header->error_resilient_mode,
.disable_cdf_update = frame_header->disable_cdf_update,
.allow_screen_content_tools = frame_header->allow_screen_content_tools,
.force_integer_mv = frame_header->force_integer_mv,
.allow_intrabc = frame_header->allow_intrabc,
.use_superres = frame_header->use_superres,
.allow_high_precision_mv = frame_header->allow_high_precision_mv,
.is_motion_mode_switchable = frame_header->is_motion_mode_switchable,
.use_ref_frame_mvs = frame_header->use_ref_frame_mvs,
.disable_frame_end_update_cdf =
frame_header->disable_frame_end_update_cdf,
.uniform_tile_spacing_flag =
frame_header->tile_info.uniform_tile_spacing_flag,
.allow_warped_motion = frame_header->allow_warped_motion,
},
.superres_scale_denominator = frame_header->superres_denom,
.interp_filter = frame_header->interpolation_filter,
/* loop filter */
.loop_filter_info_fields.bits = {
.sharpness_level =
frame_header->loop_filter_params.loop_filter_sharpness,
.mode_ref_delta_enabled =
frame_header->loop_filter_params.loop_filter_delta_enabled,
.mode_ref_delta_update =
frame_header->loop_filter_params.loop_filter_delta_update,
},
.mode_control_fields.bits = {
.delta_lf_present_flag =
frame_header->loop_filter_params.delta_lf_present,
.log2_delta_lf_res = frame_header->loop_filter_params.delta_lf_res,
.delta_lf_multi = frame_header->loop_filter_params.delta_lf_multi,
.delta_q_present_flag =
frame_header->quantization_params.delta_q_present,
.log2_delta_q_res = frame_header->quantization_params.delta_q_res,
.tx_mode = frame_header->tx_mode,
.reference_select = frame_header->reference_select,
.reduced_tx_set_used = frame_header->reduced_tx_set,
.skip_mode_present = frame_header->skip_mode_present,
},
/* quantization */
.base_qindex = frame_header->quantization_params.base_q_idx,
.y_dc_delta_q = frame_header->quantization_params.delta_q_y_dc,
.u_dc_delta_q = frame_header->quantization_params.delta_q_u_dc,
.u_ac_delta_q = frame_header->quantization_params.delta_q_u_ac,
.v_dc_delta_q = frame_header->quantization_params.delta_q_v_dc,
.v_ac_delta_q = frame_header->quantization_params.delta_q_v_ac,
/* loop restoration */
.loop_restoration_fields.bits = {
.yframe_restoration_type =
frame_header->loop_restoration_params.frame_restoration_type[0],
.cbframe_restoration_type =
frame_header->loop_restoration_params.frame_restoration_type[1],
.crframe_restoration_type =
frame_header->loop_restoration_params.frame_restoration_type[2],
.lr_unit_shift = frame_header->loop_restoration_params.lr_unit_shift,
.lr_uv_shift = frame_header->loop_restoration_params.lr_uv_shift,
},
};
/* *INDENT-ON* */
if (seq_header->bit_depth == 8) {
pic_param.bit_depth_idx = 0;
} else if (seq_header->bit_depth == 10) {
pic_param.bit_depth_idx = 1;
} else if (seq_header->bit_depth == 12) {
pic_param.bit_depth_idx = 2;
} else {
g_assert_not_reached ();
}
if (frame_header->film_grain_params.apply_grain) {
pic_param.current_frame = gst_va_decode_picture_get_aux_surface (va_pic);
pic_param.current_display_picture =
gst_va_decode_picture_get_surface (va_pic);
} else {
pic_param.current_frame = gst_va_decode_picture_get_surface (va_pic);
pic_param.current_display_picture = VA_INVALID_SURFACE;
}
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
if (dpb->pic_list[i]) {
if (dpb->pic_list[i]->apply_grain) {
pic_param.ref_frame_map[i] = gst_va_decode_picture_get_aux_surface
(gst_av1_picture_get_user_data (dpb->pic_list[i]));
} else {
pic_param.ref_frame_map[i] = gst_va_decode_picture_get_surface
(gst_av1_picture_get_user_data (dpb->pic_list[i]));
}
} else {
pic_param.ref_frame_map[i] = VA_INVALID_SURFACE;
}
}
for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
pic_param.ref_frame_idx[i] = frame_header->ref_frame_idx[i];
}
pic_param.primary_ref_frame = frame_header->primary_ref_frame;
_setup_segment_info (&pic_param, frame_header);
_setup_film_grain_info (&pic_param, frame_header);
for (i = 0; i < 63; i++) {
pic_param.width_in_sbs_minus_1[i] =
frame_header->tile_info.width_in_sbs_minus_1[i];
pic_param.height_in_sbs_minus_1[i] =
frame_header->tile_info.height_in_sbs_minus_1[i];
}
_setup_loop_filter_info (&pic_param, frame_header);
_setup_quantization_info (&pic_param, frame_header);
_setup_cdef_info (&pic_param, frame_header, seq_header->num_planes);
_setup_global_motion_info (&pic_param, frame_header);
if (!gst_va_decoder_add_param_buffer (base->decoder, va_pic,
VAPictureParameterBufferType, &pic_param, sizeof (pic_param)))
return GST_FLOW_ERROR;
return GST_FLOW_OK;
}
static GstFlowReturn
gst_va_av1_dec_decode_tile (GstAV1Decoder * decoder, GstAV1Picture * picture,
GstAV1Tile * tile)
{
GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
GstAV1TileGroupOBU *tile_group = &tile->tile_group;
GstVaDecodePicture *va_pic;
guint i;
VASliceParameterBufferAV1 slice_param[GST_AV1_MAX_TILE_COUNT];
GST_TRACE_OBJECT (self, "-");
for (i = 0; i < tile_group->tg_end - tile_group->tg_start + 1; i++) {
slice_param[i] = (VASliceParameterBufferAV1) {
};
slice_param[i].slice_data_size =
tile_group->entry[tile_group->tg_start + i].tile_size;
slice_param[i].slice_data_offset =
tile_group->entry[tile_group->tg_start + i].tile_offset;
slice_param[i].tile_row =
tile_group->entry[tile_group->tg_start + i].tile_row;
slice_param[i].tile_column =
tile_group->entry[tile_group->tg_start + i].tile_col;
slice_param[i].slice_data_flag = 0;
}
va_pic = gst_av1_picture_get_user_data (picture);
if (!gst_va_decoder_add_slice_buffer_with_n_params (base->decoder, va_pic,
slice_param, sizeof (VASliceParameterBufferAV1), i, tile->obu.data,
tile->obu.obu_size)) {
return GST_FLOW_ERROR;
}
return GST_FLOW_OK;
}
static GstFlowReturn
gst_va_av1_dec_end_picture (GstAV1Decoder * decoder, GstAV1Picture * picture)
{
GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
GstVaDecodePicture *va_pic;
GST_LOG_OBJECT (self, "end picture %p, (system_frame_number %d)",
picture, picture->system_frame_number);
va_pic = gst_av1_picture_get_user_data (picture);
if (!gst_va_decoder_decode_with_aux_surface (base->decoder, va_pic,
picture->apply_grain)) {
return GST_FLOW_ERROR;
}
return GST_FLOW_OK;
}
static GstFlowReturn
gst_va_av1_dec_output_picture (GstAV1Decoder * decoder,
GstVideoCodecFrame * frame, GstAV1Picture * picture)
{
GstVaAV1Dec *self = GST_VA_AV1_DEC (decoder);
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
g_assert (picture->frame_hdr.show_frame ||
picture->frame_hdr.show_existing_frame);
GST_LOG_OBJECT (self,
"Outputting picture %p (system_frame_number %d)",
picture, picture->system_frame_number);
if (self->last_ret != GST_FLOW_OK) {
gst_av1_picture_unref (picture);
gst_video_decoder_drop_frame (GST_VIDEO_DECODER (self), frame);
return self->last_ret;
}
if (picture->frame_hdr.show_existing_frame) {
GstVaDecodePicture *pic;
g_assert (!frame->output_buffer);
pic = gst_av1_picture_get_user_data (picture);
frame->output_buffer = gst_buffer_ref (pic->gstbuffer);
}
if (base->copy_frames)
gst_va_base_dec_copy_output_buffer (base, frame);
gst_av1_picture_unref (picture);
return gst_video_decoder_finish_frame (GST_VIDEO_DECODER (self), frame);
}
static void
gst_va_av1_dec_init (GTypeInstance * instance, gpointer g_class)
{
gst_va_base_dec_init (GST_VA_BASE_DEC (instance), GST_CAT_DEFAULT);
}
static void
gst_va_av1_dec_dispose (GObject * object)
{
gst_va_base_dec_close (GST_VIDEO_DECODER (object));
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gst_va_av1_dec_class_init (gpointer g_class, gpointer class_data)
{
GstCaps *src_doc_caps, *sink_doc_caps;
GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
GstAV1DecoderClass *av1decoder_class = GST_AV1_DECODER_CLASS (g_class);
GstVideoDecoderClass *decoder_class = GST_VIDEO_DECODER_CLASS (g_class);
struct CData *cdata = class_data;
gchar *long_name;
if (cdata->description) {
long_name = g_strdup_printf ("VA-API AV1 Decoder in %s",
cdata->description);
} else {
long_name = g_strdup ("VA-API AV1 Decoder");
}
gst_element_class_set_metadata (element_class, long_name,
"Codec/Decoder/Video/Hardware",
"VA-API based AV1 video decoder", "He Junyan <junyan.he@intel.com>");
sink_doc_caps = gst_caps_from_string (sink_caps_str);
src_doc_caps = gst_caps_from_string (src_caps_str);
parent_class = g_type_class_peek_parent (g_class);
gst_va_base_dec_class_init (GST_VA_BASE_DEC_CLASS (g_class), AV1,
cdata->render_device_path, cdata->sink_caps, cdata->src_caps,
src_doc_caps, sink_doc_caps);
gobject_class->dispose = gst_va_av1_dec_dispose;
decoder_class->getcaps = GST_DEBUG_FUNCPTR (gst_va_av1_dec_getcaps);
decoder_class->negotiate = GST_DEBUG_FUNCPTR (gst_va_av1_dec_negotiate);
av1decoder_class->new_sequence =
GST_DEBUG_FUNCPTR (gst_va_av1_dec_new_sequence);
av1decoder_class->new_picture =
GST_DEBUG_FUNCPTR (gst_va_av1_dec_new_picture);
av1decoder_class->duplicate_picture =
GST_DEBUG_FUNCPTR (gst_va_av1_dec_duplicate_picture);
av1decoder_class->start_picture =
GST_DEBUG_FUNCPTR (gst_va_av1_dec_start_picture);
av1decoder_class->decode_tile =
GST_DEBUG_FUNCPTR (gst_va_av1_dec_decode_tile);
av1decoder_class->end_picture =
GST_DEBUG_FUNCPTR (gst_va_av1_dec_end_picture);
av1decoder_class->output_picture =
GST_DEBUG_FUNCPTR (gst_va_av1_dec_output_picture);
g_free (long_name);
g_free (cdata->description);
g_free (cdata->render_device_path);
gst_caps_unref (cdata->src_caps);
gst_caps_unref (cdata->sink_caps);
g_free (cdata);
}
static gpointer
_register_debug_category (gpointer data)
{
GST_DEBUG_CATEGORY_INIT (gst_va_av1dec_debug, "vaav1dec", 0,
"VA AV1 decoder");
return NULL;
}
gboolean
gst_va_av1_dec_register (GstPlugin * plugin, GstVaDevice * device,
GstCaps * sink_caps, GstCaps * src_caps, guint rank)
{
static GOnce debug_once = G_ONCE_INIT;
GType type;
GTypeInfo type_info = {
.class_size = sizeof (GstVaAV1DecClass),
.class_init = gst_va_av1_dec_class_init,
.instance_size = sizeof (GstVaAV1Dec),
.instance_init = gst_va_av1_dec_init,
};
struct CData *cdata;
gboolean ret;
gchar *type_name, *feature_name;
g_return_val_if_fail (GST_IS_PLUGIN (plugin), FALSE);
g_return_val_if_fail (GST_IS_VA_DEVICE (device), FALSE);
g_return_val_if_fail (GST_IS_CAPS (sink_caps), FALSE);
g_return_val_if_fail (GST_IS_CAPS (src_caps), FALSE);
cdata = g_new (struct CData, 1);
cdata->description = NULL;
cdata->render_device_path = g_strdup (device->render_device_path);
cdata->sink_caps = _complete_sink_caps (sink_caps);
cdata->src_caps = gst_caps_ref (src_caps);
/* class data will be leaked if the element never gets instantiated */
GST_MINI_OBJECT_FLAG_SET (cdata->sink_caps,
GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);
GST_MINI_OBJECT_FLAG_SET (src_caps, GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);
type_info.class_data = cdata;
type_name = g_strdup ("GstVaAV1Dec");
feature_name = g_strdup ("vaav1dec");
/* The first decoder to be registered should use a constant name,
* like vaav1dec, for any additional decoders, we create unique
* names, using inserting the render device name. */
if (g_type_from_name (type_name)) {
gchar *basename = g_path_get_basename (device->render_device_path);
g_free (type_name);
g_free (feature_name);
type_name = g_strdup_printf ("GstVa%sAV1Dec", basename);
feature_name = g_strdup_printf ("va%sav1dec", basename);
cdata->description = basename;
/* lower rank for non-first device */
if (rank > 0)
rank--;
}
g_once (&debug_once, _register_debug_category, NULL);
type = g_type_register_static (GST_TYPE_AV1_DECODER,
type_name, &type_info, 0);
ret = gst_element_register (plugin, feature_name, rank, type);
g_free (type_name);
g_free (feature_name);
return ret;
}
Reference in a new issue View git blame Copy permalink