mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-27 20:21:24 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/sys/va/gstvah265dec.c
Nicolas Dufresne 2950c76c8f va: Add HEVC decoding support 
This add HEVC decoding support into the new VA plugin. This implementation has
been tested using the ITU comformance test (through fluster). It fails all
MAIN10 tests, as this is not implemented yet along with the following:

CONFWIN_A_Sony_1 (looks fine, but md5sum is incorrect)
PICSIZE_A_Bossen_1 (height too high)
PICSIZE_B_Bossen_1 (same)
VPSSPSPPS_A_MainConcept_1 (parser issue)

Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/merge_requests/1714>
2020-11-04 17:53:23 +00:00

1076 lines
35 KiB
C
Raw Blame History

/* GStreamer
* Copyright (C) 2020 Igalia, S.L.
* Author: Víctor Jáquez <vjaquez@igalia.com>
* Copyright (C) 2020 Collabora
* Author: Nicolas Dufresne <nicolas.dufresne@collabora.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-vah265dec
* @title: vah265dec
* @short_description: A VA-API based H265 video decoder
*
* vah265dec decodes H265 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=big_buck_bunny.mov ! parsebin ! vah265dec ! autovideosink
* ```
*
* Since: 1.20
*
*/
/* ToDo:
*
* + interlaced streams
* + mutiview and stereo profiles
* + SCC extension buffer
* + Add 10bit support
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gstvah265dec.h"
#include "gstvabasedec.h"
GST_DEBUG_CATEGORY_STATIC (gst_va_h265dec_debug);
#ifndef GST_DISABLE_GST_DEBUG
#define GST_CAT_DEFAULT gst_va_h265dec_debug
#else
#define GST_CAT_DEFAULT NULL
#endif
#define GST_VA_H265_DEC(obj) ((GstVaH265Dec *) obj)
#define GST_VA_H265_DEC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_TYPE_FROM_INSTANCE (obj), GstVaH265DecClass))
#define GST_VA_H265_DEC_CLASS(klass) ((GstVaH265DecClass *) klass)
typedef struct _GstVaH265Dec GstVaH265Dec;
typedef struct _GstVaH265DecClass GstVaH265DecClass;
struct _GstVaH265DecClass
{
GstVaBaseDecClass parent_class;
};
struct _GstVaH265Dec
{
GstVaBaseDec parent;
GstFlowReturn last_ret;
gint coded_width;
gint coded_height;
gint dpb_size;
VAPictureParameterBufferHEVC pic_param;
gint32 WpOffsetHalfRangeC;
gboolean need_negotiation;
};
#define parent_class gst_va_base_dec_parent_class
extern gpointer gst_va_base_dec_parent_class;
/* *INDENT-OFF* */
static const gchar *src_caps_str = GST_VIDEO_CAPS_MAKE_WITH_FEATURES ("memory:VAMemory",
"{ NV12, P010_10LE }") " ;" GST_VIDEO_CAPS_MAKE ("{ NV12, P010_10LE }");
/* *INDENT-ON* */
static const gchar *sink_caps_str = "video/x-h265";
static gboolean
gst_va_h265_dec_end_picture (GstH265Decoder * decoder, GstH265Picture * picture)
{
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
GstVaDecodePicture *va_pic;
GST_LOG_OBJECT (base, "end picture %p, (poc %d)",
picture, picture->pic_order_cnt);
va_pic = gst_h265_picture_get_user_data (picture);
return gst_va_decoder_decode (base->decoder, va_pic);
}
static GstFlowReturn
gst_va_h265_dec_output_picture (GstH265Decoder * decoder,
GstVideoCodecFrame * frame, GstH265Picture * picture)
{
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
GstVaH265Dec *self = GST_VA_H265_DEC (decoder);
GST_LOG_OBJECT (self,
"Outputting picture %p (poc %d)", picture, picture->pic_order_cnt);
if (self->last_ret != GST_FLOW_OK) {
gst_h265_picture_unref (picture);
gst_video_decoder_drop_frame (GST_VIDEO_DECODER (self), frame);
return self->last_ret;
}
if (base->copy_frames)
gst_va_base_dec_copy_output_buffer (base, frame);
gst_h265_picture_unref (picture);
return gst_video_decoder_finish_frame (GST_VIDEO_DECODER (self), frame);
}
static void
_init_vaapi_pic (VAPictureHEVC * va_picture)
{
va_picture->picture_id = VA_INVALID_ID;
va_picture->flags = VA_PICTURE_HEVC_INVALID;
va_picture->pic_order_cnt = 0;
}
static gint
_find_frame_rps_type (GstH265Decoder * decoder, GstH265Picture * ref_pic)
{
gint i;
for (i = 0; i < G_N_ELEMENTS (decoder->RefPicSetStCurrBefore); i++) {
if (ref_pic == decoder->RefPicSetStCurrBefore[i])
return VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE;
}
for (i = 0; i < G_N_ELEMENTS (decoder->RefPicSetStCurrAfter); i++) {
if (ref_pic == decoder->RefPicSetStCurrAfter[i])
return VA_PICTURE_HEVC_RPS_ST_CURR_AFTER;
}
for (i = 0; i < G_N_ELEMENTS (decoder->RefPicSetLtCurr); i++) {
if (ref_pic == decoder->RefPicSetLtCurr[i])
return VA_PICTURE_HEVC_RPS_LT_CURR;
}
return 0;
}
static void
_fill_vaapi_pic (GstH265Decoder * decoder, VAPictureHEVC * va_picture,
GstH265Picture * picture)
{
GstVaDecodePicture *va_pic;
va_pic = gst_h265_picture_get_user_data (picture);
if (!va_pic) {
_init_vaapi_pic (va_picture);
return;
}
va_picture->picture_id = gst_va_decode_picture_get_surface (va_pic);
va_picture->pic_order_cnt = picture->pic_order_cnt;
va_picture->flags = 0;
if (picture->ref && picture->long_term)
va_picture->flags |= VA_PICTURE_HEVC_LONG_TERM_REFERENCE;
va_picture->flags |= _find_frame_rps_type (decoder, picture);
switch (picture->field) {
case GST_H265_PICTURE_FIELD_FRAME:
break;
case GST_H265_PICTURE_FILED_TOP_FIELD:
va_picture->flags |= VA_PICTURE_HEVC_FIELD_PIC;
break;
case GST_H265_PICTURE_FIELD_BOTTOM_FIELD:
va_picture->flags |= VA_PICTURE_HEVC_FIELD_PIC;
va_picture->flags |= VA_PICTURE_HEVC_BOTTOM_FIELD;
break;
default:
break;
}
}
static guint8
_get_reference_index (GstH265Decoder * decoder, GstH265Picture * picture)
{
GstVaH265Dec *self = GST_VA_H265_DEC (decoder);
guint8 i;
for (i = 0; i < 15; i++) {
VAPictureHEVC *ref_va_pic = &self->pic_param.ReferenceFrames[i];
if (ref_va_pic->picture_id == VA_INVALID_ID)
break;
if (ref_va_pic->pic_order_cnt == picture->pic_order_cnt)
return i;
}
return 0xFF;
}
/* fill the VA API reference picture lists from the GstCodec reference
* picture list */
static void
_fill_ref_pic_list (GstH265Decoder * decoder, GstH265Picture * cur_pic,
guint8 va_reflist[15], GArray * reflist)
{
guint i;
for (i = 0; i < reflist->len && i < 15; i++) {
GstH265Picture *picture = g_array_index (reflist, GstH265Picture *, i);
va_reflist[i] = _get_reference_index (decoder, picture);
}
for (; i < 15; i++)
va_reflist[i] = 0xFF;
}
static void
_fill_pred_weight_table (GstVaH265Dec * self, GstH265SliceHdr * header,
VASliceParameterBufferHEVC * slice_param)
{
gint chroma_weight, chroma_log2_weight_denom;
gint i, j;
GstH265PPS *pps = header->pps;
if (GST_H265_IS_I_SLICE (header) ||
(!pps->weighted_pred_flag && GST_H265_IS_P_SLICE (header)) ||
(!pps->weighted_bipred_flag && GST_H265_IS_B_SLICE (header)))
return;
slice_param->luma_log2_weight_denom =
header->pred_weight_table.luma_log2_weight_denom;
if (pps->sps->chroma_array_type != 0)
slice_param->delta_chroma_log2_weight_denom =
header->pred_weight_table.delta_chroma_log2_weight_denom;
for (i = 0; i <= header->num_ref_idx_l0_active_minus1; i++) {
if (!header->pred_weight_table.luma_weight_l0_flag[i])
continue;
slice_param->delta_luma_weight_l0[i] =
header->pred_weight_table.delta_luma_weight_l0[i];
slice_param->luma_offset_l0[i] =
header->pred_weight_table.luma_offset_l0[i];
}
chroma_log2_weight_denom = slice_param->luma_log2_weight_denom +
slice_param->delta_chroma_log2_weight_denom;
for (i = 0; i <= header->num_ref_idx_l0_active_minus1; i++) {
if (!header->pred_weight_table.chroma_weight_l0_flag[i])
continue;
for (j = 0; j < 2; j++) {
gint8 delta_chroma_offset_l0 =
header->pred_weight_table.delta_chroma_offset_l0[i][j];
slice_param->delta_chroma_weight_l0[i][j] =
header->pred_weight_table.delta_chroma_weight_l0[i][j];
/* Find ChromaWeightL0 */
chroma_weight = (1 << chroma_log2_weight_denom) +
header->pred_weight_table.delta_chroma_weight_l0[i][j];
/* 7-56 */
slice_param->ChromaOffsetL0[i][j] = CLAMP (
(self->WpOffsetHalfRangeC + delta_chroma_offset_l0 -
((self->WpOffsetHalfRangeC *
chroma_weight) >> chroma_log2_weight_denom)),
-self->WpOffsetHalfRangeC, self->WpOffsetHalfRangeC - 1);
}
}
/* Skip l1 if this is not a B-Frame. */
if (!GST_H265_IS_B_SLICE (header))
return;
for (i = 0; i <= header->num_ref_idx_l1_active_minus1; i++) {
if (!header->pred_weight_table.luma_weight_l1_flag[i])
continue;
slice_param->delta_luma_weight_l1[i] =
header->pred_weight_table.delta_luma_weight_l1[i];
slice_param->luma_offset_l1[i] =
header->pred_weight_table.luma_offset_l1[i];
}
for (i = 0; i <= header->num_ref_idx_l1_active_minus1; i++) {
if (!header->pred_weight_table.chroma_weight_l1_flag[i])
continue;
for (j = 0; j < 2; j++) {
gint8 delta_chroma_offset_l1 =
header->pred_weight_table.delta_chroma_offset_l1[i][j];
slice_param->delta_chroma_weight_l1[i][j] =
header->pred_weight_table.delta_chroma_weight_l1[i][j];
/* Find ChromaWeightL1 */
chroma_weight = (1 << chroma_log2_weight_denom) +
header->pred_weight_table.delta_chroma_weight_l1[i][j];
/* 7-56 */
slice_param->ChromaOffsetL1[i][j] = CLAMP (
(self->WpOffsetHalfRangeC + delta_chroma_offset_l1 -
((self->WpOffsetHalfRangeC *
chroma_weight) >> chroma_log2_weight_denom)),
-self->WpOffsetHalfRangeC, self->WpOffsetHalfRangeC - 1);
}
}
}
static inline guint
_get_slice_data_byte_offset (GstH265SliceHdr * slice_hdr,
guint nal_header_bytes)
{
guint epb_count;
epb_count = slice_hdr->n_emulation_prevention_bytes;
return nal_header_bytes + (slice_hdr->header_size + 7) / 8 - epb_count;
}
static gboolean
gst_va_h265_dec_decode_slice (GstH265Decoder * decoder,
GstH265Picture * picture, GstH265Slice * slice, GArray * ref_pic_list0,
GArray * ref_pic_list1)
{
GstH265SliceHdr *header = &slice->header;
GstH265NalUnit *nalu = &slice->nalu;
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
GstVaDecodePicture *va_pic;
VASliceParameterBufferHEVC slice_param;
gboolean ret;
/* *INDENT-OFF* */
slice_param = (VASliceParameterBufferHEVC) {
.slice_data_size = nalu->size,
.slice_data_offset = 0,
.slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
.slice_data_byte_offset = _get_slice_data_byte_offset (header, nalu->header_bytes),
.slice_segment_address = header->segment_address,
.collocated_ref_idx = header->temporal_mvp_enabled_flag ? header->collocated_ref_idx : 0xFF,
.num_ref_idx_l0_active_minus1 = header->num_ref_idx_l0_active_minus1,
.num_ref_idx_l1_active_minus1 = header->num_ref_idx_l1_active_minus1,
.slice_qp_delta = header->qp_delta,
.slice_cb_qp_offset = header->cb_qp_offset,
.slice_cr_qp_offset = header->cr_qp_offset,
.slice_beta_offset_div2 = header->beta_offset_div2,
.slice_tc_offset_div2 = header->tc_offset_div2,
.five_minus_max_num_merge_cand = header->five_minus_max_num_merge_cand,
.num_entry_point_offsets = header->num_entry_point_offsets,
.entry_offset_to_subset_array = 0, /* does not exist in spec */
.slice_data_num_emu_prevn_bytes = header->n_emulation_prevention_bytes,
};
/* *INDENT-ON* */
/* FIXME to set this right, we'd need to delay writing this until we get
* called on end_picture(), which is all silly */
slice_param.LongSliceFlags.fields.LastSliceOfPic = 0;
slice_param.LongSliceFlags.fields.dependent_slice_segment_flag =
header->dependent_slice_segment_flag;
slice_param.LongSliceFlags.fields.slice_type = header->type;
slice_param.LongSliceFlags.fields.color_plane_id = header->colour_plane_id;
slice_param.LongSliceFlags.fields.slice_sao_luma_flag = header->sao_luma_flag;
slice_param.LongSliceFlags.fields.slice_sao_chroma_flag =
header->sao_chroma_flag;
slice_param.LongSliceFlags.fields.mvd_l1_zero_flag = header->mvd_l1_zero_flag;
slice_param.LongSliceFlags.fields.cabac_init_flag = header->cabac_init_flag;
slice_param.LongSliceFlags.fields.slice_temporal_mvp_enabled_flag =
header->temporal_mvp_enabled_flag;
slice_param.LongSliceFlags.fields.slice_deblocking_filter_disabled_flag =
header->deblocking_filter_disabled_flag;
slice_param.LongSliceFlags.fields.collocated_from_l0_flag =
header->collocated_from_l0_flag;
slice_param.LongSliceFlags.
fields.slice_loop_filter_across_slices_enabled_flag =
header->loop_filter_across_slices_enabled_flag;
_fill_ref_pic_list (decoder, picture, slice_param.RefPicList[0],
ref_pic_list0);
_fill_ref_pic_list (decoder, picture, slice_param.RefPicList[1],
ref_pic_list1);
_fill_pred_weight_table (GST_VA_H265_DEC (decoder), header, &slice_param);
va_pic = gst_h265_picture_get_user_data (picture);
ret = gst_va_decoder_add_slice_buffer (base->decoder, va_pic, &slice_param,
sizeof (slice_param), slice->nalu.data + slice->nalu.offset,
slice->nalu.size);
if (!ret) {
gst_va_decoder_destroy_buffers (base->decoder, va_pic);
return FALSE;
}
return TRUE;
}
static gboolean
gst_va_h265_dec_start_picture (GstH265Decoder * decoder,
GstH265Picture * picture, GstH265Slice * slice, GstH265Dpb * dpb)
{
GstH265PPS *pps;
GstH265SPS *sps;
GstVaH265Dec *self = GST_VA_H265_DEC (decoder);
GstVaBaseDec *base = &self->parent;
GstVaDecodePicture *va_pic;
GstH265ScalingList *scaling_list = NULL;
VAIQMatrixBufferHEVC iq_matrix = { 0, };
VAPictureParameterBufferHEVC *pic_param = &self->pic_param;
guint i;
va_pic = gst_h265_picture_get_user_data (picture);
pps = slice->header.pps;
sps = pps->sps;
/* *INDENT-OFF* */
*pic_param = (VAPictureParameterBufferHEVC) {
.pic_width_in_luma_samples = sps->pic_width_in_luma_samples,
.pic_height_in_luma_samples = sps->pic_height_in_luma_samples,
.sps_max_dec_pic_buffering_minus1 = sps->max_dec_pic_buffering_minus1[sps->max_sub_layers_minus1],
.bit_depth_luma_minus8 = sps->bit_depth_luma_minus8,
.bit_depth_chroma_minus8 = sps->bit_depth_chroma_minus8,
.pcm_sample_bit_depth_luma_minus1 = sps->pcm_sample_bit_depth_luma_minus1,
.pcm_sample_bit_depth_chroma_minus1 = sps->pcm_sample_bit_depth_chroma_minus1,
.log2_min_luma_coding_block_size_minus3 = sps->log2_min_luma_coding_block_size_minus3,
.log2_diff_max_min_luma_coding_block_size = sps->log2_diff_max_min_luma_coding_block_size,
.log2_min_transform_block_size_minus2 = sps->log2_min_transform_block_size_minus2,
.log2_diff_max_min_transform_block_size = sps->log2_diff_max_min_transform_block_size,
.log2_min_pcm_luma_coding_block_size_minus3 = sps->log2_min_pcm_luma_coding_block_size_minus3,
.log2_diff_max_min_pcm_luma_coding_block_size = sps->log2_diff_max_min_pcm_luma_coding_block_size,
.max_transform_hierarchy_depth_intra = sps->max_transform_hierarchy_depth_intra,
.max_transform_hierarchy_depth_inter = sps->max_transform_hierarchy_depth_inter,
.init_qp_minus26 = pps->init_qp_minus26,
.diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth,
.pps_cb_qp_offset = pps->cb_qp_offset,
.pps_cr_qp_offset = pps->cr_qp_offset,
.log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level_minus2,
.num_tile_columns_minus1 = pps->num_tile_columns_minus1,
.num_tile_rows_minus1 = pps->num_tile_rows_minus1,
.log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_pic_order_cnt_lsb_minus4,
.num_short_term_ref_pic_sets = sps->num_short_term_ref_pic_sets,
.num_long_term_ref_pic_sps = sps->num_long_term_ref_pics_sps,
.num_ref_idx_l0_default_active_minus1 = pps->num_ref_idx_l0_default_active_minus1,
.num_ref_idx_l1_default_active_minus1 = pps->num_ref_idx_l1_default_active_minus1,
.pps_beta_offset_div2 = pps->beta_offset_div2,
.pps_tc_offset_div2 = pps->tc_offset_div2,
.num_extra_slice_header_bits = pps->num_extra_slice_header_bits,
.st_rps_bits = slice->header.short_term_ref_pic_set_size, /* FIXME missing emulation bits removal */
.pic_fields.bits = {
.chroma_format_idc = sps->chroma_format_idc,
.separate_colour_plane_flag = sps->separate_colour_plane_flag,
.pcm_enabled_flag = sps->pcm_enabled_flag,
.scaling_list_enabled_flag = sps->scaling_list_enabled_flag,
.transform_skip_enabled_flag = pps->transform_skip_enabled_flag,
.amp_enabled_flag = sps->amp_enabled_flag,
.strong_intra_smoothing_enabled_flag = sps->strong_intra_smoothing_enabled_flag,
.sign_data_hiding_enabled_flag = pps->sign_data_hiding_enabled_flag,
.constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
.cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag,
.weighted_pred_flag = pps->weighted_pred_flag,
.weighted_bipred_flag = pps->weighted_bipred_flag,
.transquant_bypass_enabled_flag = pps->transquant_bypass_enabled_flag,
.tiles_enabled_flag = pps->tiles_enabled_flag,
.entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag,
.pps_loop_filter_across_slices_enabled_flag = pps->loop_filter_across_slices_enabled_flag,
.loop_filter_across_tiles_enabled_flag = pps->loop_filter_across_tiles_enabled_flag,
.pcm_loop_filter_disabled_flag = sps->pcm_loop_filter_disabled_flag,
/* Not set by FFMPEG either */
.NoPicReorderingFlag = 0,
.NoBiPredFlag = 0,
},
.slice_parsing_fields.bits = {
.lists_modification_present_flag = pps->lists_modification_present_flag,
.long_term_ref_pics_present_flag = sps->long_term_ref_pics_present_flag,
.sps_temporal_mvp_enabled_flag = sps->temporal_mvp_enabled_flag,
.cabac_init_present_flag = pps->cabac_init_present_flag,
.output_flag_present_flag = pps->output_flag_present_flag,
.dependent_slice_segments_enabled_flag = pps->dependent_slice_segments_enabled_flag,
.pps_slice_chroma_qp_offsets_present_flag = pps->slice_chroma_qp_offsets_present_flag,
.sample_adaptive_offset_enabled_flag = sps->sample_adaptive_offset_enabled_flag,
.deblocking_filter_override_enabled_flag = pps->deblocking_filter_override_enabled_flag,
.pps_disable_deblocking_filter_flag = pps->deblocking_filter_disabled_flag,
.slice_segment_header_extension_present_flag = pps->slice_segment_header_extension_present_flag,
.RapPicFlag = picture->RapPicFlag,
.IdrPicFlag = GST_H265_IS_NAL_TYPE_IDR (slice->nalu.type),
.IntraPicFlag = GST_H265_IS_NAL_TYPE_IRAP (slice->nalu.type),
},
};
/* *INDENT-ON* */
for (i = 0; i <= pps->num_tile_columns_minus1; i++)
pic_param->column_width_minus1[i] = pps->column_width_minus1[i];
for (i = 0; i <= pps->num_tile_rows_minus1; i++)
pic_param->row_height_minus1[i] = pps->row_height_minus1[i];
_fill_vaapi_pic (decoder, &pic_param->CurrPic, picture);
/* reference frames */
{
GArray *ref_list = gst_h265_dpb_get_pictures_all (dpb);
for (i = 0; i < 15 && i < ref_list->len; i++) {
GstH265Picture *pic = g_array_index (ref_list, GstH265Picture *, i);
_fill_vaapi_pic (decoder, &pic_param->ReferenceFrames[i], pic);
}
g_array_unref (ref_list);
for (; i < 15; i++)
_init_vaapi_pic (&pic_param->ReferenceFrames[i]);
}
if (!gst_va_decoder_add_param_buffer (base->decoder, va_pic,
VAPictureParameterBufferType, pic_param, sizeof (*pic_param)))
goto fail;
if (pps->scaling_list_data_present_flag ||
(sps->scaling_list_enabled_flag
&& !sps->scaling_list_data_present_flag)) {
scaling_list = &pps->scaling_list;
GST_DEBUG_OBJECT (decoder, "Passing scaling list from PPS");
} else if (sps->scaling_list_enabled_flag &&
sps->scaling_list_data_present_flag) {
scaling_list = &sps->scaling_list;
GST_DEBUG_OBJECT (decoder, "Passing scaling list from SPS");
}
if (scaling_list) {
for (i = 0; i < G_N_ELEMENTS (iq_matrix.ScalingList4x4); i++)
gst_h265_quant_matrix_4x4_get_raster_from_uprightdiagonal
(iq_matrix.ScalingList4x4[i], scaling_list->scaling_lists_4x4[i]);
for (i = 0; i < G_N_ELEMENTS (iq_matrix.ScalingList8x8); i++)
gst_h265_quant_matrix_8x8_get_raster_from_uprightdiagonal
(iq_matrix.ScalingList8x8[i], scaling_list->scaling_lists_8x8[i]);
for (i = 0; i < G_N_ELEMENTS (iq_matrix.ScalingList16x16); i++)
gst_h265_quant_matrix_16x16_get_raster_from_uprightdiagonal
(iq_matrix.ScalingList16x16[i], scaling_list->scaling_lists_16x16[i]);
for (i = 0; i < G_N_ELEMENTS (iq_matrix.ScalingList32x32); i++)
gst_h265_quant_matrix_32x32_get_raster_from_uprightdiagonal
(iq_matrix.ScalingList32x32[i], scaling_list->scaling_lists_32x32[i]);
for (i = 0; i < 6; i++)
iq_matrix.ScalingListDC16x16[i] =
scaling_list->scaling_list_dc_coef_minus8_16x16[i] + 8;
for (i = 0; i < 2; i++)
iq_matrix.ScalingListDC32x32[i] =
scaling_list->scaling_list_dc_coef_minus8_32x32[i] + 8;
if (!gst_va_decoder_add_param_buffer (base->decoder, va_pic,
VAIQMatrixBufferType, &iq_matrix, sizeof (iq_matrix)))
goto fail;
}
return TRUE;
fail:
{
gst_va_decoder_destroy_buffers (base->decoder, va_pic);
return FALSE;
}
}
static gboolean
gst_va_h265_dec_new_picture (GstH265Decoder * decoder,
GstVideoCodecFrame * frame, GstH265Picture * picture)
{
GstVaH265Dec *self = GST_VA_H265_DEC (decoder);
GstVaDecodePicture *pic;
GstVideoDecoder *vdec = GST_VIDEO_DECODER (decoder);
self->last_ret = gst_video_decoder_allocate_output_frame (vdec, frame);
if (self->last_ret != GST_FLOW_OK)
goto error;
pic = gst_va_decode_picture_new (frame->output_buffer);
gst_h265_picture_set_user_data (picture, pic,
(GDestroyNotify) gst_va_decode_picture_free);
GST_LOG_OBJECT (self, "New va decode picture %p - %#x", pic,
gst_va_decode_picture_get_surface (pic));
return TRUE;
error:
{
GST_WARNING_OBJECT (self,
"Failed to allocated output buffer, return %s",
gst_flow_get_name (self->last_ret));
return FALSE;
}
}
static guint
_get_rtformat (GstVaH265Dec * self, guint8 bit_depth_luma,
guint8 chroma_format_idc)
{
switch (bit_depth_luma) {
case 10:
if (chroma_format_idc == 3)
return VA_RT_FORMAT_YUV444_10;
if (chroma_format_idc == 2)
return VA_RT_FORMAT_YUV422_10;
else
return VA_RT_FORMAT_YUV420_10;
break;
case 8:
if (chroma_format_idc == 3)
return VA_RT_FORMAT_YUV444;
if (chroma_format_idc == 2)
return VA_RT_FORMAT_YUV422;
else
return VA_RT_FORMAT_YUV420;
break;
default:
GST_ERROR_OBJECT (self, "Unsupported chroma format: %d "
"(with depth luma: %d)", chroma_format_idc, bit_depth_luma);
return 0;
}
}
/* *INDENT-OFF* */
static const struct
{
GstH265Profile profile;
VAProfile va_profile;
} profile_map[] = {
#define P(idc, va) { G_PASTE (GST_H265_PROFILE_, idc), G_PASTE (VAProfileHEVC, va) }
P (MAIN, Main),
P (MAIN_10, Main10),
/*P (MAIN_STILL_PICTURE, ),
P (MONOCHROME, ),
P (MONOCHROME_12, ),
P (MONOCHROME_16, ),*/
P (MAIN_12, Main12),
P (MAIN_422_10, Main422_10),
P (MAIN_422_12, Main422_12),
P (MAIN_444, Main444),
P (MAIN_444_10, Main444_10),
P (MAIN_444_12, Main444_12),
/*P (MAIN_INTRA, ),
P (MAIN_10_INTRA, ),
P (MAIN_12_INTRA, ),
P (MAIN_422_10_INTRA, ),
P (MAIN_422_12_INTRA, ),
P (MAIN_444_INTRA, ),
P (MAIN_444_10_INTRA, ),
P (MAIN_444_12_INTRA, ),
P (MAIN_444_16_INTRA, ),
P (MAIN_444_STILL_PICTURE, ),
P (MAIN_444_16_STILL_PICTURE, ),
P (MONOCHROME_10, ),
P (HIGH_THROUGHPUT_444, ),
P (HIGH_THROUGHPUT_444_10, ),
P (HIGH_THROUGHPUT_444_14, ),
P (HIGH_THROUGHPUT_444_16_INTRA, ),*/
P (SCREEN_EXTENDED_MAIN, SccMain),
P (SCREEN_EXTENDED_MAIN_10, SccMain10),
P (SCREEN_EXTENDED_MAIN_444, SccMain444),
/*P (SCREEN_EXTENDED_MAIN_444_10, ),
P (SCREEN_EXTENDED_HIGH_THROUGHPUT_444, ),
P (SCREEN_EXTENDED_HIGH_THROUGHPUT_444_10, ),
P (SCREEN_EXTENDED_HIGH_THROUGHPUT_444_14, ),
P (MULTIVIEW_MAIN, ),
P (SCALABLE_MAIN, ),
P (SCALABLE_MAIN_10, ),
P (SCALABLE_MONOCHROME, ),
P (SCALABLE_MONOCHROME_12, ),
P (SCALABLE_MONOCHROME_16, ),
P (SCALABLE_MAIN_444, ),
P (3D_MAIN, ),*/
#undef P
};
/* *INDENT-ON* */
static VAProfile
_get_profile (GstVaH265Dec * self, const GstH265SPS * sps, gint max_dpb_size)
{
GstVaBaseDec *base = GST_VA_BASE_DEC (self);
GstH265Profile profile =
gst_h265_profile_tier_level_get_profile (&sps->profile_tier_level);
VAProfile profiles[4];
gint i = 0, j;
for (j = 0; j < G_N_ELEMENTS (profile_map); j++) {
if (profile_map[j].profile == profile) {
profiles[i++] = profile_map[j].va_profile;
break;
}
}
/* TODO Special cases here */
for (j = 0; j < i && j < G_N_ELEMENTS (profiles); j++) {
if (gst_va_decoder_has_profile (base->decoder, profiles[j]))
return profiles[j];
}
GST_ERROR_OBJECT (self, "Unsupported profile: %d", profile);
return VAProfileNone;
}
static gboolean
gst_va_h265_dec_new_sequence (GstH265Decoder * decoder, const GstH265SPS * sps,
gint max_dpb_size)
{
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
GstVaH265Dec *self = GST_VA_H265_DEC (decoder);
VAProfile profile;
gint display_width;
gint display_height;
guint rt_format;
gboolean negotiation_needed = FALSE;
if (self->dpb_size < max_dpb_size)
self->dpb_size = max_dpb_size;
if (sps->conformance_window_flag) {
display_width = sps->crop_rect_width;
display_height = sps->crop_rect_height;
} else {
display_width = sps->width;
display_height = sps->height;
}
profile = _get_profile (self, sps, max_dpb_size);
if (profile == VAProfileNone)
return FALSE;
rt_format = _get_rtformat (self, sps->bit_depth_luma_minus8 + 8,
sps->chroma_format_idc);
if (rt_format == 0)
return FALSE;
if (gst_va_decoder_format_changed (base->decoder, profile,
rt_format, sps->width, sps->height)) {
base->profile = profile;
base->rt_format = rt_format;
self->coded_width = sps->width;
self->coded_height = sps->height;
negotiation_needed = TRUE;
GST_INFO_OBJECT (self, "Format changed to %s [%x] (%dx%d)",
gst_va_profile_name (profile), rt_format, self->coded_width,
self->coded_height);
}
if (base->width != display_width || base->height != display_height) {
base->width = display_width;
base->height = display_height;
negotiation_needed = TRUE;
GST_INFO_OBJECT (self, "Resolution changed to %dx%d", base->width,
base->height);
}
base->need_valign = base->width < self->coded_width
|| base->height < self->coded_height;
if (base->need_valign) {
/* *INDENT-OFF* */
base->valign = (GstVideoAlignment) {
.padding_bottom = self->coded_height - base->height,
.padding_left = self->coded_width - base->width,
};
/* *INDENT-ON* */
}
base->min_buffers = self->dpb_size + 4; /* dpb size + scratch surfaces */
if (negotiation_needed) {
self->need_negotiation = TRUE;
if (!gst_video_decoder_negotiate (GST_VIDEO_DECODER (self))) {
GST_ERROR_OBJECT (self, "Failed to negotiate with downstream");
return FALSE;
}
}
{
/* FIXME: We don't have parser API for sps_range_extension, so
* assuming high_precision_offsets_enabled_flag as zero */
guint high_precision_offsets_enabled_flag = 0, bitdepthC = 0;
/* Calculate WpOffsetHalfRangeC: (7-34) */
bitdepthC = sps->bit_depth_chroma_minus8 + 8;
self->WpOffsetHalfRangeC =
1 << (high_precision_offsets_enabled_flag ? (bitdepthC - 1) : 7);
}
return TRUE;
}
static GstCaps *
_complete_sink_caps (GstCaps * sinkcaps)
{
GstCaps *caps = gst_caps_copy (sinkcaps);
GValue val = G_VALUE_INIT;
const gchar *streamformat[] = { "hvc", "hev1", "byte-stream" };
gint i;
g_value_init (&val, G_TYPE_STRING);
g_value_set_string (&val, "au");
gst_caps_set_value (caps, "alignment", &val);
g_value_unset (&val);
gst_value_list_init (&val, G_N_ELEMENTS (streamformat));
for (i = 0; i < G_N_ELEMENTS (streamformat); i++) {
GValue v = G_VALUE_INIT;
g_value_init (&v, G_TYPE_STRING);
g_value_set_string (&v, streamformat[i]);
gst_value_list_append_value (&val, &v);
g_value_unset (&v);
}
gst_caps_set_value (caps, "stream-format", &val);
g_value_unset (&val);
return caps;
}
static GstCaps *
gst_va_h265_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 gboolean
gst_va_h265_dec_negotiate (GstVideoDecoder * decoder)
{
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
GstVaH265Dec *self = GST_VA_H265_DEC (decoder);
GstVideoFormat format = GST_VIDEO_FORMAT_UNKNOWN;
GstCapsFeatures *capsfeatures = NULL;
GstH265Decoder *h265dec = GST_H265_DECODER (decoder);
/* Ignore downstream renegotiation request. */
if (!self->need_negotiation)
return TRUE;
self->need_negotiation = FALSE;
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_format (base->decoder, self->coded_width,
self->coded_height, NULL))
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, h265dec->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 void
gst_va_h265_dec_dispose (GObject * object)
{
gst_va_base_dec_close (GST_VIDEO_DECODER (object));
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gst_va_h265_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);
GstH265DecoderClass *h265decoder_class = GST_H265_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 H.265 Decoder in %s",
cdata->description);
} else {
long_name = g_strdup ("VA-API H.265 Decoder");
}
gst_element_class_set_metadata (element_class, long_name,
"Codec/Decoder/Video/Hardware",
"VA-API based H.265 video decoder",
"Nicolas Dufresne <nicolas.dufresne@collabora.com>");
sink_doc_caps = gst_caps_from_string (sink_caps_str);
src_doc_caps = gst_caps_from_string (src_caps_str);
gst_va_base_dec_class_init (GST_VA_BASE_DEC_CLASS (g_class), HEVC,
cdata->render_device_path, cdata->sink_caps, cdata->src_caps,
src_doc_caps, sink_doc_caps);
gobject_class->dispose = gst_va_h265_dec_dispose;
decoder_class->getcaps = GST_DEBUG_FUNCPTR (gst_va_h265_dec_getcaps);
decoder_class->negotiate = GST_DEBUG_FUNCPTR (gst_va_h265_dec_negotiate);
h265decoder_class->new_sequence =
GST_DEBUG_FUNCPTR (gst_va_h265_dec_new_sequence);
h265decoder_class->decode_slice =
GST_DEBUG_FUNCPTR (gst_va_h265_dec_decode_slice);
h265decoder_class->new_picture =
GST_DEBUG_FUNCPTR (gst_va_h265_dec_new_picture);
h265decoder_class->output_picture =
GST_DEBUG_FUNCPTR (gst_va_h265_dec_output_picture);
h265decoder_class->start_picture =
GST_DEBUG_FUNCPTR (gst_va_h265_dec_start_picture);
h265decoder_class->end_picture =
GST_DEBUG_FUNCPTR (gst_va_h265_dec_end_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 void
gst_va_h265_dec_init (GTypeInstance * instance, gpointer g_class)
{
gst_va_base_dec_init (GST_VA_BASE_DEC (instance), GST_CAT_DEFAULT);
gst_h265_decoder_set_process_ref_pic_lists (GST_H265_DECODER (instance),
TRUE);
}
static gpointer
_register_debug_category (gpointer data)
{
GST_DEBUG_CATEGORY_INIT (gst_va_h265dec_debug, "vah265dec", 0,
"VA H265 decoder");
return NULL;
}
gboolean
gst_va_h265_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 (GstVaH265DecClass),
.class_init = gst_va_h265_dec_class_init,
.instance_size = sizeof (GstVaH265Dec),
.instance_init = gst_va_h265_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 ("GstVaH265Dec");
feature_name = g_strdup ("vah265dec");
/* The first decoder to be registered should use a constant name,
* like vah265dec, 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%sH265Dec", basename);
feature_name = g_strdup_printf ("va%sh265dec", 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_H265_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