mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-13 03:46:34 +00:00
4cbdf43e7d
Update output caps if it's notified by baseclass See https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/3328 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/3480>
1354 lines
46 KiB
C
1354 lines
46 KiB
C
/* 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)
|
|
|
|
struct slice
|
|
{
|
|
guint8 *data;
|
|
guint size;
|
|
|
|
VASliceParameterBufferHEVCExtension param;
|
|
};
|
|
|
|
typedef struct _GstVaH265Dec GstVaH265Dec;
|
|
typedef struct _GstVaH265DecClass GstVaH265DecClass;
|
|
|
|
struct _GstVaH265DecClass
|
|
{
|
|
GstVaBaseDecClass parent_class;
|
|
};
|
|
|
|
struct _GstVaH265Dec
|
|
{
|
|
GstVaBaseDec parent;
|
|
|
|
gint dpb_size;
|
|
|
|
VAPictureParameterBufferHEVCExtension pic_param;
|
|
|
|
gint32 WpOffsetHalfRangeC;
|
|
|
|
struct slice prev_slice;
|
|
};
|
|
|
|
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-h265";
|
|
|
|
static gboolean
|
|
_is_range_extension_profile (VAProfile profile)
|
|
{
|
|
if (profile == VAProfileHEVCMain422_10
|
|
|| profile == VAProfileHEVCMain444
|
|
|| profile == VAProfileHEVCMain444_10
|
|
|| profile == VAProfileHEVCMain12
|
|
|| profile == VAProfileHEVCMain444_12
|
|
|| profile == VAProfileHEVCMain422_12)
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
_is_screen_content_ext_profile (VAProfile profile)
|
|
{
|
|
if (profile == VAProfileHEVCSccMain || profile == VAProfileHEVCSccMain10
|
|
|| profile == VAProfileHEVCSccMain444
|
|
#if VA_CHECK_VERSION(1, 8, 0)
|
|
|| profile == VAProfileHEVCSccMain444_10
|
|
#endif
|
|
)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static inline void
|
|
_set_last_slice_flag (GstVaH265Dec * self)
|
|
{
|
|
self->prev_slice.param.base.LongSliceFlags.fields.LastSliceOfPic = 1;
|
|
}
|
|
|
|
static void
|
|
_replace_previous_slice (GstVaH265Dec * self, guint8 * data, guint size)
|
|
{
|
|
struct slice *slice = &self->prev_slice;
|
|
gboolean do_reset = (slice->size < size);
|
|
|
|
if (!data || do_reset) {
|
|
g_clear_pointer (&slice->data, g_free);
|
|
slice->size = 0;
|
|
}
|
|
|
|
if (!data)
|
|
return;
|
|
|
|
if (do_reset) {
|
|
GST_LOG_OBJECT (self, "allocating slice data %u", size);
|
|
slice->data = g_malloc (size);
|
|
}
|
|
|
|
memcpy (slice->data, data, size);
|
|
slice->size = size;
|
|
}
|
|
|
|
static gboolean
|
|
_submit_previous_slice (GstVaBaseDec * base, GstVaDecodePicture * va_pic)
|
|
{
|
|
GstVaH265Dec *self = GST_VA_H265_DEC (base);
|
|
struct slice *slice;
|
|
gboolean ret;
|
|
gsize param_size;
|
|
|
|
slice = &self->prev_slice;
|
|
if (!slice->data && slice->size == 0)
|
|
return TRUE;
|
|
if (!slice->data || slice->size == 0)
|
|
return FALSE;
|
|
|
|
param_size = _is_range_extension_profile (self->parent.profile)
|
|
|| _is_screen_content_ext_profile (self->parent.profile) ?
|
|
sizeof (slice->param) : sizeof (slice->param.base);
|
|
ret = gst_va_decoder_add_slice_buffer (base->decoder, va_pic, &slice->param,
|
|
param_size, slice->data, slice->size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_va_h265_dec_end_picture (GstH265Decoder * decoder, GstH265Picture * picture)
|
|
{
|
|
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
|
|
GstVaH265Dec *self = GST_VA_H265_DEC (decoder);
|
|
GstVaDecodePicture *va_pic;
|
|
gboolean ret;
|
|
|
|
GST_LOG_OBJECT (base, "end picture %p, (poc %d)",
|
|
picture, picture->pic_order_cnt);
|
|
|
|
va_pic = gst_h265_picture_get_user_data (picture);
|
|
|
|
_set_last_slice_flag (self);
|
|
ret = _submit_previous_slice (base, va_pic);
|
|
|
|
/* TODO(victor): optimization: this could be done at decoder's
|
|
* stop() vmethod */
|
|
_replace_previous_slice (self, NULL, 0);
|
|
|
|
if (!ret) {
|
|
GST_ERROR_OBJECT (self, "Failed to submit the previous slice");
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
ret = gst_va_decoder_decode (base->decoder, va_pic);
|
|
if (!ret) {
|
|
GST_ERROR_OBJECT (self, "Failed at end picture %p, (poc %d)",
|
|
picture, picture->pic_order_cnt);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
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);
|
|
GstVideoDecoder *vdec = GST_VIDEO_DECODER (decoder);
|
|
GstVaDecodePicture *va_pic;
|
|
gboolean ret;
|
|
|
|
va_pic = gst_h265_picture_get_user_data (picture);
|
|
g_assert (va_pic->gstbuffer);
|
|
|
|
GST_LOG_OBJECT (self,
|
|
"Outputting picture %p (poc %d)", picture, picture->pic_order_cnt);
|
|
|
|
gst_buffer_replace (&frame->output_buffer, va_pic->gstbuffer);
|
|
|
|
ret = gst_va_base_dec_process_output (base, frame, picture->discont_state,
|
|
picture->buffer_flags);
|
|
gst_h265_picture_unref (picture);
|
|
|
|
if (ret)
|
|
return gst_video_decoder_finish_frame (vdec, frame);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
static guint8
|
|
_get_reference_index (GstH265Decoder * decoder, GstH265Picture * picture)
|
|
{
|
|
GstVaH265Dec *self = GST_VA_H265_DEC (decoder);
|
|
guint8 i;
|
|
|
|
if (!picture)
|
|
return 0xFF;
|
|
|
|
for (i = 0; i < 15; i++) {
|
|
VAPictureHEVC *ref_va_pic = &self->pic_param.base.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,
|
|
VASliceParameterBufferHEVCExtension * slice_param)
|
|
{
|
|
gint chroma_weight, chroma_log2_weight_denom;
|
|
gint i, j;
|
|
GstH265PPS *pps = header->pps;
|
|
gboolean is_rext = _is_range_extension_profile (self->parent.profile);
|
|
|
|
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->base.luma_log2_weight_denom =
|
|
header->pred_weight_table.luma_log2_weight_denom;
|
|
|
|
if (pps->sps->chroma_array_type != 0)
|
|
slice_param->base.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->base.delta_luma_weight_l0[i] =
|
|
header->pred_weight_table.delta_luma_weight_l0[i];
|
|
slice_param->base.luma_offset_l0[i] =
|
|
header->pred_weight_table.luma_offset_l0[i];
|
|
|
|
if (is_rext) {
|
|
slice_param->rext.luma_offset_l0[i] =
|
|
header->pred_weight_table.luma_offset_l0[i];
|
|
}
|
|
}
|
|
|
|
chroma_log2_weight_denom = slice_param->base.luma_log2_weight_denom +
|
|
slice_param->base.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++) {
|
|
gint16 delta_chroma_offset_l0 =
|
|
header->pred_weight_table.delta_chroma_offset_l0[i][j];
|
|
gint chroma_offset;
|
|
|
|
slice_param->base.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];
|
|
chroma_offset = self->WpOffsetHalfRangeC + delta_chroma_offset_l0
|
|
- ((self->WpOffsetHalfRangeC * chroma_weight)
|
|
>> chroma_log2_weight_denom);
|
|
|
|
/* 7-56 */
|
|
slice_param->base.ChromaOffsetL0[i][j] = CLAMP (chroma_offset,
|
|
-self->WpOffsetHalfRangeC, self->WpOffsetHalfRangeC - 1);
|
|
|
|
if (is_rext) {
|
|
slice_param->rext.ChromaOffsetL0[i][j] =
|
|
slice_param->base.ChromaOffsetL0[i][j];
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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->base.delta_luma_weight_l1[i] =
|
|
header->pred_weight_table.delta_luma_weight_l1[i];
|
|
slice_param->base.luma_offset_l1[i] =
|
|
header->pred_weight_table.luma_offset_l1[i];
|
|
|
|
if (is_rext) {
|
|
slice_param->rext.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++) {
|
|
gint16 delta_chroma_offset_l1 =
|
|
header->pred_weight_table.delta_chroma_offset_l1[i][j];
|
|
gint chroma_offset;
|
|
|
|
slice_param->base.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];
|
|
|
|
chroma_offset = self->WpOffsetHalfRangeC + delta_chroma_offset_l1
|
|
- ((self->WpOffsetHalfRangeC * chroma_weight)
|
|
>> chroma_log2_weight_denom);
|
|
|
|
/* 7-56 */
|
|
slice_param->base.ChromaOffsetL1[i][j] = CLAMP (chroma_offset,
|
|
-self->WpOffsetHalfRangeC, self->WpOffsetHalfRangeC - 1);
|
|
|
|
if (is_rext) {
|
|
slice_param->rext.ChromaOffsetL1[i][j] =
|
|
slice_param->base.ChromaOffsetL1[i][j];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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 GstFlowReturn
|
|
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);
|
|
GstVaH265Dec *self = GST_VA_H265_DEC (decoder);
|
|
GstVaDecodePicture *va_pic;
|
|
VASliceParameterBufferHEVCExtension *slice_param;
|
|
|
|
va_pic = gst_h265_picture_get_user_data (picture);
|
|
if (!_submit_previous_slice (base, va_pic)) {
|
|
_replace_previous_slice (self, NULL, 0);
|
|
GST_ERROR_OBJECT (base, "Failed to submit previous slice buffers");
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
|
|
slice_param = &self->prev_slice.param;
|
|
|
|
/* *INDENT-OFF* */
|
|
slice_param->base = (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,
|
|
.LongSliceFlags.fields = {
|
|
.LastSliceOfPic = 0, /* the last one will be set on end_picture() */
|
|
.dependent_slice_segment_flag = header->dependent_slice_segment_flag,
|
|
.slice_type = header->type,
|
|
.color_plane_id = header->colour_plane_id,
|
|
.slice_sao_luma_flag = header->sao_luma_flag,
|
|
.slice_sao_chroma_flag = header->sao_chroma_flag,
|
|
.mvd_l1_zero_flag = header->mvd_l1_zero_flag,
|
|
.cabac_init_flag = header->cabac_init_flag,
|
|
.slice_temporal_mvp_enabled_flag = header->temporal_mvp_enabled_flag,
|
|
.slice_deblocking_filter_disabled_flag =
|
|
header->deblocking_filter_disabled_flag,
|
|
.collocated_from_l0_flag = header->collocated_from_l0_flag,
|
|
.slice_loop_filter_across_slices_enabled_flag =
|
|
header->loop_filter_across_slices_enabled_flag,
|
|
},
|
|
};
|
|
/* *INDENT-ON* */
|
|
|
|
if (_is_range_extension_profile (base->profile)
|
|
|| _is_screen_content_ext_profile (base->profile)) {
|
|
/* *INDENT-OFF* */
|
|
slice_param->rext = (VASliceParameterBufferHEVCRext) {
|
|
.slice_ext_flags.bits = {
|
|
.cu_chroma_qp_offset_enabled_flag = header->cu_chroma_qp_offset_enabled_flag,
|
|
.use_integer_mv_flag = header->use_integer_mv_flag,
|
|
},
|
|
.slice_act_y_qp_offset = header->slice_act_y_qp_offset,
|
|
.slice_act_cb_qp_offset = header->slice_act_cb_qp_offset,
|
|
.slice_act_cr_qp_offset = header->slice_act_cr_qp_offset,
|
|
};
|
|
/* *INDENT-ON* */
|
|
}
|
|
|
|
_fill_ref_pic_list (decoder, picture, slice_param->base.RefPicList[0],
|
|
ref_pic_list0);
|
|
_fill_ref_pic_list (decoder, picture, slice_param->base.RefPicList[1],
|
|
ref_pic_list1);
|
|
|
|
_fill_pred_weight_table (GST_VA_H265_DEC (decoder), header, slice_param);
|
|
|
|
_replace_previous_slice (self, slice->nalu.data + slice->nalu.offset,
|
|
slice->nalu.size);
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
static void
|
|
_fill_picture_range_ext_parameter (GstVaH265Dec * decoder,
|
|
GstH265SPS * sps, GstH265PPS * pps)
|
|
{
|
|
VAPictureParameterBufferHEVCRext *pic_param = &decoder->pic_param.rext;
|
|
|
|
GstH265SPSExtensionParams *sps_ext = &sps->sps_extension_params;
|
|
GstH265PPSExtensionParams *pps_ext = &pps->pps_extension_params;
|
|
|
|
/* *INDENT-OFF* */
|
|
*pic_param = (VAPictureParameterBufferHEVCRext) {
|
|
.range_extension_pic_fields.bits = {
|
|
.transform_skip_rotation_enabled_flag = sps_ext->transform_skip_rotation_enabled_flag,
|
|
.transform_skip_context_enabled_flag = sps_ext->transform_skip_context_enabled_flag,
|
|
.implicit_rdpcm_enabled_flag = sps_ext->implicit_rdpcm_enabled_flag,
|
|
.explicit_rdpcm_enabled_flag = sps_ext->explicit_rdpcm_enabled_flag,
|
|
.extended_precision_processing_flag = sps_ext->extended_precision_processing_flag,
|
|
.intra_smoothing_disabled_flag = sps_ext->intra_smoothing_disabled_flag,
|
|
.high_precision_offsets_enabled_flag = sps_ext->high_precision_offsets_enabled_flag,
|
|
.persistent_rice_adaptation_enabled_flag = sps_ext->persistent_rice_adaptation_enabled_flag,
|
|
.cabac_bypass_alignment_enabled_flag = sps_ext->cabac_bypass_alignment_enabled_flag,
|
|
.cross_component_prediction_enabled_flag = pps_ext->cross_component_prediction_enabled_flag,
|
|
.chroma_qp_offset_list_enabled_flag = pps_ext->chroma_qp_offset_list_enabled_flag,
|
|
},
|
|
.diff_cu_chroma_qp_offset_depth = pps_ext->diff_cu_chroma_qp_offset_depth,
|
|
.chroma_qp_offset_list_len_minus1 = pps_ext->chroma_qp_offset_list_len_minus1,
|
|
.log2_sao_offset_scale_luma = pps_ext->log2_sao_offset_scale_luma,
|
|
.log2_sao_offset_scale_chroma = pps_ext->log2_sao_offset_scale_chroma,
|
|
.log2_max_transform_skip_block_size_minus2 = pps_ext->log2_max_transform_skip_block_size_minus2,
|
|
};
|
|
/* *INDENT-ON* */
|
|
|
|
memcpy (pic_param->cb_qp_offset_list, pps_ext->cb_qp_offset_list,
|
|
sizeof (pic_param->cb_qp_offset_list));
|
|
memcpy (pic_param->cr_qp_offset_list, pps_ext->cr_qp_offset_list,
|
|
sizeof (pic_param->cr_qp_offset_list));
|
|
}
|
|
|
|
static void
|
|
_fill_screen_content_ext_parameter (GstVaH265Dec * decoder,
|
|
GstH265SPS * sps, GstH265PPS * pps)
|
|
{
|
|
VAPictureParameterBufferHEVCScc *pic_param = &decoder->pic_param.scc;
|
|
const GstH265PPSSccExtensionParams *pps_scc = &pps->pps_scc_extension_params;
|
|
const GstH265SPSSccExtensionParams *sps_scc = &sps->sps_scc_extension_params;
|
|
guint32 num_comps;
|
|
guint i, n;
|
|
|
|
/* *INDENT-OFF* */
|
|
*pic_param = (VAPictureParameterBufferHEVCScc) {
|
|
.screen_content_pic_fields.bits = {
|
|
.pps_curr_pic_ref_enabled_flag = pps_scc->pps_curr_pic_ref_enabled_flag,
|
|
.palette_mode_enabled_flag = sps_scc->palette_mode_enabled_flag,
|
|
.motion_vector_resolution_control_idc = sps_scc->motion_vector_resolution_control_idc,
|
|
.intra_boundary_filtering_disabled_flag = sps_scc->intra_boundary_filtering_disabled_flag,
|
|
.residual_adaptive_colour_transform_enabled_flag = pps_scc->residual_adaptive_colour_transform_enabled_flag,
|
|
.pps_slice_act_qp_offsets_present_flag = pps_scc->pps_slice_act_qp_offsets_present_flag,
|
|
},
|
|
.palette_max_size = sps_scc->palette_max_size,
|
|
.delta_palette_max_predictor_size = sps_scc->delta_palette_max_predictor_size,
|
|
.pps_act_y_qp_offset_plus5 = pps_scc->pps_act_y_qp_offset_plus5,
|
|
.pps_act_cb_qp_offset_plus5 = pps_scc->pps_act_cb_qp_offset_plus5,
|
|
.pps_act_cr_qp_offset_plus3 = pps_scc->pps_act_cr_qp_offset_plus3,
|
|
};
|
|
/* *INDENT-ON* */
|
|
|
|
/* firstly use the pps, then sps */
|
|
num_comps = sps->chroma_format_idc ? 3 : 1;
|
|
|
|
if (pps_scc->pps_palette_predictor_initializers_present_flag) {
|
|
pic_param->predictor_palette_size =
|
|
pps_scc->pps_num_palette_predictor_initializer;
|
|
for (n = 0; n < num_comps; n++)
|
|
for (i = 0; i < pps_scc->pps_num_palette_predictor_initializer; i++)
|
|
pic_param->predictor_palette_entries[n][i] =
|
|
(uint16_t) pps_scc->pps_palette_predictor_initializer[n][i];
|
|
} else if (sps_scc->sps_palette_predictor_initializers_present_flag) {
|
|
pic_param->predictor_palette_size =
|
|
sps_scc->sps_num_palette_predictor_initializer_minus1 + 1;
|
|
for (n = 0; n < num_comps; n++)
|
|
for (i = 0;
|
|
i < sps_scc->sps_num_palette_predictor_initializer_minus1 + 1; i++)
|
|
pic_param->predictor_palette_entries[n][i] =
|
|
(uint16_t) sps_scc->sps_palette_predictor_initializer[n][i];
|
|
}
|
|
}
|
|
|
|
static GstFlowReturn
|
|
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, };
|
|
VAPictureParameterBufferHEVCExtension *pic_param = &self->pic_param;
|
|
gsize pic_param_size;
|
|
guint i;
|
|
|
|
va_pic = gst_h265_picture_get_user_data (picture);
|
|
|
|
pps = slice->header.pps;
|
|
sps = pps->sps;
|
|
|
|
/* *INDENT-OFF* */
|
|
pic_param->base = (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* */
|
|
|
|
if (_is_range_extension_profile (self->parent.profile)
|
|
|| _is_screen_content_ext_profile (self->parent.profile)) {
|
|
_fill_picture_range_ext_parameter (self, sps, pps);
|
|
if (_is_screen_content_ext_profile (self->parent.profile))
|
|
_fill_screen_content_ext_parameter (self, sps, pps);
|
|
}
|
|
|
|
for (i = 0; i <= pps->num_tile_columns_minus1; i++)
|
|
pic_param->base.column_width_minus1[i] = pps->column_width_minus1[i];
|
|
|
|
for (i = 0; i <= pps->num_tile_rows_minus1; i++)
|
|
pic_param->base.row_height_minus1[i] = pps->row_height_minus1[i];
|
|
|
|
_fill_vaapi_pic (decoder, &pic_param->base.CurrPic, picture);
|
|
|
|
/* reference frames */
|
|
{
|
|
GArray *ref_list = gst_h265_dpb_get_pictures_all (dpb);
|
|
guint j;
|
|
|
|
i = 0;
|
|
for (j = 0; j < 15 && j < ref_list->len; j++) {
|
|
GstH265Picture *pic = g_array_index (ref_list, GstH265Picture *, j);
|
|
|
|
if (pic->ref) {
|
|
_fill_vaapi_pic (decoder, &pic_param->base.ReferenceFrames[i], pic);
|
|
i++;
|
|
}
|
|
}
|
|
g_array_unref (ref_list);
|
|
|
|
/* 7.4.3.3.3, the current decoded picture is marked as "used for
|
|
long-term reference". Current picture is not in the DPB now. */
|
|
if (pps->pps_scc_extension_params.pps_curr_pic_ref_enabled_flag && i < 15) {
|
|
pic_param->base.ReferenceFrames[i].picture_id =
|
|
gst_va_decode_picture_get_surface (gst_h265_picture_get_user_data
|
|
(picture));
|
|
pic_param->base.ReferenceFrames[i].pic_order_cnt = picture->pic_order_cnt;
|
|
pic_param->base.ReferenceFrames[i].flags |=
|
|
VA_PICTURE_HEVC_LONG_TERM_REFERENCE;
|
|
pic_param->base.ReferenceFrames[i].flags |=
|
|
_find_frame_rps_type (decoder, picture);
|
|
i++;
|
|
}
|
|
|
|
for (; i < 15; i++)
|
|
_init_vaapi_pic (&pic_param->base.ReferenceFrames[i]);
|
|
}
|
|
|
|
pic_param_size = _is_range_extension_profile (self->parent.profile)
|
|
|| _is_screen_content_ext_profile (self->parent.profile) ?
|
|
sizeof (*pic_param) : sizeof (pic_param->base);
|
|
if (!gst_va_decoder_add_param_buffer (base->decoder, va_pic,
|
|
VAPictureParameterBufferType, pic_param, pic_param_size))
|
|
return GST_FLOW_ERROR;
|
|
|
|
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))) {
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
}
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_va_h265_dec_new_picture (GstH265Decoder * decoder,
|
|
GstVideoCodecFrame * frame, GstH265Picture * picture)
|
|
{
|
|
GstVaBaseDec *base = GST_VA_BASE_DEC (decoder);
|
|
GstVaH265Dec *self = GST_VA_H265_DEC (decoder);
|
|
GstVaDecodePicture *pic;
|
|
GstBuffer *output_buffer;
|
|
GstVideoDecoder *vdec = GST_VIDEO_DECODER (decoder);
|
|
GstFlowReturn ret = GST_FLOW_ERROR;
|
|
|
|
if (base->need_negotiation) {
|
|
if (!gst_video_decoder_negotiate (vdec)) {
|
|
GST_ERROR_OBJECT (self, "Failed to negotiate with downstream");
|
|
return GST_FLOW_NOT_NEGOTIATED;
|
|
}
|
|
}
|
|
|
|
output_buffer = gst_video_decoder_allocate_output_buffer (vdec);
|
|
if (!output_buffer)
|
|
goto error;
|
|
|
|
pic = gst_va_decode_picture_new (base->decoder, output_buffer);
|
|
gst_buffer_unref (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 GST_FLOW_OK;
|
|
|
|
error:
|
|
{
|
|
GST_WARNING_OBJECT (self,
|
|
"Failed to allocated output buffer, return %s",
|
|
gst_flow_get_name (ret));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
static guint
|
|
_get_rtformat (GstVaH265Dec * self, guint8 bit_depth_luma,
|
|
guint8 bit_depth_chroma, guint8 chroma_format_idc)
|
|
{
|
|
guint8 bit_num = MAX (bit_depth_luma, bit_depth_chroma);
|
|
|
|
switch (bit_num) {
|
|
case 11:
|
|
case 12:
|
|
if (chroma_format_idc == 3)
|
|
return VA_RT_FORMAT_YUV444_12;
|
|
if (chroma_format_idc == 2)
|
|
return VA_RT_FORMAT_YUV422_12;
|
|
else
|
|
return VA_RT_FORMAT_YUV420_12;
|
|
break;
|
|
case 9:
|
|
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, with depth chroma: %d)",
|
|
chroma_format_idc, bit_depth_luma, bit_depth_chroma);
|
|
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),
|
|
#if VA_CHECK_VERSION(1, 8, 0)
|
|
P (SCREEN_EXTENDED_MAIN_444_10, SccMain444_10),
|
|
#endif
|
|
/*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)
|
|
{
|
|
GstH265Decoder *h265_decoder = GST_H265_DECODER (self);
|
|
GstVaBaseDec *base = GST_VA_BASE_DEC (self);
|
|
GstH265Profile profile = gst_h265_get_profile_from_sps ((GstH265SPS *) sps);
|
|
VAProfile profiles[4];
|
|
gint i = 0, j;
|
|
|
|
/* 1. The profile directly specified by the SPS should always be the
|
|
first choice. It is the exact one.
|
|
2. The profile in the input caps may contain the compatible profile
|
|
chosen by the upstream element. Upstream element such as the parse
|
|
may already decide the best compatible profile for us. We also need
|
|
to consider it as a choice. */
|
|
|
|
for (j = 0; j < G_N_ELEMENTS (profile_map); j++) {
|
|
if (profile_map[j].profile == profile) {
|
|
profiles[i++] = profile_map[j].va_profile;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (h265_decoder->input_state->caps
|
|
&& gst_caps_is_fixed (h265_decoder->input_state->caps)) {
|
|
GstH265Profile compatible_profile = GST_H265_PROFILE_INVALID;
|
|
GstStructure *structure;
|
|
const gchar *profile_str;
|
|
|
|
structure = gst_caps_get_structure (h265_decoder->input_state->caps, 0);
|
|
|
|
profile_str = gst_structure_get_string (structure, "profile");
|
|
if (profile_str)
|
|
compatible_profile = gst_h265_profile_from_string (profile_str);
|
|
|
|
if (compatible_profile != profile) {
|
|
GST_INFO_OBJECT (self, "The upstream set the compatible profile %s, "
|
|
"also consider it as a candidate.", profile_str);
|
|
|
|
for (j = 0; j < G_N_ELEMENTS (profile_map); j++) {
|
|
if (profile_map[j].profile == compatible_profile) {
|
|
profiles[i++] = profile_map[j].va_profile;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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 GstFlowReturn
|
|
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);
|
|
GstVideoInfo *info = &base->output_info;
|
|
VAProfile profile;
|
|
gint display_width;
|
|
gint display_height;
|
|
gint padding_left, padding_right, padding_top, padding_bottom;
|
|
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;
|
|
padding_left = sps->crop_rect_x;
|
|
padding_right = sps->width - sps->crop_rect_x - display_width;
|
|
padding_top = sps->crop_rect_y;
|
|
padding_bottom = sps->height - sps->crop_rect_y - display_height;
|
|
} else {
|
|
display_width = sps->width;
|
|
display_height = sps->height;
|
|
padding_left = padding_right = padding_top = padding_bottom = 0;
|
|
}
|
|
|
|
profile = _get_profile (self, sps, max_dpb_size);
|
|
if (profile == VAProfileNone)
|
|
return GST_FLOW_NOT_NEGOTIATED;
|
|
|
|
rt_format = _get_rtformat (self, sps->bit_depth_luma_minus8 + 8,
|
|
sps->bit_depth_chroma_minus8 + 8, sps->chroma_format_idc);
|
|
if (rt_format == 0)
|
|
return GST_FLOW_NOT_NEGOTIATED;
|
|
|
|
if (!gst_va_decoder_config_is_equal (base->decoder, profile,
|
|
rt_format, sps->width, sps->height)) {
|
|
base->profile = profile;
|
|
base->rt_format = rt_format;
|
|
base->width = sps->width;
|
|
base->height = sps->height;
|
|
|
|
negotiation_needed = TRUE;
|
|
GST_INFO_OBJECT (self, "Format changed to %s [%x] (%dx%d)",
|
|
gst_va_profile_name (profile), rt_format, base->width, base->height);
|
|
}
|
|
|
|
if (GST_VIDEO_INFO_WIDTH (info) != display_width ||
|
|
GST_VIDEO_INFO_HEIGHT (info) != display_height) {
|
|
GST_VIDEO_INFO_WIDTH (info) = display_width;
|
|
GST_VIDEO_INFO_HEIGHT (info) = display_height;
|
|
|
|
negotiation_needed = TRUE;
|
|
GST_INFO_OBJECT (self, "Resolution changed to %dx%d",
|
|
GST_VIDEO_INFO_WIDTH (info), GST_VIDEO_INFO_HEIGHT (info));
|
|
}
|
|
|
|
base->need_valign = GST_VIDEO_INFO_WIDTH (info) < base->width ||
|
|
GST_VIDEO_INFO_HEIGHT (info) < base->height;
|
|
if (base->need_valign) {
|
|
/* *INDENT-OFF* */
|
|
if (base->valign.padding_left != padding_left ||
|
|
base->valign.padding_right != padding_right ||
|
|
base->valign.padding_top != padding_top ||
|
|
base->valign.padding_bottom != padding_bottom) {
|
|
negotiation_needed = TRUE;
|
|
GST_INFO_OBJECT (self, "crop rect changed to (%d,%d)-->(%d,%d)",
|
|
padding_left, padding_top, padding_right, padding_bottom);
|
|
}
|
|
base->valign = (GstVideoAlignment) {
|
|
.padding_left = padding_left,
|
|
.padding_right = padding_right,
|
|
.padding_top = padding_top,
|
|
.padding_bottom = padding_bottom,
|
|
};
|
|
/* *INDENT-ON* */
|
|
}
|
|
|
|
base->min_buffers = self->dpb_size + 4; /* dpb size + scratch surfaces */
|
|
base->need_negotiation = negotiation_needed;
|
|
g_clear_pointer (&base->input_state, gst_video_codec_state_unref);
|
|
base->input_state = gst_video_codec_state_ref (decoder->input_state);
|
|
|
|
{
|
|
/* 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 GST_FLOW_OK;
|
|
}
|
|
|
|
static GstCaps *
|
|
_complete_sink_caps (GstCaps * sinkcaps)
|
|
{
|
|
GstCaps *caps = gst_caps_copy (sinkcaps);
|
|
GValue val = G_VALUE_INIT;
|
|
const gchar *streamformat[] = { "hvc1", "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 void
|
|
gst_va_h265_dec_dispose (GObject * object)
|
|
{
|
|
g_free (GST_VA_H265_DEC (object)->prev_slice.data);
|
|
|
|
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);
|
|
|
|
parent_class = g_type_class_peek_parent (g_class);
|
|
|
|
/**
|
|
* GstVaH265Dec:device-path:
|
|
*
|
|
* It shows the DRM device path used for the VA operation, if any.
|
|
*
|
|
* Since: 1.22
|
|
*/
|
|
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);
|
|
|
|
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;
|
|
|
|
/* 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 (device->index == 0) {
|
|
type_name = g_strdup ("GstVaH265Dec");
|
|
feature_name = g_strdup ("vah265dec");
|
|
} else {
|
|
gchar *basename = g_path_get_basename (device->render_device_path);
|
|
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;
|
|
}
|