/* * gstvaapidecoder_h265.c - H.265 decoder * * Copyright (C) 2015 Intel Corporation * Author: Sreerenj Balachandran * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 2.1 * of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301 USA */ /** * SECTION:gstvaapidecoder_h265 * @short_description: H.265 decoder */ #include "sysdeps.h" #include #include #include #include "gstvaapicompat.h" #include "gstvaapidecoder_h265.h" #include "gstvaapidecoder_objects.h" #include "gstvaapidecoder_priv.h" #include "gstvaapidisplay_priv.h" #include "gstvaapiutils_h265_priv.h" #define DEBUG 1 #include "gstvaapidebug.h" /* Defined to 1 if strict ordering of DPB is needed. Only useful for debug */ #define USE_STRICT_DPB_ORDERING 0 typedef struct _GstVaapiDecoderH265Private GstVaapiDecoderH265Private; typedef struct _GstVaapiDecoderH265Class GstVaapiDecoderH265Class; typedef struct _GstVaapiFrameStore GstVaapiFrameStore; typedef struct _GstVaapiFrameStoreClass GstVaapiFrameStoreClass; typedef struct _GstVaapiParserInfoH265 GstVaapiParserInfoH265; typedef struct _GstVaapiPictureH265 GstVaapiPictureH265; static gboolean nal_is_slice (guint8 nal_type); /* ------------------------------------------------------------------------- */ /* --- H.265 Parser Info --- */ /* ------------------------------------------------------------------------- */ /* * Extended decoder unit flags: * * @GST_VAAPI_DECODER_UNIT_AU_START: marks the start of an access unit. * @GST_VAAPI_DECODER_UNIT_AU_END: marks the end of an access unit. */ enum { GST_VAAPI_DECODER_UNIT_FLAG_AU_START = (GST_VAAPI_DECODER_UNIT_FLAG_LAST << 0), GST_VAAPI_DECODER_UNIT_FLAG_AU_END = (GST_VAAPI_DECODER_UNIT_FLAG_LAST << 1), GST_VAAPI_DECODER_UNIT_FLAGS_AU = (GST_VAAPI_DECODER_UNIT_FLAG_AU_START | GST_VAAPI_DECODER_UNIT_FLAG_AU_END), }; #define GST_VAAPI_PARSER_INFO_H265(obj) \ ((GstVaapiParserInfoH265 *)(obj)) struct _GstVaapiParserInfoH265 { GstVaapiMiniObject parent_instance; GstH265NalUnit nalu; union { GstH265VPS vps; GstH265SPS sps; GstH265PPS pps; GArray *sei; GstH265SliceHdr slice_hdr; } data; guint state; guint flags; // Same as decoder unit flags (persistent) }; static void gst_vaapi_parser_info_h265_finalize (GstVaapiParserInfoH265 * pi) { if (nal_is_slice (pi->nalu.type)) gst_h265_slice_hdr_free (&pi->data.slice_hdr); else { switch (pi->nalu.type) { case GST_H265_NAL_VPS: case GST_H265_NAL_SPS: case GST_H265_NAL_PPS: break; case GST_H265_NAL_PREFIX_SEI: case GST_H265_NAL_SUFFIX_SEI: if (pi->data.sei) { g_array_unref (pi->data.sei); pi->data.sei = NULL; } break; } } } static inline const GstVaapiMiniObjectClass * gst_vaapi_parser_info_h265_class (void) { static const GstVaapiMiniObjectClass GstVaapiParserInfoH265Class = { .size = sizeof (GstVaapiParserInfoH265), .finalize = (GDestroyNotify) gst_vaapi_parser_info_h265_finalize }; return &GstVaapiParserInfoH265Class; } static inline GstVaapiParserInfoH265 * gst_vaapi_parser_info_h265_new (void) { return (GstVaapiParserInfoH265 *) gst_vaapi_mini_object_new (gst_vaapi_parser_info_h265_class ()); } #define gst_vaapi_parser_info_h265_ref(pi) \ gst_vaapi_mini_object_ref(GST_VAAPI_MINI_OBJECT(pi)) #define gst_vaapi_parser_info_h265_unref(pi) \ gst_vaapi_mini_object_unref(GST_VAAPI_MINI_OBJECT(pi)) #define gst_vaapi_parser_info_h265_replace(old_pi_ptr, new_pi) \ gst_vaapi_mini_object_replace((GstVaapiMiniObject **)(old_pi_ptr), \ (GstVaapiMiniObject *)(new_pi)) /* ------------------------------------------------------------------------- */ /* --- H.265 Pictures --- */ /* ------------------------------------------------------------------------- */ /* * Extended picture flags: * * @GST_VAAPI_PICTURE_FLAG_IDR: flag that specifies an IDR picture * @GST_VAAPI_PICTURE_FLAG_AU_START: flag that marks the start of an * access unit (AU) * @GST_VAAPI_PICTURE_FLAG_AU_END: flag that marks the end of an * access unit (AU) * @GST_VAAPI_PICTURE_FLAG_RPS_ST_CURR_BEFORE: flag indicate the inclusion * of picture in RefPicSetStCurrBefore reference list * @GST_VAAPI_PICTURE_FLAG_RPS_ST_CURR_AFTER: flag indicate the inclusion * of picture in RefPictSetStCurrAfter reference list * @GST_VAAPI_PICTURE_FLAG_RPS_ST_FOLL: flag indicate the inclusion * of picture in RefPicSetStFoll reference list * @GST_VAAPI_PICTURE_FLAG_RPS_LT_CURR: flag indicate the inclusion * of picture in RefPicSetLtCurr reference list * @GST_VAAPI_PICTURE_FLAG_RPS_LT_FOLL: flag indicate the inclusion * of picture in RefPicSetLtFoll reference list * @GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE: flag that specifies * "used for short-term reference" * @GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE: flag that specifies * "used for long-term reference" * @GST_VAAPI_PICTURE_FLAGS_REFERENCE: mask covering any kind of * reference picture (short-term reference or long-term reference) */ enum { GST_VAAPI_PICTURE_FLAG_IDR = (GST_VAAPI_PICTURE_FLAG_LAST << 0), GST_VAAPI_PICTURE_FLAG_REFERENCE2 = (GST_VAAPI_PICTURE_FLAG_LAST << 1), GST_VAAPI_PICTURE_FLAG_AU_START = (GST_VAAPI_PICTURE_FLAG_LAST << 4), GST_VAAPI_PICTURE_FLAG_AU_END = (GST_VAAPI_PICTURE_FLAG_LAST << 5), GST_VAAPI_PICTURE_FLAG_RPS_ST_CURR_BEFORE = (GST_VAAPI_PICTURE_FLAG_LAST << 6), GST_VAAPI_PICTURE_FLAG_RPS_ST_CURR_AFTER = (GST_VAAPI_PICTURE_FLAG_LAST << 7), GST_VAAPI_PICTURE_FLAG_RPS_ST_FOLL = (GST_VAAPI_PICTURE_FLAG_LAST << 8), GST_VAAPI_PICTURE_FLAG_RPS_LT_CURR = (GST_VAAPI_PICTURE_FLAG_LAST << 9), GST_VAAPI_PICTURE_FLAG_RPS_LT_FOLL = (GST_VAAPI_PICTURE_FLAG_LAST << 10), GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE = (GST_VAAPI_PICTURE_FLAG_REFERENCE), GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE = (GST_VAAPI_PICTURE_FLAG_REFERENCE | GST_VAAPI_PICTURE_FLAG_REFERENCE2), GST_VAAPI_PICTURE_FLAGS_REFERENCE = (GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE | GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE), GST_VAAPI_PICTURE_FLAGS_RPS_ST = (GST_VAAPI_PICTURE_FLAG_RPS_ST_CURR_BEFORE | GST_VAAPI_PICTURE_FLAG_RPS_ST_CURR_AFTER | GST_VAAPI_PICTURE_FLAG_RPS_ST_FOLL), GST_VAAPI_PICTURE_FLAGS_RPS_LT = (GST_VAAPI_PICTURE_FLAG_RPS_LT_CURR | GST_VAAPI_PICTURE_FLAG_RPS_LT_FOLL), }; #define GST_VAAPI_PICTURE_IS_IDR(picture) \ (GST_VAAPI_PICTURE_FLAG_IS_SET(picture, GST_VAAPI_PICTURE_FLAG_IDR)) #define GST_VAAPI_PICTURE_IS_SHORT_TERM_REFERENCE(picture) \ ((GST_VAAPI_PICTURE_FLAGS(picture) & \ GST_VAAPI_PICTURE_FLAGS_REFERENCE) == \ GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE) #define GST_VAAPI_PICTURE_IS_LONG_TERM_REFERENCE(picture) \ ((GST_VAAPI_PICTURE_FLAGS(picture) & \ GST_VAAPI_PICTURE_FLAGS_REFERENCE) == \ GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE) #define GST_VAAPI_PICTURE_H265(picture) \ ((GstVaapiPictureH265 *)(picture)) struct _GstVaapiPictureH265 { GstVaapiPicture base; GstH265SliceHdr *last_slice_hdr; guint structure; gint32 poc; // PicOrderCntVal (8.3.1) gint32 poc_lsb; // slice_pic_order_cnt_lsb guint32 pic_latency_cnt; // PicLatencyCount guint output_flag:1; guint output_needed:1; guint NoRaslOutputFlag:1; guint NoOutputOfPriorPicsFlag:1; guint RapPicFlag:1; // nalu type between 16 and 21 guint IntraPicFlag:1; // Intra pic (only Intra slices) }; GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiPictureH265, gst_vaapi_picture_h265); void gst_vaapi_picture_h265_destroy (GstVaapiPictureH265 * picture) { gst_vaapi_picture_destroy (GST_VAAPI_PICTURE (picture)); } gboolean gst_vaapi_picture_h265_create (GstVaapiPictureH265 * picture, const GstVaapiCodecObjectConstructorArgs * args) { if (!gst_vaapi_picture_create (GST_VAAPI_PICTURE (picture), args)) return FALSE; picture->structure = picture->base.structure; picture->poc = G_MAXINT32; picture->output_needed = FALSE; return TRUE; } static inline void gst_vaapi_picture_h265_set_reference (GstVaapiPictureH265 * picture, guint reference_flags) { if (!picture) return; GST_VAAPI_PICTURE_FLAG_UNSET (picture, GST_VAAPI_PICTURE_FLAGS_RPS_ST | GST_VAAPI_PICTURE_FLAGS_RPS_LT); GST_VAAPI_PICTURE_FLAG_UNSET (picture, GST_VAAPI_PICTURE_FLAGS_REFERENCE); GST_VAAPI_PICTURE_FLAG_SET (picture, reference_flags); } /* ------------------------------------------------------------------------- */ /* --- Frame Buffers (DPB) --- */ /* ------------------------------------------------------------------------- */ struct _GstVaapiFrameStore { /*< private > */ GstVaapiMiniObject parent_instance; GstVaapiPictureH265 *buffer; }; static void gst_vaapi_frame_store_finalize (gpointer object) { GstVaapiFrameStore *const fs = object; gst_vaapi_picture_replace (&fs->buffer, NULL); } static GstVaapiFrameStore * gst_vaapi_frame_store_new (GstVaapiPictureH265 * picture) { GstVaapiFrameStore *fs; static const GstVaapiMiniObjectClass GstVaapiFrameStoreClass = { sizeof (GstVaapiFrameStore), gst_vaapi_frame_store_finalize }; fs = (GstVaapiFrameStore *) gst_vaapi_mini_object_new (&GstVaapiFrameStoreClass); if (!fs) return NULL; fs->buffer = gst_vaapi_picture_ref (picture); return fs; } static inline gboolean gst_vaapi_frame_store_has_reference (GstVaapiFrameStore * fs) { if (GST_VAAPI_PICTURE_IS_REFERENCE (fs->buffer)) return TRUE; return FALSE; } #define gst_vaapi_frame_store_ref(fs) \ gst_vaapi_mini_object_ref(GST_VAAPI_MINI_OBJECT(fs)) #define gst_vaapi_frame_store_unref(fs) \ gst_vaapi_mini_object_unref(GST_VAAPI_MINI_OBJECT(fs)) #define gst_vaapi_frame_store_replace(old_fs_p, new_fs) \ gst_vaapi_mini_object_replace((GstVaapiMiniObject **)(old_fs_p), \ (GstVaapiMiniObject *)(new_fs)) /* ------------------------------------------------------------------------- */ /* --- H.265 Decoder --- */ /* ------------------------------------------------------------------------- */ #define GST_VAAPI_DECODER_H265_CAST(decoder) \ ((GstVaapiDecoderH265 *)(decoder)) typedef enum { GST_H265_VIDEO_STATE_GOT_VPS = 1 << 0, GST_H265_VIDEO_STATE_GOT_SPS = 1 << 1, GST_H265_VIDEO_STATE_GOT_PPS = 1 << 2, GST_H265_VIDEO_STATE_GOT_SLICE = 1 << 3, GST_H265_VIDEO_STATE_GOT_I_FRAME = 1 << 4, /* persistent across SPS */ GST_H265_VIDEO_STATE_GOT_P_SLICE = 1 << 5, /* predictive (all non-intra) */ GST_H265_VIDEO_STATE_VALID_PICTURE_HEADERS = (GST_H265_VIDEO_STATE_GOT_SPS | GST_H265_VIDEO_STATE_GOT_PPS), GST_H265_VIDEO_STATE_VALID_PICTURE = (GST_H265_VIDEO_STATE_VALID_PICTURE_HEADERS | GST_H265_VIDEO_STATE_GOT_SLICE) } GstH265VideoState; struct _GstVaapiDecoderH265Private { GstH265Parser *parser; guint parser_state; guint decoder_state; GstVaapiStreamAlignH265 stream_alignment; GstVaapiPictureH265 *current_picture; GstVaapiParserInfoH265 *vps[GST_H265_MAX_VPS_COUNT]; GstVaapiParserInfoH265 *active_vps; GstVaapiParserInfoH265 *sps[GST_H265_MAX_SPS_COUNT]; GstVaapiParserInfoH265 *active_sps; GstVaapiParserInfoH265 *pps[GST_H265_MAX_PPS_COUNT]; GstVaapiParserInfoH265 *active_pps; GstVaapiParserInfoH265 *prev_pi; GstVaapiParserInfoH265 *prev_slice_pi; GstVaapiParserInfoH265 *prev_independent_slice_pi; GstVaapiFrameStore **dpb; guint dpb_count; guint dpb_size; guint dpb_size_max; GstVaapiProfile profile; GstVaapiEntrypoint entrypoint; GstVaapiChromaType chroma_type; GstVaapiPictureH265 *RefPicSetStCurrBefore[16]; GstVaapiPictureH265 *RefPicSetStCurrAfter[16]; GstVaapiPictureH265 *RefPicSetStFoll[16]; GstVaapiPictureH265 *RefPicSetLtCurr[16]; GstVaapiPictureH265 *RefPicSetLtFoll[16]; GstVaapiPictureH265 *RefPicList0[16]; guint RefPicList0_count; GstVaapiPictureH265 *RefPicList1[16]; guint RefPicList1_count; guint32 SpsMaxLatencyPictures; gint32 WpOffsetHalfRangeC; guint nal_length_size; guint pic_width_in_luma_samples; //sps->pic_width_in_luma_samples guint pic_height_in_luma_samples; //sps->pic_height_in_luma_samples guint pic_structure; // pic_struct (from SEI pic_timing() or inferred) gint32 poc; // PicOrderCntVal gint32 poc_msb; // PicOrderCntMsb gint32 poc_lsb; // pic_order_cnt_lsb (from slice_header()) gint32 prev_poc_msb; // prevPicOrderCntMsb gint32 prev_poc_lsb; // prevPicOrderCntLsb gint32 prev_tid0pic_poc_lsb; gint32 prev_tid0pic_poc_msb; gint32 PocStCurrBefore[16]; gint32 PocStCurrAfter[16]; gint32 PocStFoll[16]; gint32 PocLtCurr[16]; gint32 PocLtFoll[16]; guint NumPocStCurrBefore; guint NumPocStCurrAfter; guint NumPocStFoll; guint NumPocLtCurr; guint NumPocLtFoll; guint NumPocTotalCurr; guint is_opened:1; guint is_hvcC:1; guint has_context:1; guint progressive_sequence:1; guint new_bitstream:1; guint prev_nal_is_eos:1; /*previous nal type is EOS */ guint associated_irap_NoRaslOutputFlag:1; }; /** * GstVaapiDecoderH265: * * A decoder based on H265. */ struct _GstVaapiDecoderH265 { /*< private > */ GstVaapiDecoder parent_instance; GstVaapiDecoderH265Private priv; }; /** * GstVaapiDecoderH265Class: * * A decoder class based on H265. */ struct _GstVaapiDecoderH265Class { /*< private > */ GstVaapiDecoderClass parent_class; }; G_DEFINE_TYPE (GstVaapiDecoderH265, gst_vaapi_decoder_h265, GST_TYPE_VAAPI_DECODER); #define RSV_VCL_N10 10 #define RSV_VCL_N12 12 #define RSV_VCL_N14 14 static gboolean nal_is_idr (guint8 nal_type) { if ((nal_type == GST_H265_NAL_SLICE_IDR_W_RADL) || (nal_type == GST_H265_NAL_SLICE_IDR_N_LP)) return TRUE; return FALSE; } static gboolean nal_is_irap (guint8 nal_type) { if ((nal_type >= GST_H265_NAL_SLICE_BLA_W_LP) && (nal_type <= RESERVED_IRAP_NAL_TYPE_MAX)) return TRUE; return FALSE; } static gboolean nal_is_bla (guint8 nal_type) { if ((nal_type >= GST_H265_NAL_SLICE_BLA_W_LP) && (nal_type <= GST_H265_NAL_SLICE_BLA_N_LP)) return TRUE; return FALSE; } static gboolean nal_is_cra (guint8 nal_type) { if (nal_type == GST_H265_NAL_SLICE_CRA_NUT) return TRUE; return FALSE; } static gboolean nal_is_radl (guint8 nal_type) { if ((nal_type >= GST_H265_NAL_SLICE_RADL_N) && (nal_type <= GST_H265_NAL_SLICE_RADL_R)) return TRUE; return FALSE; } static gboolean nal_is_rasl (guint8 nal_type) { if ((nal_type >= GST_H265_NAL_SLICE_RASL_N) && (nal_type <= GST_H265_NAL_SLICE_RASL_R)) return TRUE; return FALSE; } static gboolean nal_is_slice (guint8 nal_type) { if ((nal_type >= GST_H265_NAL_SLICE_TRAIL_N) && (nal_type <= GST_H265_NAL_SLICE_CRA_NUT)) return TRUE; return FALSE; } static gboolean nal_is_ref (guint8 nal_type) { gboolean ret = FALSE; switch (nal_type) { case GST_H265_NAL_SLICE_TRAIL_N: case GST_H265_NAL_SLICE_TSA_N: case GST_H265_NAL_SLICE_STSA_N: case GST_H265_NAL_SLICE_RADL_N: case GST_H265_NAL_SLICE_RASL_N: case RSV_VCL_N10: case RSV_VCL_N12: case RSV_VCL_N14: ret = FALSE; break; default: ret = TRUE; break; } return ret; } static gboolean is_range_extension_profile (GstVaapiProfile profile) { if (profile == GST_VAAPI_PROFILE_H265_MAIN_422_10 || profile == GST_VAAPI_PROFILE_H265_MAIN_444 || profile == GST_VAAPI_PROFILE_H265_MAIN_444_10 || profile == GST_VAAPI_PROFILE_H265_MAIN12) return TRUE; return FALSE; } static gboolean is_scc_profile (GstVaapiProfile profile) { #if VA_CHECK_VERSION(1,2,0) if (profile == GST_VAAPI_PROFILE_H265_SCREEN_EXTENDED_MAIN || profile == GST_VAAPI_PROFILE_H265_SCREEN_EXTENDED_MAIN_10 || profile == GST_VAAPI_PROFILE_H265_SCREEN_EXTENDED_MAIN_444 #if VA_CHECK_VERSION(1,8,0) || profile == GST_VAAPI_PROFILE_H265_SCREEN_EXTENDED_MAIN_444_10 #endif ) return TRUE; #endif return FALSE; } static inline GstVaapiPictureH265 * gst_vaapi_picture_h265_new (GstVaapiDecoderH265 * decoder) { GstVaapiDecoderH265Private *const priv = &decoder->priv; if (is_range_extension_profile (priv->profile) || is_scc_profile (priv->profile)) { #if VA_CHECK_VERSION(1,2,0) return (GstVaapiPictureH265 *) gst_vaapi_codec_object_new (&GstVaapiPictureH265Class, GST_VAAPI_CODEC_BASE (decoder), NULL, sizeof (VAPictureParameterBufferHEVCExtension), NULL, 0, 0); #endif return NULL; } else { return (GstVaapiPictureH265 *) gst_vaapi_codec_object_new (&GstVaapiPictureH265Class, GST_VAAPI_CODEC_BASE (decoder), NULL, sizeof (VAPictureParameterBufferHEVC), NULL, 0, 0); } } /* Activates the supplied PPS */ static GstH265PPS * ensure_pps (GstVaapiDecoderH265 * decoder, GstH265PPS * pps) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = priv->pps[pps->id]; gst_vaapi_parser_info_h265_replace (&priv->active_pps, pi); return pi ? &pi->data.pps : NULL; } /* Returns the active PPS */ static inline GstH265PPS * get_pps (GstVaapiDecoderH265 * decoder) { GstVaapiParserInfoH265 *const pi = decoder->priv.active_pps; return pi ? &pi->data.pps : NULL; } /* Activate the supplied SPS */ static GstH265SPS * ensure_sps (GstVaapiDecoderH265 * decoder, GstH265SPS * sps) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = priv->sps[sps->id]; /* Propagate "got I-frame" state to the next SPS unit if the current * sequence was not ended */ if (pi && priv->active_sps) pi->state |= (priv->active_sps->state & GST_H265_VIDEO_STATE_GOT_I_FRAME); gst_vaapi_parser_info_h265_replace (&priv->active_sps, pi); return pi ? &pi->data.sps : NULL; } /* Returns the active SPS */ static inline GstH265SPS * get_sps (GstVaapiDecoderH265 * decoder) { GstVaapiParserInfoH265 *const pi = decoder->priv.active_sps; return pi ? &pi->data.sps : NULL; } /* VPS nal is not necessary to decode the base layers, so this is not * needed at the moment. But in future we need this, especially when * dealing with MVC and scalable layer decoding. * See https://bugzilla.gnome.org/show_bug.cgi?id=754250 */ #if 0 /* Activate the supplied VPS */ static GstH265VPS * ensure_vps (GstVaapiDecoderH265 * decoder, GstH265VPS * vps) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = priv->vps[vps->id]; gst_vaapi_parser_info_h265_replace (&priv->active_vps, pi); return pi ? &pi->data.vps : NULL; } /* Returns the active VPS */ static inline GstH265VPS * get_vps (GstVaapiDecoderH265 * decoder) { GstVaapiParserInfoH265 *const pi = decoder->priv.active_vps; return pi ? &pi->data.vps : NULL; } #endif /* Get number of reference frames to use */ static guint get_max_dec_frame_buffering (GstH265SPS * sps) { G_GNUC_UNUSED guint max_dec_frame_buffering; /* FIXME */ GstVaapiLevelH265 level; const GstVaapiH265LevelLimits *level_limits; level = gst_vaapi_utils_h265_get_level (sps->profile_tier_level.level_idc); level_limits = gst_vaapi_utils_h265_get_level_limits (level); if (G_UNLIKELY (!level_limits)) { GST_FIXME ("unsupported level_idc value (%d)", sps->profile_tier_level.level_idc); max_dec_frame_buffering = 16; } /* FIXME: Add limit check based on Annex A */ /* Assuming HighestTid as sps_max_sub_layers_minus1 */ return MAX (1, (sps->max_dec_pic_buffering_minus1[sps->max_sub_layers_minus1] + 1)); } static void dpb_remove_all (GstVaapiDecoderH265 * decoder) { GstVaapiDecoderH265Private *const priv = &decoder->priv; while (priv->dpb_count > 0) gst_vaapi_frame_store_replace (&priv->dpb[--priv->dpb_count], NULL); } static void dpb_remove_index (GstVaapiDecoderH265 * decoder, gint index) { GstVaapiDecoderH265Private *const priv = &decoder->priv; guint i, num_frames = --priv->dpb_count; if (USE_STRICT_DPB_ORDERING) { for (i = index; i < num_frames; i++) gst_vaapi_frame_store_replace (&priv->dpb[i], priv->dpb[i + 1]); } else if (index != num_frames) gst_vaapi_frame_store_replace (&priv->dpb[index], priv->dpb[num_frames]); gst_vaapi_frame_store_replace (&priv->dpb[num_frames], NULL); } static gboolean dpb_output (GstVaapiDecoderH265 * decoder, GstVaapiFrameStore * fs) { GstVaapiPictureH265 *picture; g_return_val_if_fail (fs != NULL, FALSE); picture = fs->buffer; if (!picture) return FALSE; picture->output_needed = FALSE; return gst_vaapi_picture_output (GST_VAAPI_PICTURE_CAST (picture)); } /* Get the dpb picture having the specifed poc or poc_lsb */ static GstVaapiPictureH265 * dpb_get_picture (GstVaapiDecoderH265 * decoder, gint poc, gboolean match_lsb) { GstVaapiDecoderH265Private *const priv = &decoder->priv; guint i; for (i = 0; i < priv->dpb_count; i++) { GstVaapiPictureH265 *const picture = priv->dpb[i]->buffer; if (picture && GST_VAAPI_PICTURE_FLAG_IS_SET (picture, GST_VAAPI_PICTURE_FLAGS_REFERENCE)) { if (match_lsb) { if (picture->poc_lsb == poc) return picture; } else { if (picture->poc == poc) return picture; } } } return NULL; } /* Get the dpb picture having the specifed poc and shor/long ref flags */ static GstVaapiPictureH265 * dpb_get_ref_picture (GstVaapiDecoderH265 * decoder, gint poc, gboolean is_short) { GstVaapiDecoderH265Private *const priv = &decoder->priv; guint i; for (i = 0; i < priv->dpb_count; i++) { GstVaapiPictureH265 *const picture = priv->dpb[i]->buffer; if (picture && picture->poc == poc) { if (is_short && GST_VAAPI_PICTURE_IS_SHORT_TERM_REFERENCE (picture)) return picture; else if (GST_VAAPI_PICTURE_IS_LONG_TERM_REFERENCE (picture)) return picture; } } return NULL; } /* Finds the picture with the lowest POC that needs to be output */ static gint dpb_find_lowest_poc (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 ** found_picture_ptr) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiPictureH265 *found_picture = NULL; guint i, found_index = -1; for (i = 0; i < priv->dpb_count; i++) { GstVaapiPictureH265 *const picture = priv->dpb[i]->buffer; if (picture && !picture->output_needed) continue; if (picture && (!found_picture || found_picture->poc > picture->poc)) { found_picture = picture; found_index = i; } } if (found_picture_ptr) *found_picture_ptr = found_picture; return found_index; } static gboolean dpb_bump (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiPictureH265 *found_picture; gint found_index; gboolean success; found_index = dpb_find_lowest_poc (decoder, &found_picture); if (found_index < 0) return FALSE; success = dpb_output (decoder, priv->dpb[found_index]); if (!gst_vaapi_frame_store_has_reference (priv->dpb[found_index])) dpb_remove_index (decoder, found_index); return success; } static void dpb_clear (GstVaapiDecoderH265 * decoder, gboolean hard_flush) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiPictureH265 *pic; guint i; if (hard_flush) { dpb_remove_all (decoder); } else { /* Remove unused pictures from DPB */ i = 0; while (i < priv->dpb_count) { GstVaapiFrameStore *const fs = priv->dpb[i]; pic = fs->buffer; if (!pic->output_needed && !gst_vaapi_frame_store_has_reference (fs)) dpb_remove_index (decoder, i); else i++; } } } static void dpb_flush (GstVaapiDecoderH265 * decoder) { /* Output any frame remaining in DPB */ while (dpb_bump (decoder, NULL)); dpb_clear (decoder, TRUE); } static gint dpb_get_num_need_output (GstVaapiDecoderH265 * decoder) { GstVaapiDecoderH265Private *const priv = &decoder->priv; guint i = 0, n_output_needed = 0; while (i < priv->dpb_count) { GstVaapiFrameStore *const fs = priv->dpb[i]; if (fs->buffer->output_needed) n_output_needed++; i++; } return n_output_needed; } static gboolean check_latency_cnt (GstVaapiDecoderH265 * decoder) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiPictureH265 *tmp_pic; guint i = 0; while (i < priv->dpb_count) { GstVaapiFrameStore *const fs = priv->dpb[i]; tmp_pic = fs->buffer; if (tmp_pic->output_needed) { if (tmp_pic->pic_latency_cnt >= priv->SpsMaxLatencyPictures) return TRUE; } i++; } return FALSE; } static gboolean dpb_add (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstH265SPS *const sps = get_sps (decoder); GstVaapiFrameStore *fs; GstVaapiPictureH265 *tmp_pic; guint i = 0; /* C.5.2.3 */ if (picture->output_flag) { while (i < priv->dpb_count) { GstVaapiFrameStore *const fs = priv->dpb[i]; tmp_pic = fs->buffer; if (tmp_pic->output_needed) tmp_pic->pic_latency_cnt += 1; i++; } } /* Create new frame store */ fs = gst_vaapi_frame_store_new (picture); if (!fs) return FALSE; gst_vaapi_frame_store_replace (&priv->dpb[priv->dpb_count++], fs); gst_vaapi_frame_store_unref (fs); if (picture->output_flag) { picture->output_needed = 1; picture->pic_latency_cnt = 0; } else picture->output_needed = 0; /* set pic as short_term_ref */ gst_vaapi_picture_h265_set_reference (picture, GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE); /* C.5.2.4 "Bumping" process */ while ((dpb_get_num_need_output (decoder) > sps->max_num_reorder_pics[sps->max_sub_layers_minus1]) || (sps->max_latency_increase_plus1[sps->max_sub_layers_minus1] && check_latency_cnt (decoder))) dpb_bump (decoder, picture); return TRUE; } /* C.5.2.2 */ static gboolean dpb_init (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture, GstVaapiParserInfoH265 * pi) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstH265SliceHdr *const slice_hdr = &pi->data.slice_hdr; GstH265SPS *const sps = get_sps (decoder); if (nal_is_irap (pi->nalu.type) && picture->NoRaslOutputFlag && !priv->new_bitstream) { if (pi->nalu.type == GST_H265_NAL_SLICE_CRA_NUT) picture->NoOutputOfPriorPicsFlag = 1; else picture->NoOutputOfPriorPicsFlag = slice_hdr->no_output_of_prior_pics_flag; if (picture->NoOutputOfPriorPicsFlag) dpb_clear (decoder, TRUE); else { dpb_clear (decoder, FALSE); while (dpb_bump (decoder, NULL)); } } else { dpb_clear (decoder, FALSE); while ((dpb_get_num_need_output (decoder) > sps->max_num_reorder_pics[sps->max_sub_layers_minus1]) || (sps->max_latency_increase_plus1[sps->max_sub_layers_minus1] && check_latency_cnt (decoder)) || (priv->dpb_count >= (sps->max_dec_pic_buffering_minus1[sps->max_sub_layers_minus1] + 1))) { dpb_bump (decoder, picture); } } return TRUE; } static gboolean dpb_reset (GstVaapiDecoderH265 * decoder, guint dpb_size) { GstVaapiDecoderH265Private *const priv = &decoder->priv; if (dpb_size > priv->dpb_size_max) { priv->dpb = g_try_realloc_n (priv->dpb, dpb_size, sizeof (*priv->dpb)); if (!priv->dpb) return FALSE; memset (&priv->dpb[priv->dpb_size_max], 0, (dpb_size - priv->dpb_size_max) * sizeof (*priv->dpb)); priv->dpb_size_max = dpb_size; } priv->dpb_size = dpb_size; GST_DEBUG ("DPB size %u", priv->dpb_size); return TRUE; } static GstVaapiDecoderStatus get_status (GstH265ParserResult result) { GstVaapiDecoderStatus status; switch (result) { case GST_H265_PARSER_OK: status = GST_VAAPI_DECODER_STATUS_SUCCESS; break; case GST_H265_PARSER_NO_NAL_END: status = GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA; break; case GST_H265_PARSER_ERROR: status = GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER; break; default: status = GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; break; } return status; } static void gst_vaapi_decoder_h265_close (GstVaapiDecoderH265 * decoder) { GstVaapiDecoderH265Private *const priv = &decoder->priv; gst_vaapi_picture_replace (&priv->current_picture, NULL); gst_vaapi_parser_info_h265_replace (&priv->prev_slice_pi, NULL); gst_vaapi_parser_info_h265_replace (&priv->prev_independent_slice_pi, NULL); gst_vaapi_parser_info_h265_replace (&priv->prev_pi, NULL); dpb_clear (decoder, TRUE); if (priv->parser) { gst_h265_parser_free (priv->parser); priv->parser = NULL; } priv->is_opened = FALSE; } static gboolean gst_vaapi_decoder_h265_open (GstVaapiDecoderH265 * decoder) { GstVaapiDecoderH265Private *const priv = &decoder->priv; gst_vaapi_decoder_h265_close (decoder); priv->parser = gst_h265_parser_new (); if (!priv->parser) return FALSE; return TRUE; } static void gst_vaapi_decoder_h265_destroy (GstVaapiDecoder * base_decoder) { GstVaapiDecoderH265 *const decoder = GST_VAAPI_DECODER_H265_CAST (base_decoder); GstVaapiDecoderH265Private *const priv = &decoder->priv; guint i; gst_vaapi_decoder_h265_close (decoder); g_clear_pointer (&priv->dpb, g_free); priv->dpb_count = priv->dpb_size_max = priv->dpb_size = 0; for (i = 0; i < G_N_ELEMENTS (priv->pps); i++) gst_vaapi_parser_info_h265_replace (&priv->pps[i], NULL); gst_vaapi_parser_info_h265_replace (&priv->active_pps, NULL); for (i = 0; i < G_N_ELEMENTS (priv->sps); i++) gst_vaapi_parser_info_h265_replace (&priv->sps[i], NULL); gst_vaapi_parser_info_h265_replace (&priv->active_sps, NULL); for (i = 0; i < G_N_ELEMENTS (priv->vps); i++) gst_vaapi_parser_info_h265_replace (&priv->vps[i], NULL); gst_vaapi_parser_info_h265_replace (&priv->active_vps, NULL); } static gboolean gst_vaapi_decoder_h265_create (GstVaapiDecoder * base_decoder) { GstVaapiDecoderH265 *const decoder = GST_VAAPI_DECODER_H265_CAST (base_decoder); GstVaapiDecoderH265Private *const priv = &decoder->priv; priv->profile = GST_VAAPI_PROFILE_UNKNOWN; priv->entrypoint = GST_VAAPI_ENTRYPOINT_VLD; priv->chroma_type = GST_VAAPI_CHROMA_TYPE_YUV420; priv->progressive_sequence = TRUE; priv->new_bitstream = TRUE; priv->prev_nal_is_eos = FALSE; return TRUE; } static GstVaapiDecoderStatus gst_vaapi_decoder_h265_reset (GstVaapiDecoder * base_decoder) { gst_vaapi_decoder_h265_destroy (base_decoder); gst_vaapi_decoder_h265_create (base_decoder); return GST_VAAPI_DECODER_STATUS_SUCCESS; } static void fill_profiles (GstVaapiProfile profiles[16], guint * n_profiles_ptr, GstVaapiProfile profile) { guint n_profiles = *n_profiles_ptr; profiles[n_profiles++] = profile; switch (profile) { case GST_VAAPI_PROFILE_H265_MAIN: profiles[n_profiles++] = GST_VAAPI_PROFILE_H265_MAIN10; break; case GST_VAAPI_PROFILE_H265_MAIN_STILL_PICTURE: profiles[n_profiles++] = GST_VAAPI_PROFILE_H265_MAIN; profiles[n_profiles++] = GST_VAAPI_PROFILE_H265_MAIN10; break; default: break; } *n_profiles_ptr = n_profiles; } static GstVaapiProfile get_profile (GstVaapiDecoderH265 * decoder, GstH265SPS * sps, guint dpb_size) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiDisplay *const display = GST_VAAPI_DECODER_DISPLAY (decoder); GstVaapiProfile profile, profiles[3]; guint i, n_profiles = 0; profile = gst_vaapi_utils_h265_get_profile (sps); if (!profile) { /* HACK: This is a work-around to identify some main profile streams having wrong profile_idc. * There are some wrongly encoded main profile streams(eg: ENTP_C_LG_3.bin) which doesn't * have any of the profile_idc values mentioned in Annex-A, instead general_profile_idc * has been set as zero and having general_profile_compatibility_flag[general_profile_idc] * is TRUE. Assuming them as MAIN profile for now */ if (sps->profile_tier_level.profile_space == 0 && sps->profile_tier_level.profile_idc == 0 && sps->profile_tier_level.profile_compatibility_flag[0] == 1) { GST_WARNING ("Wrong profile_idc, blindly setting it as main profile !!"); profile = GST_VAAPI_PROFILE_H265_MAIN; } else return GST_VAAPI_PROFILE_UNKNOWN; } fill_profiles (profiles, &n_profiles, profile); switch (profile) { case GST_VAAPI_PROFILE_H265_MAIN10: if (sps->profile_tier_level.profile_compatibility_flag[1]) { // A.2.3.2 (main profile) fill_profiles (profiles, &n_profiles, GST_VAAPI_PROFILE_H265_MAIN); } break; default: break; } /* If the preferred profile (profiles[0]) matches one that we already found, then just return it now instead of searching for it again */ if (profiles[0] == priv->profile) return priv->profile; for (i = 0; i < n_profiles; i++) { if (gst_vaapi_display_has_decoder (display, profiles[i], priv->entrypoint)) return profiles[i]; } return GST_VAAPI_PROFILE_UNKNOWN; } static GstVaapiDecoderStatus ensure_context (GstVaapiDecoderH265 * decoder, GstH265SPS * sps) { GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER_CAST (decoder); GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiContextInfo info; GstVaapiProfile profile; GstVaapiChromaType chroma_type; gboolean reset_context = FALSE; guint dpb_size; dpb_size = get_max_dec_frame_buffering (sps); if (priv->dpb_size < dpb_size) { GST_DEBUG ("DPB size increased"); reset_context = TRUE; } profile = get_profile (decoder, sps, dpb_size); if (!profile) { GST_ERROR ("unsupported profile_idc %u", sps->profile_tier_level.profile_idc); return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE; } if (!priv->profile || (priv->profile != profile)) { GST_DEBUG ("profile changed"); reset_context = TRUE; priv->profile = profile; } chroma_type = gst_vaapi_utils_h265_get_chroma_type (sps->chroma_format_idc, sps->bit_depth_luma_minus8 + 8, sps->bit_depth_chroma_minus8 + 8); if (!chroma_type) { GST_ERROR ("unsupported chroma_format_idc %u", sps->chroma_format_idc); return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CHROMA_FORMAT; } if (priv->chroma_type != chroma_type) { GST_DEBUG ("chroma format changed"); reset_context = TRUE; priv->chroma_type = chroma_type; } if (priv->pic_width_in_luma_samples != sps->pic_width_in_luma_samples || priv->pic_height_in_luma_samples != sps->pic_height_in_luma_samples) { GST_DEBUG ("size changed"); reset_context = TRUE; priv->pic_width_in_luma_samples = sps->pic_width_in_luma_samples; priv->pic_height_in_luma_samples = sps->pic_height_in_luma_samples; } priv->progressive_sequence = 1; /* FIXME */ gst_vaapi_decoder_set_interlaced (base_decoder, !priv->progressive_sequence); gst_vaapi_decoder_set_pixel_aspect_ratio (base_decoder, sps->vui_params.par_n, sps->vui_params.par_d); if (!reset_context && priv->has_context) return GST_VAAPI_DECODER_STATUS_SUCCESS; /* XXX: fix surface size when cropping is implemented */ info.profile = priv->profile; info.entrypoint = priv->entrypoint; info.chroma_type = priv->chroma_type; info.width = sps->width; info.height = sps->height; info.ref_frames = dpb_size; if (!gst_vaapi_decoder_ensure_context (GST_VAAPI_DECODER (decoder), &info)) return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; priv->has_context = TRUE; /* Reset DPB */ if (!dpb_reset (decoder, dpb_size)) return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED; return GST_VAAPI_DECODER_STATUS_SUCCESS; } static void fill_iq_matrix_4x4 (VAIQMatrixBufferHEVC * iq_matrix, GstH265ScalingList * scaling_list) { guint i; g_assert (G_N_ELEMENTS (iq_matrix->ScalingList4x4) == 6); g_assert (G_N_ELEMENTS (iq_matrix->ScalingList4x4[0]) == 16); 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]); } } static void fill_iq_matrix_8x8 (VAIQMatrixBufferHEVC * iq_matrix, GstH265ScalingList * scaling_list) { guint i; g_assert (G_N_ELEMENTS (iq_matrix->ScalingList8x8) == 6); g_assert (G_N_ELEMENTS (iq_matrix->ScalingList8x8[0]) == 64); 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]); } } static void fill_iq_matrix_16x16 (VAIQMatrixBufferHEVC * iq_matrix, GstH265ScalingList * scaling_list) { guint i; g_assert (G_N_ELEMENTS (iq_matrix->ScalingList16x16) == 6); g_assert (G_N_ELEMENTS (iq_matrix->ScalingList16x16[0]) == 64); 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]); } } static void fill_iq_matrix_32x32 (VAIQMatrixBufferHEVC * iq_matrix, GstH265ScalingList * scaling_list) { guint i; g_assert (G_N_ELEMENTS (iq_matrix->ScalingList32x32) == 2); g_assert (G_N_ELEMENTS (iq_matrix->ScalingList32x32[0]) == 64); 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]); } } static void fill_iq_matrix_dc_16x16 (VAIQMatrixBufferHEVC * iq_matrix, GstH265ScalingList * scaling_list) { guint i; for (i = 0; i < 6; i++) iq_matrix->ScalingListDC16x16[i] = scaling_list->scaling_list_dc_coef_minus8_16x16[i] + 8; } static void fill_iq_matrix_dc_32x32 (VAIQMatrixBufferHEVC * iq_matrix, GstH265ScalingList * scaling_list) { guint i; for (i = 0; i < 2; i++) iq_matrix->ScalingListDC32x32[i] = scaling_list->scaling_list_dc_coef_minus8_32x32[i] + 8; } static GstVaapiDecoderStatus ensure_quant_matrix (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture) { GstVaapiPicture *const base_picture = &picture->base; GstH265PPS *const pps = get_pps (decoder); GstH265SPS *const sps = get_sps (decoder); GstH265ScalingList *scaling_list = NULL; VAIQMatrixBufferHEVC *iq_matrix; if (pps && (pps->scaling_list_data_present_flag || (sps->scaling_list_enabled_flag && !sps->scaling_list_data_present_flag))) scaling_list = &pps->scaling_list; else if (sps && sps->scaling_list_enabled_flag && sps->scaling_list_data_present_flag) scaling_list = &sps->scaling_list; else return GST_VAAPI_DECODER_STATUS_SUCCESS; base_picture->iq_matrix = GST_VAAPI_IQ_MATRIX_NEW (HEVC, decoder); if (!base_picture->iq_matrix) { GST_ERROR ("failed to allocate IQ matrix"); return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED; } iq_matrix = base_picture->iq_matrix->param; fill_iq_matrix_4x4 (iq_matrix, scaling_list); fill_iq_matrix_8x8 (iq_matrix, scaling_list); fill_iq_matrix_16x16 (iq_matrix, scaling_list); fill_iq_matrix_32x32 (iq_matrix, scaling_list); fill_iq_matrix_dc_16x16 (iq_matrix, scaling_list); fill_iq_matrix_dc_32x32 (iq_matrix, scaling_list); return GST_VAAPI_DECODER_STATUS_SUCCESS; } static inline gboolean is_valid_state (guint state, guint ref_state) { return (state & ref_state) == ref_state; } static GstVaapiDecoderStatus decode_current_picture (GstVaapiDecoderH265 * decoder) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const sps_pi = decoder->priv.active_sps; GstVaapiPictureH265 *const picture = priv->current_picture; if (!is_valid_state (priv->decoder_state, GST_H265_VIDEO_STATE_VALID_PICTURE)) { goto drop_frame; } priv->decoder_state |= sps_pi->state; if (!(priv->decoder_state & GST_H265_VIDEO_STATE_GOT_I_FRAME)) { const GstH265PPS *pps = get_pps (decoder); /* 7.4.3.3.3: the picture is an IRAP picture, nuh_layer_id is equal to 0, and pps_curr_pic_ref_enabled_flag is equal to 0, slice_type shall be equal to 2(I Slice). And F.8.3.4: Decoding process for reference picture lists construction is invoked at the beginning of the decoding process for each P or B slice. so if pps_curr_pic_ref_enabled_flag is set, which means the picture can ref to itself, the IRAP picture may be set to P/B slice, in order to generate the ref lists. If the slice_type is I, no ref list will be constructed and no MV data for that slice according to the syntax. That kind of CVS may start with P/B slice, but in fact it is a intra frame. */ if (priv->decoder_state & GST_H265_VIDEO_STATE_GOT_P_SLICE && !pps->pps_scc_extension_params.pps_curr_pic_ref_enabled_flag) goto drop_frame; sps_pi->state |= GST_H265_VIDEO_STATE_GOT_I_FRAME; } priv->decoder_state = 0; /* FIXME: Use SEI header values */ priv->pic_structure = GST_VAAPI_PICTURE_STRUCTURE_FRAME; if (!picture) return GST_VAAPI_DECODER_STATUS_SUCCESS; if (!gst_vaapi_picture_decode (GST_VAAPI_PICTURE_CAST (picture))) goto error; if (!dpb_add (decoder, picture)) goto error; gst_vaapi_picture_replace (&priv->current_picture, NULL); return GST_VAAPI_DECODER_STATUS_SUCCESS; /* ERRORS */ error: { gst_vaapi_picture_replace (&priv->current_picture, NULL); return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; } drop_frame: { priv->decoder_state = 0; priv->pic_structure = GST_VAAPI_PICTURE_STRUCTURE_FRAME; return (GstVaapiDecoderStatus) GST_VAAPI_DECODER_STATUS_DROP_FRAME; } } static GstVaapiDecoderStatus parse_vps (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = unit->parsed_info; GstH265VPS *const vps = &pi->data.vps; GstH265ParserResult result; GST_DEBUG ("parse VPS"); priv->parser_state = 0; memset (vps, 0, sizeof (GstH265VPS)); result = gst_h265_parser_parse_vps (priv->parser, &pi->nalu, vps); if (result != GST_H265_PARSER_OK) return get_status (result); priv->parser_state |= GST_H265_VIDEO_STATE_GOT_VPS; return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus parse_sps (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = unit->parsed_info; GstH265SPS *const sps = &pi->data.sps; GstH265ParserResult result; GST_DEBUG ("parse SPS"); priv->parser_state = 0; memset (sps, 0, sizeof (GstH265SPS)); result = gst_h265_parser_parse_sps (priv->parser, &pi->nalu, sps, TRUE); if (result != GST_H265_PARSER_OK) return get_status (result); priv->parser_state |= GST_H265_VIDEO_STATE_GOT_SPS; return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus parse_pps (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = unit->parsed_info; GstH265PPS *const pps = &pi->data.pps; GstH265ParserResult result; guint col_width[19], row_height[21]; GST_DEBUG ("parse PPS"); priv->parser_state &= GST_H265_VIDEO_STATE_GOT_SPS; memset (col_width, 0, sizeof (col_width)); memset (row_height, 0, sizeof (row_height)); memset (pps, 0, sizeof (GstH265PPS)); result = gst_h265_parser_parse_pps (priv->parser, &pi->nalu, pps); if (result != GST_H265_PARSER_OK) return get_status (result); priv->parser_state |= GST_H265_VIDEO_STATE_GOT_PPS; return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus parse_sei (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = unit->parsed_info; GArray **const sei_ptr = &pi->data.sei; GstH265ParserResult result; GST_DEBUG ("parse SEI"); result = gst_h265_parser_parse_sei (priv->parser, &pi->nalu, sei_ptr); if (result != GST_H265_PARSER_OK) { GST_WARNING ("failed to parse SEI messages"); return get_status (result); } return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus parse_slice (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = unit->parsed_info; GstH265SliceHdr *const slice_hdr = &pi->data.slice_hdr; GstH265ParserResult result; GST_DEBUG ("parse slice"); priv->parser_state &= (GST_H265_VIDEO_STATE_GOT_SPS | GST_H265_VIDEO_STATE_GOT_PPS); slice_hdr->short_term_ref_pic_set_idx = 0; memset (slice_hdr, 0, sizeof (GstH265SliceHdr)); result = gst_h265_parser_parse_slice_hdr (priv->parser, &pi->nalu, slice_hdr); if (result != GST_H265_PARSER_OK) return get_status (result); priv->parser_state |= GST_H265_VIDEO_STATE_GOT_SLICE; return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus decode_vps (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = unit->parsed_info; GstH265VPS *const vps = &pi->data.vps; GST_DEBUG ("decode VPS"); gst_vaapi_parser_info_h265_replace (&priv->vps[vps->id], pi); return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus decode_sps (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = unit->parsed_info; GstH265SPS *const sps = &pi->data.sps; guint high_precision_offsets_enabled_flag = 0, bitdepthC = 0; GST_DEBUG ("decode SPS"); if (sps->max_latency_increase_plus1[sps->max_sub_layers_minus1]) priv->SpsMaxLatencyPictures = sps->max_num_reorder_pics[sps->max_sub_layers_minus1] + sps->max_latency_increase_plus1[sps->max_sub_layers_minus1] - 1; /* Calculate WpOffsetHalfRangeC: (7-34) * FIXME: We don't have parser API for sps_range_extension, so * assuming high_precision_offsets_enabled_flag as zero */ bitdepthC = sps->bit_depth_chroma_minus8 + 8; priv->WpOffsetHalfRangeC = 1 << (high_precision_offsets_enabled_flag ? (bitdepthC - 1) : 7); gst_vaapi_parser_info_h265_replace (&priv->sps[sps->id], pi); return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus decode_pps (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = unit->parsed_info; GstH265PPS *const pps = &pi->data.pps; GST_DEBUG ("decode PPS"); gst_vaapi_parser_info_h265_replace (&priv->pps[pps->id], pi); return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus decode_sei (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = unit->parsed_info; guint i; GST_DEBUG ("decode SEI messages"); for (i = 0; i < pi->data.sei->len; i++) { const GstH265SEIMessage *const sei = &g_array_index (pi->data.sei, GstH265SEIMessage, i); switch (sei->payloadType) { case GST_H265_SEI_PIC_TIMING:{ const GstH265PicTiming *const pic_timing = &sei->payload.pic_timing; priv->pic_structure = pic_timing->pic_struct; break; } default: break; } } return GST_VAAPI_DECODER_STATUS_SUCCESS; } static GstVaapiDecoderStatus decode_sequence_end (GstVaapiDecoderH265 * decoder) { GstVaapiDecoderStatus status; GstVaapiParserInfoH265 *const sps_pi = decoder->priv.active_sps; GST_DEBUG ("decode sequence-end"); /* Sequence ended, don't try to propagate "got I-frame" state beyond * this point */ if (sps_pi) sps_pi->state &= ~GST_H265_VIDEO_STATE_GOT_I_FRAME; status = decode_current_picture (decoder); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) return status; return GST_VAAPI_DECODER_STATUS_SUCCESS; } /* 8.3.1 - Decoding process for picture order count */ static void init_picture_poc (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture, GstVaapiParserInfoH265 * pi) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstH265SliceHdr *const slice_hdr = &pi->data.slice_hdr; GstH265SPS *const sps = get_sps (decoder); const gint32 MaxPicOrderCntLsb = 1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4); guint8 nal_type = pi->nalu.type; guint8 temporal_id = pi->nalu.temporal_id_plus1 - 1; GST_DEBUG ("decode PicOrderCntVal"); priv->prev_poc_lsb = priv->poc_lsb; priv->prev_poc_msb = priv->poc_msb; if (!(nal_is_irap (nal_type) && picture->NoRaslOutputFlag)) { priv->prev_poc_lsb = priv->prev_tid0pic_poc_lsb; priv->prev_poc_msb = priv->prev_tid0pic_poc_msb; } /* Finding PicOrderCntMsb */ if (nal_is_irap (nal_type) && picture->NoRaslOutputFlag) priv->poc_msb = 0; else { /* (8-1) */ if ((slice_hdr->pic_order_cnt_lsb < priv->prev_poc_lsb) && ((priv->prev_poc_lsb - slice_hdr->pic_order_cnt_lsb) >= (MaxPicOrderCntLsb / 2))) priv->poc_msb = priv->prev_poc_msb + MaxPicOrderCntLsb; else if ((slice_hdr->pic_order_cnt_lsb > priv->prev_poc_lsb) && ((slice_hdr->pic_order_cnt_lsb - priv->prev_poc_lsb) > (MaxPicOrderCntLsb / 2))) priv->poc_msb = priv->prev_poc_msb - MaxPicOrderCntLsb; else priv->poc_msb = priv->prev_poc_msb; } /* (8-2) */ priv->poc = picture->poc = priv->poc_msb + slice_hdr->pic_order_cnt_lsb; priv->poc_lsb = picture->poc_lsb = slice_hdr->pic_order_cnt_lsb; if (nal_is_idr (nal_type)) { picture->poc = 0; picture->poc_lsb = 0; priv->poc_lsb = 0; priv->poc_msb = 0; priv->prev_poc_lsb = 0; priv->prev_poc_msb = 0; priv->prev_tid0pic_poc_lsb = 0; priv->prev_tid0pic_poc_msb = 0; } picture->base.poc = picture->poc; GST_DEBUG ("PicOrderCntVal %d", picture->base.poc); if (!temporal_id && !nal_is_rasl (nal_type) && !nal_is_radl (nal_type) && nal_is_ref (nal_type)) { priv->prev_tid0pic_poc_lsb = slice_hdr->pic_order_cnt_lsb; priv->prev_tid0pic_poc_msb = priv->poc_msb; } } static void init_picture_refs (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture, GstH265SliceHdr * slice_hdr) { GstVaapiDecoderH265Private *const priv = &decoder->priv; guint32 NumRpsCurrTempList0 = 0, NumRpsCurrTempList1 = 0; GstVaapiPictureH265 *RefPicListTemp0[16] = { NULL, }; GstVaapiPictureH265 *RefPicListTemp1[16] = { NULL, }; guint i, rIdx = 0; guint num_ref_idx_l0_active_minus1 = 0; guint num_ref_idx_l1_active_minus1 = 0; GstH265RefPicListModification *ref_pic_list_modification; GstH265PPS *const pps = get_pps (decoder); guint type; memset (priv->RefPicList0, 0, sizeof (GstVaapiPictureH265 *) * 16); memset (priv->RefPicList1, 0, sizeof (GstVaapiPictureH265 *) * 16); priv->RefPicList0_count = priv->RefPicList1_count = 0; num_ref_idx_l0_active_minus1 = slice_hdr->num_ref_idx_l0_active_minus1; num_ref_idx_l1_active_minus1 = slice_hdr->num_ref_idx_l1_active_minus1; ref_pic_list_modification = &slice_hdr->ref_pic_list_modification; type = slice_hdr->type; /* decoding process for reference picture list construction needs to be * invoked only for P and B slice */ if (type == GST_H265_I_SLICE) return; NumRpsCurrTempList0 = MAX ((num_ref_idx_l0_active_minus1 + 1), priv->NumPocTotalCurr); NumRpsCurrTempList1 = MAX ((num_ref_idx_l1_active_minus1 + 1), priv->NumPocTotalCurr); /* (8-8) */ while (rIdx < NumRpsCurrTempList0) { for (i = 0; i < priv->NumPocStCurrBefore && rIdx < NumRpsCurrTempList0; rIdx++, i++) RefPicListTemp0[rIdx] = priv->RefPicSetStCurrBefore[i]; for (i = 0; i < priv->NumPocStCurrAfter && rIdx < NumRpsCurrTempList0; rIdx++, i++) RefPicListTemp0[rIdx] = priv->RefPicSetStCurrAfter[i]; for (i = 0; i < priv->NumPocLtCurr && rIdx < NumRpsCurrTempList0; rIdx++, i++) RefPicListTemp0[rIdx] = priv->RefPicSetLtCurr[i]; if (pps->pps_scc_extension_params.pps_curr_pic_ref_enabled_flag) RefPicListTemp0[rIdx++] = picture; } /* construct RefPicList0 (8-9) */ for (rIdx = 0; rIdx <= num_ref_idx_l0_active_minus1; rIdx++) priv->RefPicList0[rIdx] = ref_pic_list_modification->ref_pic_list_modification_flag_l0 ? RefPicListTemp0[ref_pic_list_modification->list_entry_l0[rIdx]] : RefPicListTemp0[rIdx]; if (pps->pps_scc_extension_params.pps_curr_pic_ref_enabled_flag && !ref_pic_list_modification->ref_pic_list_modification_flag_l0 && (NumRpsCurrTempList0 > num_ref_idx_l0_active_minus1 + 1)) priv->RefPicList0[rIdx++] = picture; priv->RefPicList0_count = rIdx; if (type == GST_H265_B_SLICE) { rIdx = 0; /* (8-10) */ while (rIdx < NumRpsCurrTempList1) { for (i = 0; i < priv->NumPocStCurrAfter && rIdx < NumRpsCurrTempList1; rIdx++, i++) RefPicListTemp1[rIdx] = priv->RefPicSetStCurrAfter[i]; for (i = 0; i < priv->NumPocStCurrBefore && rIdx < NumRpsCurrTempList1; rIdx++, i++) RefPicListTemp1[rIdx] = priv->RefPicSetStCurrBefore[i]; for (i = 0; i < priv->NumPocLtCurr && rIdx < NumRpsCurrTempList1; rIdx++, i++) RefPicListTemp1[rIdx] = priv->RefPicSetLtCurr[i]; if (pps->pps_scc_extension_params.pps_curr_pic_ref_enabled_flag) RefPicListTemp1[rIdx++] = picture; } /* construct RefPicList1 (8-10) */ for (rIdx = 0; rIdx <= num_ref_idx_l1_active_minus1; rIdx++) priv->RefPicList1[rIdx] = ref_pic_list_modification->ref_pic_list_modification_flag_l1 ? RefPicListTemp1[ref_pic_list_modification->list_entry_l1 [rIdx]] : RefPicListTemp1[rIdx]; priv->RefPicList1_count = rIdx; } } static gboolean init_picture (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture, GstVaapiParserInfoH265 * pi) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiPicture *const base_picture = &picture->base; GstH265SliceHdr *const slice_hdr = &pi->data.slice_hdr; base_picture->pts = GST_VAAPI_DECODER_CODEC_FRAME (decoder)->pts; base_picture->type = GST_VAAPI_PICTURE_TYPE_NONE; if (nal_is_idr (pi->nalu.type)) { GST_DEBUG (""); GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_IDR); } if (pi->nalu.type >= GST_H265_NAL_SLICE_BLA_W_LP && pi->nalu.type <= GST_H265_NAL_SLICE_CRA_NUT) picture->RapPicFlag = TRUE; /* FIXME: Use SEI header values */ base_picture->structure = GST_VAAPI_PICTURE_STRUCTURE_FRAME; picture->structure = base_picture->structure; /*NoRaslOutputFlag ==1 if the current picture is 1) an IDR picture 2) a BLA picture 3) a CRA picture that is the first access unit in the bitstream 4) first picture that follows an end of sequence NAL unit in decoding order 5) has HandleCraAsBlaFlag == 1 (set by external means, so not considering ) */ if (nal_is_idr (pi->nalu.type) || nal_is_bla (pi->nalu.type) || (nal_is_cra (pi->nalu.type) && priv->new_bitstream) || priv->prev_nal_is_eos) { picture->NoRaslOutputFlag = 1; } if (nal_is_irap (pi->nalu.type)) { picture->IntraPicFlag = TRUE; priv->associated_irap_NoRaslOutputFlag = picture->NoRaslOutputFlag; } if (nal_is_rasl (pi->nalu.type) && priv->associated_irap_NoRaslOutputFlag) picture->output_flag = FALSE; else picture->output_flag = slice_hdr->pic_output_flag; init_picture_poc (decoder, picture, pi); return TRUE; } static void vaapi_init_picture (VAPictureHEVC * pic) { pic->picture_id = VA_INVALID_SURFACE; pic->pic_order_cnt = 0; pic->flags = VA_PICTURE_HEVC_INVALID; } static void vaapi_fill_picture (VAPictureHEVC * pic, GstVaapiPictureH265 * picture, guint picture_structure) { if (!picture_structure) picture_structure = picture->structure; pic->picture_id = picture->base.surface_id; pic->pic_order_cnt = picture->poc; pic->flags = 0; /* Set the VAPictureHEVC flags */ if (GST_VAAPI_PICTURE_IS_LONG_TERM_REFERENCE (picture)) pic->flags |= VA_PICTURE_HEVC_LONG_TERM_REFERENCE; if (GST_VAAPI_PICTURE_FLAG_IS_SET (picture, GST_VAAPI_PICTURE_FLAG_RPS_ST_CURR_BEFORE)) pic->flags |= VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE; else if (GST_VAAPI_PICTURE_FLAG_IS_SET (picture, GST_VAAPI_PICTURE_FLAG_RPS_ST_CURR_AFTER)) pic->flags |= VA_PICTURE_HEVC_RPS_ST_CURR_AFTER; else if (GST_VAAPI_PICTURE_FLAG_IS_SET (picture, GST_VAAPI_PICTURE_FLAG_RPS_LT_CURR)) pic->flags |= VA_PICTURE_HEVC_RPS_LT_CURR; switch (picture_structure) { case GST_VAAPI_PICTURE_STRUCTURE_FRAME: break; case GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD: pic->flags |= VA_PICTURE_HEVC_FIELD_PIC; break; case GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD: pic->flags |= VA_PICTURE_HEVC_FIELD_PIC; pic->flags |= VA_PICTURE_HEVC_BOTTOM_FIELD; break; default: break; } } static guint get_index_for_RefPicListX (VAPictureHEVC * ReferenceFrames, GstVaapiPictureH265 * pic) { gint i; for (i = 0; i < 15; i++) { if ((ReferenceFrames[i].picture_id != VA_INVALID_ID) && pic) { if ((ReferenceFrames[i].pic_order_cnt == pic->poc) && (ReferenceFrames[i].picture_id == pic->base.surface_id)) { return i; } } } return 0xff; } static gboolean fill_picture (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiPicture *const base_picture = &picture->base; GstH265PPS *const pps = get_pps (decoder); GstH265SPS *const sps = get_sps (decoder); VAPictureParameterBufferHEVC *pic_param = base_picture->param; guint i, n; #if VA_CHECK_VERSION(1,2,0) VAPictureParameterBufferHEVCRext *pic_rext_param = NULL; VAPictureParameterBufferHEVCScc *pic_scc_param = NULL; if (is_range_extension_profile (priv->profile)) { VAPictureParameterBufferHEVCExtension *param = base_picture->param; pic_param = ¶m->base; pic_rext_param = ¶m->rext; } if (is_scc_profile (priv->profile)) { VAPictureParameterBufferHEVCExtension *param = base_picture->param; pic_param = ¶m->base; pic_rext_param = ¶m->rext; pic_scc_param = ¶m->scc; } #endif pic_param->pic_fields.value = 0; pic_param->slice_parsing_fields.value = 0; /* Fill in VAPictureHEVC */ vaapi_fill_picture (&pic_param->CurrPic, picture, 0); /* Fill in ReferenceFrames */ for (i = 0, n = 0; i < priv->dpb_count; i++) { GstVaapiFrameStore *const fs = priv->dpb[i]; if ((gst_vaapi_frame_store_has_reference (fs))) vaapi_fill_picture (&pic_param->ReferenceFrames[n++], fs->buffer, fs->buffer->structure); if (n >= G_N_ELEMENTS (pic_param->ReferenceFrames)) break; } /* 7.4.3.3.3, the current decoded picture is marked as "used for long-term reference", no matter TwoVersionsOfCurrDecPicFlag */ if (pps->pps_scc_extension_params.pps_curr_pic_ref_enabled_flag && n < G_N_ELEMENTS (pic_param->ReferenceFrames) - 1) { gst_vaapi_picture_h265_set_reference (picture, GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE); vaapi_fill_picture (&pic_param->ReferenceFrames[n++], picture, picture->structure); gst_vaapi_picture_h265_set_reference (picture, 0); } for (; n < G_N_ELEMENTS (pic_param->ReferenceFrames); n++) vaapi_init_picture (&pic_param->ReferenceFrames[n]); #define COPY_FIELD(s, f) \ pic_param->f = (s)->f #define COPY_BFM(a, s, f) \ pic_param->a.bits.f = (s)->f COPY_FIELD (sps, pic_width_in_luma_samples); COPY_FIELD (sps, pic_height_in_luma_samples); COPY_BFM (pic_fields, sps, chroma_format_idc); COPY_BFM (pic_fields, sps, separate_colour_plane_flag); COPY_BFM (pic_fields, sps, pcm_enabled_flag); COPY_BFM (pic_fields, sps, scaling_list_enabled_flag); COPY_BFM (pic_fields, pps, transform_skip_enabled_flag); COPY_BFM (pic_fields, sps, amp_enabled_flag); COPY_BFM (pic_fields, sps, strong_intra_smoothing_enabled_flag); COPY_BFM (pic_fields, pps, sign_data_hiding_enabled_flag); COPY_BFM (pic_fields, pps, constrained_intra_pred_flag); COPY_BFM (pic_fields, pps, cu_qp_delta_enabled_flag); COPY_BFM (pic_fields, pps, weighted_pred_flag); COPY_BFM (pic_fields, pps, weighted_bipred_flag); COPY_BFM (pic_fields, pps, transquant_bypass_enabled_flag); COPY_BFM (pic_fields, pps, tiles_enabled_flag); COPY_BFM (pic_fields, pps, entropy_coding_sync_enabled_flag); pic_param->pic_fields.bits.pps_loop_filter_across_slices_enabled_flag = pps->loop_filter_across_slices_enabled_flag; COPY_BFM (pic_fields, pps, loop_filter_across_tiles_enabled_flag); COPY_BFM (pic_fields, sps, pcm_loop_filter_disabled_flag); /* Fix: Assign value based on sps_max_num_reorder_pics */ pic_param->pic_fields.bits.NoPicReorderingFlag = 0; /* Fix: Enable if picture has no B slices */ pic_param->pic_fields.bits.NoBiPredFlag = 0; pic_param->sps_max_dec_pic_buffering_minus1 = sps->max_dec_pic_buffering_minus1[0]; COPY_FIELD (sps, bit_depth_luma_minus8); COPY_FIELD (sps, bit_depth_chroma_minus8); COPY_FIELD (sps, pcm_sample_bit_depth_luma_minus1); COPY_FIELD (sps, pcm_sample_bit_depth_chroma_minus1); COPY_FIELD (sps, log2_min_luma_coding_block_size_minus3); COPY_FIELD (sps, log2_diff_max_min_luma_coding_block_size); COPY_FIELD (sps, log2_min_transform_block_size_minus2); COPY_FIELD (sps, log2_diff_max_min_transform_block_size); COPY_FIELD (sps, log2_min_pcm_luma_coding_block_size_minus3); COPY_FIELD (sps, log2_diff_max_min_pcm_luma_coding_block_size); COPY_FIELD (sps, max_transform_hierarchy_depth_intra); COPY_FIELD (sps, max_transform_hierarchy_depth_inter); COPY_FIELD (pps, init_qp_minus26); COPY_FIELD (pps, diff_cu_qp_delta_depth); pic_param->pps_cb_qp_offset = pps->cb_qp_offset; pic_param->pps_cr_qp_offset = pps->cr_qp_offset; COPY_FIELD (pps, log2_parallel_merge_level_minus2); COPY_FIELD (pps, num_tile_columns_minus1); COPY_FIELD (pps, num_tile_rows_minus1); for (i = 0; i <= pps->num_tile_columns_minus1; i++) pic_param->column_width_minus1[i] = pps->column_width_minus1[i]; for (; i < 19; i++) pic_param->column_width_minus1[i] = 0; for (i = 0; i <= pps->num_tile_rows_minus1; i++) pic_param->row_height_minus1[i] = pps->row_height_minus1[i]; for (; i < 21; i++) pic_param->row_height_minus1[i] = 0; COPY_BFM (slice_parsing_fields, pps, lists_modification_present_flag); COPY_BFM (slice_parsing_fields, sps, long_term_ref_pics_present_flag); pic_param->slice_parsing_fields.bits.sps_temporal_mvp_enabled_flag = sps->temporal_mvp_enabled_flag; COPY_BFM (slice_parsing_fields, pps, cabac_init_present_flag); COPY_BFM (slice_parsing_fields, pps, output_flag_present_flag); COPY_BFM (slice_parsing_fields, pps, dependent_slice_segments_enabled_flag); pic_param->slice_parsing_fields.bits. pps_slice_chroma_qp_offsets_present_flag = pps->slice_chroma_qp_offsets_present_flag; COPY_BFM (slice_parsing_fields, sps, sample_adaptive_offset_enabled_flag); COPY_BFM (slice_parsing_fields, pps, deblocking_filter_override_enabled_flag); pic_param->slice_parsing_fields.bits.pps_disable_deblocking_filter_flag = pps->deblocking_filter_disabled_flag; COPY_BFM (slice_parsing_fields, pps, slice_segment_header_extension_present_flag); pic_param->slice_parsing_fields.bits.RapPicFlag = picture->RapPicFlag; pic_param->slice_parsing_fields.bits.IdrPicFlag = GST_VAAPI_PICTURE_FLAG_IS_SET (picture, GST_VAAPI_PICTURE_FLAG_IDR); pic_param->slice_parsing_fields.bits.IntraPicFlag = picture->IntraPicFlag; COPY_FIELD (sps, log2_max_pic_order_cnt_lsb_minus4); COPY_FIELD (sps, num_short_term_ref_pic_sets); pic_param->num_long_term_ref_pic_sps = sps->num_long_term_ref_pics_sps; COPY_FIELD (pps, num_ref_idx_l0_default_active_minus1); COPY_FIELD (pps, num_ref_idx_l1_default_active_minus1); pic_param->pps_beta_offset_div2 = pps->beta_offset_div2; pic_param->pps_tc_offset_div2 = pps->tc_offset_div2; COPY_FIELD (pps, num_extra_slice_header_bits); /* FIXME: Set correct value as mentioned in va_dec_hevc.h */ pic_param->st_rps_bits = 0; #if VA_CHECK_VERSION(1,2,0) if (pic_rext_param) { pic_rext_param->range_extension_pic_fields.value = 0; #define COPY_REXT_FIELD(s, f) \ pic_rext_param->f = s.f #define COPY_REXT_BFM(a, s, f) \ pic_rext_param->a.bits.f = s.f COPY_REXT_BFM (range_extension_pic_fields, sps->sps_extnsion_params, transform_skip_rotation_enabled_flag); COPY_REXT_BFM (range_extension_pic_fields, sps->sps_extnsion_params, transform_skip_context_enabled_flag); COPY_REXT_BFM (range_extension_pic_fields, sps->sps_extnsion_params, implicit_rdpcm_enabled_flag); COPY_REXT_BFM (range_extension_pic_fields, sps->sps_extnsion_params, explicit_rdpcm_enabled_flag); COPY_REXT_BFM (range_extension_pic_fields, sps->sps_extnsion_params, extended_precision_processing_flag); COPY_REXT_BFM (range_extension_pic_fields, sps->sps_extnsion_params, intra_smoothing_disabled_flag); COPY_REXT_BFM (range_extension_pic_fields, sps->sps_extnsion_params, high_precision_offsets_enabled_flag); COPY_REXT_BFM (range_extension_pic_fields, sps->sps_extnsion_params, persistent_rice_adaptation_enabled_flag); COPY_REXT_BFM (range_extension_pic_fields, sps->sps_extnsion_params, cabac_bypass_alignment_enabled_flag); COPY_REXT_BFM (range_extension_pic_fields, pps->pps_extension_params, cross_component_prediction_enabled_flag); COPY_REXT_BFM (range_extension_pic_fields, pps->pps_extension_params, chroma_qp_offset_list_enabled_flag); COPY_REXT_FIELD (pps->pps_extension_params, diff_cu_chroma_qp_offset_depth); COPY_REXT_FIELD (pps->pps_extension_params, chroma_qp_offset_list_len_minus1); COPY_REXT_FIELD (pps->pps_extension_params, log2_sao_offset_scale_luma); COPY_REXT_FIELD (pps->pps_extension_params, log2_sao_offset_scale_chroma); COPY_REXT_FIELD (pps->pps_extension_params, log2_max_transform_skip_block_size_minus2); memcpy (pic_rext_param->cb_qp_offset_list, pps->pps_extension_params.cb_qp_offset_list, sizeof (pic_rext_param->cb_qp_offset_list)); memcpy (pic_rext_param->cr_qp_offset_list, pps->pps_extension_params.cr_qp_offset_list, sizeof (pic_rext_param->cr_qp_offset_list)); } if (pic_scc_param) { #define COPY_SCC_FIELD(s, f) \ pic_scc_param->f = s->f #define COPY_SCC_BFM(a, s, f) \ pic_scc_param->a.bits.f = s->f const GstH265PPSSccExtensionParams *pps_scc = &pps->pps_scc_extension_params; const GstH265SPSSccExtensionParams *sps_scc = &sps->sps_scc_extension_params; guint32 num_comps; pic_scc_param->screen_content_pic_fields.value = 0; COPY_SCC_BFM (screen_content_pic_fields, pps_scc, pps_curr_pic_ref_enabled_flag); COPY_SCC_BFM (screen_content_pic_fields, sps_scc, palette_mode_enabled_flag); COPY_SCC_BFM (screen_content_pic_fields, sps_scc, motion_vector_resolution_control_idc); COPY_SCC_BFM (screen_content_pic_fields, sps_scc, intra_boundary_filtering_disabled_flag); COPY_SCC_BFM (screen_content_pic_fields, pps_scc, residual_adaptive_colour_transform_enabled_flag); COPY_SCC_BFM (screen_content_pic_fields, pps_scc, pps_slice_act_qp_offsets_present_flag); COPY_SCC_FIELD (sps_scc, palette_max_size); COPY_SCC_FIELD (sps_scc, delta_palette_max_predictor_size); COPY_SCC_FIELD (pps_scc, pps_act_y_qp_offset_plus5); COPY_SCC_FIELD (pps_scc, pps_act_cb_qp_offset_plus5); COPY_SCC_FIELD (pps_scc, pps_act_cr_qp_offset_plus3); /* firstly use the pps, then sps */ num_comps = sps->chroma_format_idc ? 3 : 1; if (pps_scc->pps_palette_predictor_initializers_present_flag) { for (n = 0; n < num_comps; n++) for (i = 0; i < pps_scc->pps_num_palette_predictor_initializer; i++) pic_scc_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) { for (n = 0; n < num_comps; n++) for (i = 0; i < sps_scc->sps_num_palette_predictor_initializer_minus1 + 1; i++) pic_scc_param->predictor_palette_entries[n][i] = (uint16_t) sps_scc->sps_palette_predictor_initializer[n][i]; } } #endif return TRUE; } /* Detection of the first VCL NAL unit of a coded picture (7.4.2.4.5 ) */ static gboolean is_new_picture (GstVaapiParserInfoH265 * pi, GstVaapiParserInfoH265 * prev_pi) { GstH265SliceHdr *const slice_hdr = &pi->data.slice_hdr; if (!prev_pi) return TRUE; if (slice_hdr->first_slice_segment_in_pic_flag) return TRUE; return FALSE; } /* Detection of a new access unit, assuming we are already in presence of a new picture */ static inline gboolean is_new_access_unit (GstVaapiParserInfoH265 * pi, GstVaapiParserInfoH265 * prev_pi) { if (!prev_pi) return TRUE; return FALSE; } static gboolean has_entry_in_rps (GstVaapiPictureH265 * dpb_pic, GstVaapiPictureH265 ** rps_list, guint rps_list_length) { guint i; if (!dpb_pic || !rps_list || !rps_list_length) return FALSE; for (i = 0; i < rps_list_length; i++) { if (rps_list[i] && rps_list[i]->poc == dpb_pic->poc) return TRUE; } return FALSE; } /* the derivation process for the RPS and the picture marking */ static void derive_and_mark_rps (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture, GstVaapiParserInfoH265 * pi, gint32 * CurrDeltaPocMsbPresentFlag, gint32 * FollDeltaPocMsbPresentFlag) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiPictureH265 *dpb_pic = NULL; guint i; memset (priv->RefPicSetLtCurr, 0, sizeof (GstVaapiPictureH265 *) * 16); memset (priv->RefPicSetLtFoll, 0, sizeof (GstVaapiPictureH265 *) * 16); memset (priv->RefPicSetStCurrBefore, 0, sizeof (GstVaapiPictureH265 *) * 16); memset (priv->RefPicSetStCurrAfter, 0, sizeof (GstVaapiPictureH265 *) * 16); memset (priv->RefPicSetStFoll, 0, sizeof (GstVaapiPictureH265 *) * 16); /* (8-6) */ for (i = 0; i < priv->NumPocLtCurr; i++) { if (!CurrDeltaPocMsbPresentFlag[i]) { dpb_pic = dpb_get_picture (decoder, priv->PocLtCurr[i], TRUE); if (dpb_pic) priv->RefPicSetLtCurr[i] = dpb_pic; else priv->RefPicSetLtCurr[i] = NULL; } else { dpb_pic = dpb_get_picture (decoder, priv->PocLtCurr[i], FALSE); if (dpb_pic) priv->RefPicSetLtCurr[i] = dpb_pic; else priv->RefPicSetLtCurr[i] = NULL; } } for (; i < 16; i++) priv->RefPicSetLtCurr[i] = NULL; for (i = 0; i < priv->NumPocLtFoll; i++) { if (!FollDeltaPocMsbPresentFlag[i]) { dpb_pic = dpb_get_picture (decoder, priv->PocLtFoll[i], TRUE); if (dpb_pic) priv->RefPicSetLtFoll[i] = dpb_pic; else priv->RefPicSetLtFoll[i] = NULL; } else { dpb_pic = dpb_get_picture (decoder, priv->PocLtFoll[i], FALSE); if (dpb_pic) priv->RefPicSetLtFoll[i] = dpb_pic; else priv->RefPicSetLtFoll[i] = NULL; } } for (; i < 16; i++) priv->RefPicSetLtFoll[i] = NULL; /* Mark all ref pics in RefPicSetLtCurr and RefPicSetLtFol as long_term_refs */ for (i = 0; i < priv->NumPocLtCurr; i++) { if (priv->RefPicSetLtCurr[i]) gst_vaapi_picture_h265_set_reference (priv->RefPicSetLtCurr[i], GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE | GST_VAAPI_PICTURE_FLAG_RPS_LT_CURR); } for (i = 0; i < priv->NumPocLtFoll; i++) { if (priv->RefPicSetLtFoll[i]) gst_vaapi_picture_h265_set_reference (priv->RefPicSetLtFoll[i], GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE | GST_VAAPI_PICTURE_FLAG_RPS_LT_FOLL); } /* (8-7) */ for (i = 0; i < priv->NumPocStCurrBefore; i++) { dpb_pic = dpb_get_ref_picture (decoder, priv->PocStCurrBefore[i], TRUE); if (dpb_pic) { gst_vaapi_picture_h265_set_reference (dpb_pic, GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE | GST_VAAPI_PICTURE_FLAG_RPS_ST_CURR_BEFORE); priv->RefPicSetStCurrBefore[i] = dpb_pic; } else priv->RefPicSetStCurrBefore[i] = NULL; } for (; i < 16; i++) priv->RefPicSetStCurrBefore[i] = NULL; for (i = 0; i < priv->NumPocStCurrAfter; i++) { dpb_pic = dpb_get_ref_picture (decoder, priv->PocStCurrAfter[i], TRUE); if (dpb_pic) { gst_vaapi_picture_h265_set_reference (dpb_pic, GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE | GST_VAAPI_PICTURE_FLAG_RPS_ST_CURR_AFTER); priv->RefPicSetStCurrAfter[i] = dpb_pic; } else priv->RefPicSetStCurrAfter[i] = NULL; } for (; i < 16; i++) priv->RefPicSetStCurrAfter[i] = NULL; for (i = 0; i < priv->NumPocStFoll; i++) { dpb_pic = dpb_get_ref_picture (decoder, priv->PocStFoll[i], TRUE); if (dpb_pic) { gst_vaapi_picture_h265_set_reference (dpb_pic, GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE | GST_VAAPI_PICTURE_FLAG_RPS_ST_FOLL); priv->RefPicSetStFoll[i] = dpb_pic; } else priv->RefPicSetStFoll[i] = NULL; } for (; i < 16; i++) priv->RefPicSetStFoll[i] = NULL; /* Mark all dpb pics not beloging to RefPicSet*[] as unused for ref */ for (i = 0; i < priv->dpb_count; i++) { dpb_pic = priv->dpb[i]->buffer; if (dpb_pic && !has_entry_in_rps (dpb_pic, priv->RefPicSetLtCurr, priv->NumPocLtCurr) && !has_entry_in_rps (dpb_pic, priv->RefPicSetLtFoll, priv->NumPocLtFoll) && !has_entry_in_rps (dpb_pic, priv->RefPicSetStCurrAfter, priv->NumPocStCurrAfter) && !has_entry_in_rps (dpb_pic, priv->RefPicSetStCurrBefore, priv->NumPocStCurrBefore) && !has_entry_in_rps (dpb_pic, priv->RefPicSetStFoll, priv->NumPocStFoll)) gst_vaapi_picture_h265_set_reference (dpb_pic, 0); } } /* Decoding process for reference picture set (8.3.2) */ static gboolean decode_ref_pic_set (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture, GstVaapiParserInfoH265 * pi) { guint i, j, k; gint32 CurrDeltaPocMsbPresentFlag[16] = { 0, }; gint32 FollDeltaPocMsbPresentFlag[16] = { 0, }; GstVaapiDecoderH265Private *const priv = &decoder->priv; GstH265SliceHdr *const slice_hdr = &pi->data.slice_hdr; GstH265SPS *const sps = get_sps (decoder); GstH265PPS *const pps = get_pps (decoder); const gint32 MaxPicOrderCntLsb = 1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4); /* if it is an irap pic, set all ref pics in dpb as unused for ref */ if (nal_is_irap (pi->nalu.type) && picture->NoRaslOutputFlag) { for (i = 0; i < priv->dpb_count; i++) { GstVaapiFrameStore *const fs = priv->dpb[i]; gst_vaapi_picture_h265_set_reference (fs->buffer, 0); } } /* Reset everything for IDR */ if (nal_is_idr (pi->nalu.type)) { memset (priv->PocStCurrBefore, 0, sizeof (guint) * 16); memset (priv->PocStCurrAfter, 0, sizeof (guint) * 16); memset (priv->PocStFoll, 0, sizeof (guint) * 16); memset (priv->PocLtCurr, 0, sizeof (guint) * 16); memset (priv->PocLtFoll, 0, sizeof (guint) * 16); priv->NumPocStCurrBefore = priv->NumPocStCurrAfter = priv->NumPocStFoll = 0; priv->NumPocLtCurr = priv->NumPocLtFoll = 0; priv->NumPocTotalCurr = 0; } else { GstH265ShortTermRefPicSet *stRefPic = NULL; gint32 num_lt_pics, pocLt; gint32 PocLsbLt[16] = { 0, }; gint32 UsedByCurrPicLt[16] = { 0, }; gint32 DeltaPocMsbCycleLt[16] = { 0, }; gint numtotalcurr = 0; /* this is based on CurrRpsIdx described in spec */ if (!slice_hdr->short_term_ref_pic_set_sps_flag) stRefPic = &slice_hdr->short_term_ref_pic_sets; else if (sps->num_short_term_ref_pic_sets) stRefPic = &sps->short_term_ref_pic_set[slice_hdr->short_term_ref_pic_set_idx]; g_assert (stRefPic != NULL); for (i = 0, j = 0, k = 0; i < stRefPic->NumNegativePics; i++) { if (stRefPic->UsedByCurrPicS0[i]) { priv->PocStCurrBefore[j++] = picture->poc + stRefPic->DeltaPocS0[i]; numtotalcurr++; } else priv->PocStFoll[k++] = picture->poc + stRefPic->DeltaPocS0[i]; } priv->NumPocStCurrBefore = j; for (i = 0, j = 0; i < stRefPic->NumPositivePics; i++) { if (stRefPic->UsedByCurrPicS1[i]) { priv->PocStCurrAfter[j++] = picture->poc + stRefPic->DeltaPocS1[i]; numtotalcurr++; } else priv->PocStFoll[k++] = picture->poc + stRefPic->DeltaPocS1[i]; } priv->NumPocStCurrAfter = j; priv->NumPocStFoll = k; num_lt_pics = slice_hdr->num_long_term_sps + slice_hdr->num_long_term_pics; /* The variables PocLsbLt[i] and UsedByCurrPicLt[i] are derived as follows: */ for (i = 0; i < num_lt_pics; i++) { if (i < slice_hdr->num_long_term_sps) { PocLsbLt[i] = sps->lt_ref_pic_poc_lsb_sps[slice_hdr->lt_idx_sps[i]]; UsedByCurrPicLt[i] = sps->used_by_curr_pic_lt_sps_flag[slice_hdr->lt_idx_sps[i]]; } else { PocLsbLt[i] = slice_hdr->poc_lsb_lt[i]; UsedByCurrPicLt[i] = slice_hdr->used_by_curr_pic_lt_flag[i]; } if (UsedByCurrPicLt[i]) numtotalcurr++; } if (pps->pps_scc_extension_params.pps_curr_pic_ref_enabled_flag) numtotalcurr++; priv->NumPocTotalCurr = numtotalcurr; /* The variable DeltaPocMsbCycleLt[i] is derived as follows: (7-38) */ for (i = 0; i < num_lt_pics; i++) { if (i == 0 || i == slice_hdr->num_long_term_sps) DeltaPocMsbCycleLt[i] = slice_hdr->delta_poc_msb_cycle_lt[i]; else DeltaPocMsbCycleLt[i] = slice_hdr->delta_poc_msb_cycle_lt[i] + DeltaPocMsbCycleLt[i - 1]; } /* (8-5) */ for (i = 0, j = 0, k = 0; i < num_lt_pics; i++) { pocLt = PocLsbLt[i]; if (slice_hdr->delta_poc_msb_present_flag[i]) pocLt += picture->poc - DeltaPocMsbCycleLt[i] * MaxPicOrderCntLsb - slice_hdr->pic_order_cnt_lsb; if (UsedByCurrPicLt[i]) { priv->PocLtCurr[j] = pocLt; CurrDeltaPocMsbPresentFlag[j++] = slice_hdr->delta_poc_msb_present_flag[i]; } else { priv->PocLtFoll[k] = pocLt; FollDeltaPocMsbPresentFlag[k++] = slice_hdr->delta_poc_msb_present_flag[i]; } } priv->NumPocLtCurr = j; priv->NumPocLtFoll = k; } /* the derivation process for the RPS and the picture marking */ derive_and_mark_rps (decoder, picture, pi, CurrDeltaPocMsbPresentFlag, FollDeltaPocMsbPresentFlag); return TRUE; } static GstVaapiDecoderStatus decode_picture (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *pi = unit->parsed_info; GstH265SliceHdr *const slice_hdr = &pi->data.slice_hdr; GstH265PPS *const pps = ensure_pps (decoder, slice_hdr->pps); GstH265SPS *const sps = ensure_sps (decoder, slice_hdr->pps->sps); GstVaapiPictureH265 *picture; GstVaapiDecoderStatus status; if (!(pps && sps)) return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; status = ensure_context (decoder, sps); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) return status; priv->decoder_state = 0; /* Create new picture */ picture = gst_vaapi_picture_h265_new (decoder); if (!picture) { GST_ERROR ("failed to allocate picture"); return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED; } gst_vaapi_picture_replace (&priv->current_picture, picture); gst_vaapi_picture_unref (picture); /* Update cropping rectangle */ if (sps->conformance_window_flag) { GstVaapiRectangle crop_rect; crop_rect.x = sps->crop_rect_x; crop_rect.y = sps->crop_rect_y; crop_rect.width = sps->crop_rect_width; crop_rect.height = sps->crop_rect_height; gst_vaapi_picture_set_crop_rect (&picture->base, &crop_rect); } status = ensure_quant_matrix (decoder, picture); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) { GST_ERROR ("failed to reset quantizer matrix"); return status; } if (!init_picture (decoder, picture, pi)) return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; /* Drop all RASL pictures having NoRaslOutputFlag is TRUE for the * associated IRAP picture */ if (nal_is_rasl (pi->nalu.type) && priv->associated_irap_NoRaslOutputFlag) { gst_vaapi_picture_replace (&priv->current_picture, NULL); return (GstVaapiDecoderStatus) GST_VAAPI_DECODER_STATUS_DROP_FRAME; } if (!decode_ref_pic_set (decoder, picture, pi)) return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; if (!dpb_init (decoder, picture, pi)) return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; if (!fill_picture (decoder, picture)) return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; priv->decoder_state = pi->state; return GST_VAAPI_DECODER_STATUS_SUCCESS; } 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 fill_pred_weight_table (GstVaapiDecoderH265 * decoder, GstVaapiSlice * slice, GstH265SliceHdr * slice_hdr) { GstVaapiDecoderH265Private *const priv = &decoder->priv; VASliceParameterBufferHEVC *slice_param = slice->param; GstH265PPS *const pps = get_pps (decoder); GstH265SPS *const sps = get_sps (decoder); GstH265PredWeightTable *const w = &slice_hdr->pred_weight_table; gint chroma_weight, chroma_log2_weight_denom; gint i, j; #if VA_CHECK_VERSION(1,2,0) VASliceParameterBufferHEVCRext *slice_rext_param = NULL; if (is_range_extension_profile (priv->profile)) { VASliceParameterBufferHEVCExtension *param = slice->param; slice_param = ¶m->base; slice_rext_param = ¶m->rext; } #endif slice_param->luma_log2_weight_denom = 0; slice_param->delta_chroma_log2_weight_denom = 0; if ((pps->weighted_pred_flag && GST_H265_IS_P_SLICE (slice_hdr)) || (pps->weighted_bipred_flag && GST_H265_IS_B_SLICE (slice_hdr))) { /* FIXME: This should be done in parser apis */ memset (slice_param->delta_luma_weight_l0, 0, sizeof (slice_param->delta_luma_weight_l0)); memset (slice_param->luma_offset_l0, 0, sizeof (slice_param->luma_offset_l0)); memset (slice_param->delta_luma_weight_l1, 0, sizeof (slice_param->delta_luma_weight_l1)); memset (slice_param->luma_offset_l1, 0, sizeof (slice_param->luma_offset_l1)); memset (slice_param->delta_chroma_weight_l0, 0, sizeof (slice_param->delta_chroma_weight_l0)); memset (slice_param->ChromaOffsetL0, 0, sizeof (slice_param->ChromaOffsetL0)); memset (slice_param->delta_chroma_weight_l1, 0, sizeof (slice_param->delta_chroma_weight_l1)); memset (slice_param->ChromaOffsetL1, 0, sizeof (slice_param->ChromaOffsetL1)); #if VA_CHECK_VERSION(1,2,0) if (slice_rext_param) { memset (slice_rext_param->luma_offset_l0, 0, sizeof (slice_rext_param->luma_offset_l0)); memset (slice_rext_param->luma_offset_l1, 0, sizeof (slice_rext_param->luma_offset_l1)); memset (slice_rext_param->ChromaOffsetL0, 0, sizeof (slice_rext_param->ChromaOffsetL0)); memset (slice_rext_param->ChromaOffsetL1, 0, sizeof (slice_rext_param->ChromaOffsetL1)); } #endif slice_param->luma_log2_weight_denom = w->luma_log2_weight_denom; if (sps->chroma_array_type != 0) slice_param->delta_chroma_log2_weight_denom = w->delta_chroma_log2_weight_denom; chroma_log2_weight_denom = slice_param->luma_log2_weight_denom + slice_param->delta_chroma_log2_weight_denom; for (i = 0; i <= slice_param->num_ref_idx_l0_active_minus1; i++) { if (slice_hdr->pred_weight_table.luma_weight_l0_flag[i]) { slice_param->delta_luma_weight_l0[i] = w->delta_luma_weight_l0[i]; slice_param->luma_offset_l0[i] = w->luma_offset_l0[i]; #if VA_CHECK_VERSION(1,2,0) if (slice_rext_param) slice_rext_param->luma_offset_l0[i] = w->luma_offset_l0[i]; #endif } if (slice_hdr->pred_weight_table.chroma_weight_l0_flag[i]) { for (j = 0; j < 2; j++) { slice_param->delta_chroma_weight_l0[i][j] = w->delta_chroma_weight_l0[i][j]; /* Find ChromaWeightL0 */ chroma_weight = (1 << chroma_log2_weight_denom) + w->delta_chroma_weight_l0[i][j]; /* 7-56 */ slice_param->ChromaOffsetL0[i][j] = CLAMP ( (priv->WpOffsetHalfRangeC + w->delta_chroma_offset_l0[i][j] - ((priv->WpOffsetHalfRangeC * chroma_weight) >> chroma_log2_weight_denom)), -priv->WpOffsetHalfRangeC, priv->WpOffsetHalfRangeC - 1); #if VA_CHECK_VERSION(1,2,0) if (slice_rext_param) slice_rext_param->ChromaOffsetL0[i][j] = CLAMP ( (priv->WpOffsetHalfRangeC + w->delta_chroma_offset_l0[i][j] - ((priv->WpOffsetHalfRangeC * chroma_weight) >> chroma_log2_weight_denom)), -priv->WpOffsetHalfRangeC, priv->WpOffsetHalfRangeC - 1); #endif } } } if (GST_H265_IS_B_SLICE (slice_hdr)) { for (i = 0; i <= slice_param->num_ref_idx_l1_active_minus1; i++) { if (slice_hdr->pred_weight_table.luma_weight_l1_flag[i]) { slice_param->delta_luma_weight_l1[i] = w->delta_luma_weight_l1[i]; slice_param->luma_offset_l1[i] = w->luma_offset_l1[i]; #if VA_CHECK_VERSION(1,2,0) if (slice_rext_param) slice_rext_param->luma_offset_l1[i] = w->luma_offset_l1[i]; #endif } if (slice_hdr->pred_weight_table.chroma_weight_l1_flag[i]) { for (j = 0; j < 2; j++) { slice_param->delta_chroma_weight_l1[i][j] = w->delta_chroma_weight_l1[i][j]; /* Find ChromaWeightL1 */ chroma_weight = (1 << chroma_log2_weight_denom) + w->delta_chroma_weight_l1[i][j]; /* 7-56 */ slice_param->ChromaOffsetL1[i][j] = CLAMP ((priv->WpOffsetHalfRangeC + w->delta_chroma_offset_l1[i][j] - ((priv->WpOffsetHalfRangeC * chroma_weight) >> chroma_log2_weight_denom)), -priv->WpOffsetHalfRangeC, priv->WpOffsetHalfRangeC - 1); #if VA_CHECK_VERSION(1,2,0) if (slice_rext_param) slice_rext_param->ChromaOffsetL1[i][j] = CLAMP ((priv->WpOffsetHalfRangeC + w->delta_chroma_offset_l1[i][j] - ((priv->WpOffsetHalfRangeC * chroma_weight) >> chroma_log2_weight_denom)), -priv->WpOffsetHalfRangeC, priv->WpOffsetHalfRangeC - 1); #endif } } } } } return TRUE; } static gboolean fill_RefPicList (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture, GstVaapiSlice * slice, GstH265SliceHdr * slice_hdr) { GstVaapiDecoderH265Private *const priv = &decoder->priv; VASliceParameterBufferHEVC *const slice_param = slice->param; GstVaapiPicture *const base_picture = &picture->base; VAPictureParameterBufferHEVC *const pic_param = base_picture->param; guint i, num_ref_lists = 0, j; slice_param->num_ref_idx_l0_active_minus1 = 0; slice_param->num_ref_idx_l1_active_minus1 = 0; for (j = 0; j < 2; j++) for (i = 0; i < 15; i++) slice_param->RefPicList[j][i] = 0xFF; if (GST_H265_IS_B_SLICE (slice_hdr)) num_ref_lists = 2; else if (GST_H265_IS_I_SLICE (slice_hdr)) num_ref_lists = 0; else num_ref_lists = 1; if (num_ref_lists < 1) return TRUE; slice_param->num_ref_idx_l0_active_minus1 = slice_hdr->num_ref_idx_l0_active_minus1; slice_param->num_ref_idx_l1_active_minus1 = slice_hdr->num_ref_idx_l1_active_minus1; for (i = 0; i < priv->RefPicList0_count; i++) slice_param->RefPicList[0][i] = get_index_for_RefPicListX (pic_param->ReferenceFrames, priv->RefPicList0[i]); for (; i < 15; i++) slice_param->RefPicList[0][i] = 0xFF; if (num_ref_lists < 2) return TRUE; for (i = 0; i < priv->RefPicList1_count; i++) slice_param->RefPicList[1][i] = get_index_for_RefPicListX (pic_param->ReferenceFrames, priv->RefPicList1[i]); for (; i < 15; i++) slice_param->RefPicList[1][i] = 0xFF; return TRUE; } static gboolean fill_slice (GstVaapiDecoderH265 * decoder, GstVaapiPictureH265 * picture, GstVaapiSlice * slice, GstVaapiParserInfoH265 * pi, GstVaapiDecoderUnit * unit) { GstH265SliceHdr *slice_hdr = &pi->data.slice_hdr; VASliceParameterBufferHEVC *slice_param = slice->param; #if VA_CHECK_VERSION(1,2,0) GstVaapiDecoderH265Private *const priv = &decoder->priv; VASliceParameterBufferHEVCRext *slice_rext_param = NULL; if (is_range_extension_profile (priv->profile) || is_scc_profile (priv->profile)) { VASliceParameterBufferHEVCExtension *param = slice->param; slice_param = ¶m->base; slice_rext_param = ¶m->rext; } #endif /* Fill in VASliceParameterBufferH265 */ slice_param->LongSliceFlags.value = 0; slice_param->slice_data_byte_offset = get_slice_data_byte_offset (slice_hdr, pi->nalu.header_bytes); slice_param->slice_segment_address = slice_hdr->segment_address; #define COPY_LFF(f) \ slice_param->LongSliceFlags.fields.f = (slice_hdr)->f if (GST_VAAPI_PICTURE_FLAG_IS_SET (picture, GST_VAAPI_PICTURE_FLAG_AU_END)) slice_param->LongSliceFlags.fields.LastSliceOfPic = 1; else slice_param->LongSliceFlags.fields.LastSliceOfPic = 0; COPY_LFF (dependent_slice_segment_flag); COPY_LFF (mvd_l1_zero_flag); COPY_LFF (cabac_init_flag); COPY_LFF (collocated_from_l0_flag); slice_param->LongSliceFlags.fields.color_plane_id = slice_hdr->colour_plane_id; slice_param->LongSliceFlags.fields.slice_type = slice_hdr->type; slice_param->LongSliceFlags.fields.slice_sao_luma_flag = slice_hdr->sao_luma_flag; slice_param->LongSliceFlags.fields.slice_sao_chroma_flag = slice_hdr->sao_chroma_flag; slice_param->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag = slice_hdr->temporal_mvp_enabled_flag; slice_param->LongSliceFlags.fields.slice_deblocking_filter_disabled_flag = slice_hdr->deblocking_filter_disabled_flag; slice_param->LongSliceFlags.fields. slice_loop_filter_across_slices_enabled_flag = slice_hdr->loop_filter_across_slices_enabled_flag; if (!slice_hdr->temporal_mvp_enabled_flag) slice_param->collocated_ref_idx = 0xFF; else slice_param->collocated_ref_idx = slice_hdr->collocated_ref_idx; slice_param->num_ref_idx_l0_active_minus1 = slice_hdr->num_ref_idx_l0_active_minus1; slice_param->num_ref_idx_l1_active_minus1 = slice_hdr->num_ref_idx_l1_active_minus1; slice_param->slice_qp_delta = slice_hdr->qp_delta; slice_param->slice_cb_qp_offset = slice_hdr->cb_qp_offset; slice_param->slice_cr_qp_offset = slice_hdr->cr_qp_offset; slice_param->slice_beta_offset_div2 = slice_hdr->beta_offset_div2; slice_param->slice_tc_offset_div2 = slice_hdr->tc_offset_div2; slice_param->five_minus_max_num_merge_cand = slice_hdr->five_minus_max_num_merge_cand; #if VA_CHECK_VERSION(1,2,0) if (slice_rext_param) { slice_rext_param->slice_ext_flags.bits.cu_chroma_qp_offset_enabled_flag = slice_hdr->cu_chroma_qp_offset_enabled_flag; slice_rext_param->slice_ext_flags.bits.use_integer_mv_flag = slice_hdr->use_integer_mv_flag; slice_rext_param->slice_act_y_qp_offset = slice_hdr->slice_act_y_qp_offset; slice_rext_param->slice_act_cb_qp_offset = slice_hdr->slice_act_cb_qp_offset; slice_rext_param->slice_act_cr_qp_offset = slice_hdr->slice_act_cr_qp_offset; } #endif if (!fill_RefPicList (decoder, picture, slice, slice_hdr)) return FALSE; if (!fill_pred_weight_table (decoder, slice, slice_hdr)) return FALSE; return TRUE; } static GstVaapiDecoderStatus decode_slice (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = unit->parsed_info; GstVaapiPictureH265 *const picture = priv->current_picture; GstH265SliceHdr *const slice_hdr = &pi->data.slice_hdr; GstVaapiSlice *slice = NULL; GstBuffer *const buffer = GST_VAAPI_DECODER_CODEC_FRAME (decoder)->input_buffer; GstMapInfo map_info; GST_DEBUG ("slice (%u bytes)", pi->nalu.size); if (!is_valid_state (pi->state, GST_H265_VIDEO_STATE_VALID_PICTURE_HEADERS)) { GST_WARNING ("failed to receive enough headers to decode slice"); return GST_VAAPI_DECODER_STATUS_SUCCESS; } if (!ensure_pps (decoder, slice_hdr->pps)) { GST_ERROR ("failed to activate PPS"); return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; } if (!ensure_sps (decoder, slice_hdr->pps->sps)) { GST_ERROR ("failed to activate SPS"); return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; } if (!gst_buffer_map (buffer, &map_info, GST_MAP_READ)) { GST_ERROR ("failed to map buffer"); return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; } /* Check wether this is the first/last slice in the current access unit */ if (pi->flags & GST_VAAPI_DECODER_UNIT_FLAG_AU_START) GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_AU_START); if (pi->flags & GST_VAAPI_DECODER_UNIT_FLAG_AU_END) GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_AU_END); if (is_range_extension_profile (priv->profile) || is_scc_profile (priv->profile)) { #if VA_CHECK_VERSION(1,2,0) slice = GST_VAAPI_SLICE_NEW (HEVCExtension, decoder, (map_info.data + unit->offset + pi->nalu.offset), pi->nalu.size); #endif } else { slice = GST_VAAPI_SLICE_NEW (HEVC, decoder, (map_info.data + unit->offset + pi->nalu.offset), pi->nalu.size); } gst_buffer_unmap (buffer, &map_info); if (!slice) { GST_ERROR ("failed to allocate slice"); return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED; } init_picture_refs (decoder, picture, slice_hdr); if (!fill_slice (decoder, picture, slice, pi, unit)) { gst_vaapi_mini_object_unref (GST_VAAPI_MINI_OBJECT (slice)); return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN; } gst_vaapi_picture_add_slice (GST_VAAPI_PICTURE_CAST (picture), slice); picture->last_slice_hdr = slice_hdr; return GST_VAAPI_DECODER_STATUS_SUCCESS; } static inline gint scan_for_start_code (GstAdapter * adapter, guint ofs, guint size, guint32 * scp) { if (size == 0) return -1; return (gint) gst_adapter_masked_scan_uint32_peek (adapter, 0xffffff00, 0x00000100, ofs, size, scp); } static GstVaapiDecoderStatus decode_unit (GstVaapiDecoderH265 * decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserInfoH265 *const pi = unit->parsed_info; GstVaapiDecoderStatus status; priv->decoder_state |= pi->state; switch (pi->nalu.type) { case GST_H265_NAL_VPS: status = decode_vps (decoder, unit); break; case GST_H265_NAL_SPS: status = decode_sps (decoder, unit); break; case GST_H265_NAL_PPS: status = decode_pps (decoder, unit); break; case GST_H265_NAL_SLICE_TRAIL_N: case GST_H265_NAL_SLICE_TRAIL_R: case GST_H265_NAL_SLICE_TSA_N: case GST_H265_NAL_SLICE_TSA_R: case GST_H265_NAL_SLICE_STSA_N: case GST_H265_NAL_SLICE_STSA_R: case GST_H265_NAL_SLICE_RADL_N: case GST_H265_NAL_SLICE_RADL_R: case GST_H265_NAL_SLICE_RASL_N: case GST_H265_NAL_SLICE_RASL_R: case GST_H265_NAL_SLICE_BLA_W_LP: case GST_H265_NAL_SLICE_BLA_W_RADL: case GST_H265_NAL_SLICE_BLA_N_LP: case GST_H265_NAL_SLICE_IDR_W_RADL: case GST_H265_NAL_SLICE_IDR_N_LP: case GST_H265_NAL_SLICE_CRA_NUT: /* slice decoding will get started only after completing all the initialization routines for each picture which is hanlding in start_frame() call back, so the new_bitstream and prev_nal_is_eos flags will have effects starting from the next frame onwards */ priv->new_bitstream = FALSE; priv->prev_nal_is_eos = FALSE; status = decode_slice (decoder, unit); break; case GST_H265_NAL_EOB: priv->new_bitstream = TRUE; GST_DEBUG ("Next AU(if there is any) will be the begining of new bitstream"); status = decode_sequence_end (decoder); break; case GST_H265_NAL_EOS: priv->prev_nal_is_eos = TRUE; status = decode_sequence_end (decoder); break; case GST_H265_NAL_SUFFIX_SEI: case GST_H265_NAL_PREFIX_SEI: status = decode_sei (decoder, unit); break; default: GST_WARNING ("unsupported NAL unit type %d", pi->nalu.type); status = GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER; break; } return status; } static GstVaapiDecoderStatus gst_vaapi_decoder_h265_decode_codec_data (GstVaapiDecoder * base_decoder, const guchar * buf, guint buf_size) { GstVaapiDecoderH265 *const decoder = GST_VAAPI_DECODER_H265_CAST (base_decoder); GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiDecoderStatus status; GstVaapiDecoderUnit unit; GstVaapiParserInfoH265 *pi = NULL; GstH265ParserResult result; guint num_nal_arrays, num_nals; guint i, j, ofs; if (!priv->is_opened) return GST_VAAPI_DECODER_STATUS_SUCCESS; unit.parsed_info = NULL; if (buf_size < 23) return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA; if (buf[0] != 1) { GST_ERROR ("failed to decode codec-data, not in hvcC format"); return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER; } priv->nal_length_size = (buf[21] & 0x03) + 1; GST_DEBUG ("nal length size %u", priv->nal_length_size); num_nal_arrays = buf[22]; ofs = 23; for (i = 0; i < num_nal_arrays; i++) { if (ofs + 1 > buf_size) return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA; num_nals = GST_READ_UINT16_BE (buf + ofs + 1); /* the max number of nals is GST_H265_MAX_PPS_COUNT (64) */ if (num_nals > 64) return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER; ofs += 3; for (j = 0; j < num_nals; j++) { pi = gst_vaapi_parser_info_h265_new (); if (!pi) return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED; unit.parsed_info = pi; result = gst_h265_parser_identify_nalu_hevc (priv->parser, buf, ofs, buf_size, 2, &pi->nalu); if (result != GST_H265_PARSER_OK) { status = get_status (result); goto cleanup; } pi->state = priv->parser_state; pi->flags = 0; switch (pi->nalu.type) { case GST_H265_NAL_VPS: status = parse_vps (decoder, &unit); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) goto cleanup; status = decode_vps (decoder, &unit); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) goto cleanup; break; case GST_H265_NAL_SPS: status = parse_sps (decoder, &unit); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) goto cleanup; status = decode_sps (decoder, &unit); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) goto cleanup; break; case GST_H265_NAL_PPS: status = parse_pps (decoder, &unit); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) goto cleanup; status = decode_pps (decoder, &unit); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) goto cleanup; break; case GST_H265_NAL_SUFFIX_SEI: case GST_H265_NAL_PREFIX_SEI: status = parse_sei (decoder, &unit); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) goto cleanup; status = decode_sei (decoder, &unit); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) goto cleanup; break; } ofs = pi->nalu.offset + pi->nalu.size; gst_vaapi_parser_info_h265_replace (&pi, NULL); } } priv->is_hvcC = TRUE; status = GST_VAAPI_DECODER_STATUS_SUCCESS; cleanup: gst_vaapi_parser_info_h265_replace (&pi, NULL); return status; } static GstVaapiDecoderStatus ensure_decoder (GstVaapiDecoderH265 * decoder) { GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiDecoderStatus status; if (!priv->is_opened) { priv->is_opened = gst_vaapi_decoder_h265_open (decoder); if (!priv->is_opened) return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CODEC; status = gst_vaapi_decoder_decode_codec_data (GST_VAAPI_DECODER_CAST (decoder)); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) return status; } return GST_VAAPI_DECODER_STATUS_SUCCESS; } static void populate_dependent_slice_hdr (GstVaapiParserInfoH265 * pi, GstVaapiParserInfoH265 * indep_pi) { GstH265SliceHdr *slice_hdr = &pi->data.slice_hdr; GstH265SliceHdr *indep_slice_hdr = &indep_pi->data.slice_hdr; memcpy (&slice_hdr->type, &indep_slice_hdr->type, offsetof (GstH265SliceHdr, num_entry_point_offsets) - offsetof (GstH265SliceHdr, type)); } static GstVaapiDecoderStatus gst_vaapi_decoder_h265_parse (GstVaapiDecoder * base_decoder, GstAdapter * adapter, gboolean at_eos, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265 *const decoder = GST_VAAPI_DECODER_H265_CAST (base_decoder); GstVaapiDecoderH265Private *const priv = &decoder->priv; GstVaapiParserState *const ps = GST_VAAPI_PARSER_STATE (base_decoder); GstVaapiParserInfoH265 *pi; GstVaapiDecoderStatus status; GstH265ParserResult result; guchar *buf; guint i, size, buf_size, nalu_size, flags; guint32 start_code; gint ofs, ofs2; gboolean at_au_end = FALSE; status = ensure_decoder (decoder); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) return status; switch (priv->stream_alignment) { case GST_VAAPI_STREAM_ALIGN_H265_NALU: case GST_VAAPI_STREAM_ALIGN_H265_AU: size = gst_adapter_available_fast (adapter); break; default: size = gst_adapter_available (adapter); break; } if (priv->is_hvcC) { if (size < priv->nal_length_size) return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA; buf = (guchar *) & start_code; g_assert (priv->nal_length_size <= sizeof (start_code)); gst_adapter_copy (adapter, buf, 0, priv->nal_length_size); nalu_size = 0; for (i = 0; i < priv->nal_length_size; i++) nalu_size = (nalu_size << 8) | buf[i]; buf_size = priv->nal_length_size + nalu_size; if (size < buf_size) return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA; else if (priv->stream_alignment == GST_VAAPI_STREAM_ALIGN_H265_AU) at_au_end = (buf_size == size); } else { if (size < 4) return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA; if (priv->stream_alignment == GST_VAAPI_STREAM_ALIGN_H265_NALU) { buf_size = size; ofs = scan_for_start_code (adapter, 4, size - 4, NULL); if (ofs > 0) buf_size = ofs; } else { ofs = scan_for_start_code (adapter, 0, size, NULL); if (ofs < 0) return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA; if (ofs > 0) { gst_adapter_flush (adapter, ofs); size -= ofs; } ofs2 = ps->input_offset2 - ofs - 4; if (ofs2 < 4) ofs2 = 4; ofs = G_UNLIKELY (size < ofs2 + 4) ? -1 : scan_for_start_code (adapter, ofs2, size - ofs2, NULL); if (ofs < 0) { // Assume the whole NAL unit is present if end-of-stream // or stream buffers aligned on access unit boundaries if (priv->stream_alignment == GST_VAAPI_STREAM_ALIGN_H265_AU) at_au_end = TRUE; else if (!at_eos) { ps->input_offset2 = size; return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA; } ofs = size; } buf_size = ofs; } } ps->input_offset2 = 0; buf = (guchar *) gst_adapter_map (adapter, buf_size); if (!buf) return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA; unit->size = buf_size; pi = gst_vaapi_parser_info_h265_new (); if (!pi) return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED; gst_vaapi_decoder_unit_set_parsed_info (unit, pi, (GDestroyNotify) gst_vaapi_mini_object_unref); if (priv->is_hvcC) result = gst_h265_parser_identify_nalu_hevc (priv->parser, buf, 0, buf_size, priv->nal_length_size, &pi->nalu); else result = gst_h265_parser_identify_nalu_unchecked (priv->parser, buf, 0, buf_size, &pi->nalu); status = get_status (result); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) goto exit; switch (pi->nalu.type) { case GST_H265_NAL_VPS: status = parse_vps (decoder, unit); break; case GST_H265_NAL_SPS: status = parse_sps (decoder, unit); break; case GST_H265_NAL_PPS: status = parse_pps (decoder, unit); break; case GST_H265_NAL_PREFIX_SEI: case GST_H265_NAL_SUFFIX_SEI: status = parse_sei (decoder, unit); break; case GST_H265_NAL_SLICE_TRAIL_N: case GST_H265_NAL_SLICE_TRAIL_R: case GST_H265_NAL_SLICE_TSA_N: case GST_H265_NAL_SLICE_TSA_R: case GST_H265_NAL_SLICE_STSA_N: case GST_H265_NAL_SLICE_STSA_R: case GST_H265_NAL_SLICE_RADL_N: case GST_H265_NAL_SLICE_RADL_R: case GST_H265_NAL_SLICE_RASL_N: case GST_H265_NAL_SLICE_RASL_R: case GST_H265_NAL_SLICE_BLA_W_LP: case GST_H265_NAL_SLICE_BLA_W_RADL: case GST_H265_NAL_SLICE_BLA_N_LP: case GST_H265_NAL_SLICE_IDR_W_RADL: case GST_H265_NAL_SLICE_IDR_N_LP: case GST_H265_NAL_SLICE_CRA_NUT: status = parse_slice (decoder, unit); break; default: status = GST_VAAPI_DECODER_STATUS_SUCCESS; break; } if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) goto exit; flags = 0; if (at_au_end) { flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_END | GST_VAAPI_DECODER_UNIT_FLAG_AU_END; } switch (pi->nalu.type) { case GST_H265_NAL_AUD: flags |= GST_VAAPI_DECODER_UNIT_FLAG_AU_START; flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START; /* fall-through */ case GST_H265_NAL_FD: flags |= GST_VAAPI_DECODER_UNIT_FLAG_SKIP; break; case GST_H265_NAL_EOB: flags |= GST_VAAPI_DECODER_UNIT_FLAG_STREAM_END; /* fall-through */ case GST_H265_NAL_SUFFIX_SEI: case GST_H265_NAL_EOS: flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_END; flags |= GST_VAAPI_DECODER_UNIT_FLAG_AU_END; break; case GST_H265_NAL_VPS: case GST_H265_NAL_SPS: case GST_H265_NAL_PPS: case GST_H265_NAL_PREFIX_SEI: flags |= GST_VAAPI_DECODER_UNIT_FLAG_AU_START; flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START; break; case GST_H265_NAL_SLICE_TRAIL_N: case GST_H265_NAL_SLICE_TRAIL_R: case GST_H265_NAL_SLICE_TSA_N: case GST_H265_NAL_SLICE_TSA_R: case GST_H265_NAL_SLICE_STSA_N: case GST_H265_NAL_SLICE_STSA_R: case GST_H265_NAL_SLICE_RADL_N: case GST_H265_NAL_SLICE_RADL_R: case GST_H265_NAL_SLICE_RASL_N: case GST_H265_NAL_SLICE_RASL_R: case GST_H265_NAL_SLICE_BLA_W_LP: case GST_H265_NAL_SLICE_BLA_W_RADL: case GST_H265_NAL_SLICE_BLA_N_LP: case GST_H265_NAL_SLICE_IDR_W_RADL: case GST_H265_NAL_SLICE_IDR_N_LP: case GST_H265_NAL_SLICE_CRA_NUT: flags |= GST_VAAPI_DECODER_UNIT_FLAG_SLICE; if (priv->prev_pi && (priv->prev_pi->flags & GST_VAAPI_DECODER_UNIT_FLAG_AU_END)) { flags |= GST_VAAPI_DECODER_UNIT_FLAG_AU_START | GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START; } else if (is_new_picture (pi, priv->prev_slice_pi)) { flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START; if (is_new_access_unit (pi, priv->prev_slice_pi)) flags |= GST_VAAPI_DECODER_UNIT_FLAG_AU_START; } gst_vaapi_parser_info_h265_replace (&priv->prev_slice_pi, pi); if (!pi->data.slice_hdr.dependent_slice_segment_flag) gst_vaapi_parser_info_h265_replace (&priv->prev_independent_slice_pi, pi); else populate_dependent_slice_hdr (pi, priv->prev_independent_slice_pi); if (!GST_H265_IS_I_SLICE (&pi->data.slice_hdr)) priv->parser_state |= GST_H265_VIDEO_STATE_GOT_P_SLICE; break; default: /* Fix */ break; } if ((flags & GST_VAAPI_DECODER_UNIT_FLAGS_AU) && priv->prev_slice_pi) priv->prev_slice_pi->flags |= GST_VAAPI_DECODER_UNIT_FLAG_AU_END; GST_VAAPI_DECODER_UNIT_FLAG_SET (unit, flags); pi->nalu.data = NULL; pi->state = priv->parser_state; pi->flags = flags; gst_vaapi_parser_info_h265_replace (&priv->prev_pi, pi); return GST_VAAPI_DECODER_STATUS_SUCCESS; exit: gst_adapter_flush (adapter, unit->size); gst_vaapi_parser_info_h265_unref (pi); return status; } static GstVaapiDecoderStatus gst_vaapi_decoder_h265_decode (GstVaapiDecoder * base_decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265 *const decoder = GST_VAAPI_DECODER_H265_CAST (base_decoder); GstVaapiDecoderStatus status; status = ensure_decoder (decoder); if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) return status; return decode_unit (decoder, unit); } static GstVaapiDecoderStatus gst_vaapi_decoder_h265_start_frame (GstVaapiDecoder * base_decoder, GstVaapiDecoderUnit * unit) { GstVaapiDecoderH265 *const decoder = GST_VAAPI_DECODER_H265_CAST (base_decoder); return decode_picture (decoder, unit); } static GstVaapiDecoderStatus gst_vaapi_decoder_h265_end_frame (GstVaapiDecoder * base_decoder) { GstVaapiDecoderH265 *const decoder = GST_VAAPI_DECODER_H265_CAST (base_decoder); return decode_current_picture (decoder); } static GstVaapiDecoderStatus gst_vaapi_decoder_h265_flush (GstVaapiDecoder * base_decoder) { GstVaapiDecoderH265 *const decoder = GST_VAAPI_DECODER_H265_CAST (base_decoder); dpb_flush (decoder); return GST_VAAPI_DECODER_STATUS_SUCCESS; } static void gst_vaapi_decoder_h265_finalize (GObject * object) { GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER (object); gst_vaapi_decoder_h265_destroy (base_decoder); G_OBJECT_CLASS (gst_vaapi_decoder_h265_parent_class)->finalize (object); } static void gst_vaapi_decoder_h265_class_init (GstVaapiDecoderH265Class * klass) { GObjectClass *const object_class = G_OBJECT_CLASS (klass); GstVaapiDecoderClass *const decoder_class = GST_VAAPI_DECODER_CLASS (klass); object_class->finalize = gst_vaapi_decoder_h265_finalize; decoder_class->reset = gst_vaapi_decoder_h265_reset; decoder_class->parse = gst_vaapi_decoder_h265_parse; decoder_class->decode = gst_vaapi_decoder_h265_decode; decoder_class->start_frame = gst_vaapi_decoder_h265_start_frame; decoder_class->end_frame = gst_vaapi_decoder_h265_end_frame; decoder_class->flush = gst_vaapi_decoder_h265_flush; decoder_class->decode_codec_data = gst_vaapi_decoder_h265_decode_codec_data; } static void gst_vaapi_decoder_h265_init (GstVaapiDecoderH265 * decoder) { GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER (decoder); gst_vaapi_decoder_h265_create (base_decoder); } /** * gst_vaapi_decoder_h265_set_alignment: * @decoder: a #GstVaapiDecoderH265 * @alignment: the #GstVaapiStreamAlignH265 * * Specifies how stream buffers are aligned / fed, i.e. the boundaries * of each buffer that is supplied to the decoder. This could be no * specific alignment, NAL unit boundaries, or access unit boundaries. */ void gst_vaapi_decoder_h265_set_alignment (GstVaapiDecoderH265 * decoder, GstVaapiStreamAlignH265 alignment) { g_return_if_fail (decoder != NULL); decoder->priv.stream_alignment = alignment; } /** * gst_vaapi_decoder_h265_new: * @display: a #GstVaapiDisplay * @caps: a #GstCaps holding codec information * * Creates a new #GstVaapiDecoder for MPEG-2 decoding. The @caps can * hold extra information like codec-data and pictured coded size. * * Return value: the newly allocated #GstVaapiDecoder object */ GstVaapiDecoder * gst_vaapi_decoder_h265_new (GstVaapiDisplay * display, GstCaps * caps) { return g_object_new (GST_TYPE_VAAPI_DECODER_H265, "display", display, "caps", caps, NULL); }