sigrid/ffmpeg

libavcodec/dxva2_hevc.c+12−12

@@ -72,7 +72,7 @@ void ff_dxva2_hevc_fill_picture_parameters(const AVCodecContext *avctx, AVDXVACo · 71 unmodified lines
72	72	pp->PicHeightInMinCbsY = sps->min_cb_height;
73	73
74	74	pp->wFormatAndSequenceInfoFlags = (sps->chroma_format_idc << 0) \|
75		− (sps->separate_colour_plane_flag << 2) \|
	75	+ (sps->separate_colour_plane << 2) \|
76	76	((sps->bit_depth - 8) << 3) \|
77	77	((sps->bit_depth - 8) << 6) \|
78	78	((sps->log2_max_poc_lsb - 4) << 9) \|
@@ -99,18 +99,18 @@ void ff_dxva2_hevc_fill_picture_parameters(const AVCodecContext *avctx, AVDXVACo · 20 unmodified lines
99	99	pp->wNumBitsForShortTermRPSInSlice = h->sh.short_term_ref_pic_set_size;
100	100	}
101	101
102		− pp->dwCodingParamToolFlags = (sps->scaling_list_enable_flag << 0) \|
103		− (sps->amp_enabled_flag << 1) \|
	102	+ pp->dwCodingParamToolFlags = (sps->scaling_list_enabled << 0) \|
	103	+ (sps->amp_enabled << 1) \|
104	104	(sps->sao_enabled << 2) \|
105		− (sps->pcm_enabled_flag << 3) \|
106		− ((sps->pcm_enabled_flag ? (sps->pcm.bit_depth - 1) : 0) << 4) \|
107		− ((sps->pcm_enabled_flag ? (sps->pcm.bit_depth_chroma - 1) : 0) << 8) \|
108		− ((sps->pcm_enabled_flag ? (sps->pcm.log2_min_pcm_cb_size - 3) : 0) << 12) \|
109		− ((sps->pcm_enabled_flag ? (sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size) : 0) << 14) \|
110		− (sps->pcm.loop_filter_disable_flag << 16) \|
111		− (sps->long_term_ref_pics_present_flag << 17) \|
112		− (sps->sps_temporal_mvp_enabled_flag << 18) \|
113		− (sps->sps_strong_intra_smoothing_enable_flag << 19) \|
	105	+ (sps->pcm_enabled << 3) \|
	106	+ ((sps->pcm_enabled ? (sps->pcm.bit_depth - 1) : 0) << 4) \|
	107	+ ((sps->pcm_enabled ? (sps->pcm.bit_depth_chroma - 1) : 0) << 8) \|
	108	+ ((sps->pcm_enabled ? (sps->pcm.log2_min_pcm_cb_size - 3) : 0) << 12) \|
	109	+ ((sps->pcm_enabled ? (sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size) : 0) << 14) \|
	110	+ (sps->pcm_loop_filter_disabled << 16) \|
	111	+ (sps->long_term_ref_pics_present << 17) \|
	112	+ (sps->temporal_mvp_enabled << 18) \|
	113	+ (sps->strong_intra_smoothing_enabled << 19) \|
114	114	(pps->dependent_slice_segments_enabled_flag << 20) \|
115	115	(pps->output_flag_present_flag << 21) \|
116	116	(pps->num_extra_slice_header_bits << 22) \|

libavcodec/hevc_cabac.c+18−18

@@ -408,7 +408,7 @@ void ff_hevc_save_states(HEVCLocalContext *lc, int ctb_addr_ts) · 407 unmodified lines
408	408	(s->ps.sps->ctb_width == 2 &&
409	409	ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
410	410	memcpy(lc->common_cabac_state->state, lc->cabac_state, HEVC_CONTEXTS);
411		− if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
	411	+ if (s->ps.sps->persistent_rice_adaptation_enabled) {
412	412	memcpy(lc->common_cabac_state->stat_coeff, lc->stat_coeff, HEVC_STAT_COEFFS);
413	413	}
414	414	}
@@ -417,7 +417,7 @@ void ff_hevc_save_states(HEVCLocalContext *lc, int ctb_addr_ts) · 2 unmodified lines
417	417	static void load_states(HEVCLocalContext lc, const HEVCContext s)
418	418	{
419	419	memcpy(lc->cabac_state, lc->common_cabac_state->state, HEVC_CONTEXTS);
420		− if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
	420	+ if (s->ps.sps->persistent_rice_adaptation_enabled) {
421	421	memcpy(lc->stat_coeff, lc->common_cabac_state->stat_coeff, HEVC_STAT_COEFFS);
422	422	}
423	423	}
@@ -683,7 +683,7 @@ int ff_hevc_part_mode_decode(HEVCLocalContext *lc, int log2_cb_size) · 259 unmodified lines
683	683	return PART_NxN; // 000
684	684	}
685	685
686		− if (!lc->parent->ps.sps->amp_enabled_flag) {
	686	+ if (!lc->parent->ps.sps->amp_enabled) {
687	687	if (GET_CABAC(PART_MODE_OFFSET + 1)) // 01
688	688	return PART_2NxN;
689	689	return PART_Nx2N;
@@ -1091,7 +1091,7 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, · 401 unmodified lines
1091	1091	scale_m = 16; // default when no custom scaling lists.
1092	1092	dc_scale = 16;
1093	1093
1094		− if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
	1094	+ if (s->ps.sps->scaling_list_enabled && !(transform_skip_flag && log2_trafo_size > 2)) {
1095	1095	const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1096	1096	&s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1097	1097	int matrix_id = lc->cu.pred_mode != MODE_INTRA;
@@ -1109,7 +1109,7 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, · 11 unmodified lines
1109	1109	dc_scale = 0;
1110	1110	}
1111	1111
1112		− if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
	1112	+ if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled &&
1113	1113	(transform_skip_flag \|\| lc->cu.cu_transquant_bypass_flag)) {
1114	1114	explicit_rdpcm_flag = explicit_rdpcm_flag_decode(lc, c_idx);
1115	1115	if (explicit_rdpcm_flag) {
@@ -1240,7 +1240,7 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, · 124 unmodified lines
1240	1240	};
1241	1241	const uint8_t *ctx_idx_map_p;
1242	1242	int scf_offset = 0;
1243		− if (s->ps.sps->transform_skip_context_enabled_flag &&
	1243	+ if (s->ps.sps->transform_skip_context_enabled &&
1244	1244	(transform_skip_flag \|\| lc->cu.cu_transquant_bypass_flag)) {
1245	1245	ctx_idx_map_p = &ctx_idx_map[4 * 16];
1246	1246	if (c_idx == 0) {
@@ -1281,7 +1281,7 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, · 34 unmodified lines
1281	1281	}
1282	1282	}
1283	1283	if (implicit_non_zero_coeff == 0) {
1284		− if (s->ps.sps->transform_skip_context_enabled_flag &&
	1284	+ if (s->ps.sps->transform_skip_context_enabled &&
1285	1285	(transform_skip_flag \|\| lc->cu.cu_transquant_bypass_flag)) {
1286	1286	if (c_idx == 0) {
1287	1287	scf_offset = 42;
@@ -1326,7 +1326,7 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, · 38 unmodified lines
1326	1326	// initialize first elem of coeff_bas_level_greater1_flag
1327	1327	int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1328	1328
1329		− if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
	1329	+ if (s->ps.sps->persistent_rice_adaptation_enabled) {
1330	1330	if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1331	1331	sb_type = 2 * (c_idx == 0 ? 1 : 0);
1332	1332	else
@@ -1355,7 +1355,7 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, · 22 unmodified lines
1355	1355
1356	1356	if (lc->cu.cu_transquant_bypass_flag \|\|
1357	1357	(lc->cu.pred_mode == MODE_INTRA &&
1358		− s->ps.sps->implicit_rdpcm_enabled_flag && transform_skip_flag &&
	1358	+ s->ps.sps->implicit_rdpcm_enabled && transform_skip_flag &&
1359	1359	(pred_mode_intra == 10 \|\| pred_mode_intra == 26 )) \|\|
1360	1360	explicit_rdpcm_flag)
1361	1361	sign_hidden = 0;
@@ -1381,8 +1381,8 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, · 19 unmodified lines
1381	1381
1382	1382	trans_coeff_level += last_coeff_abs_level_remaining;
1383	1383	if (trans_coeff_level > (3 << c_rice_param))
1384		− c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1385		− if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
	1384	+ c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
	1385	+ if (s->ps.sps->persistent_rice_adaptation_enabled && !rice_init) {
1386	1386	int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1387	1387	if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1388	1388	lc->stat_coeff[sb_type]++;
@@ -1397,8 +1397,8 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, · 8 unmodified lines
1397	1397
1398	1398	trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1399	1399	if (trans_coeff_level > (3 << c_rice_param))
1400		− c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1401		− if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
	1400	+ c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
	1401	+ if (s->ps.sps->persistent_rice_adaptation_enabled && !rice_init) {
1402	1402	int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1403	1403	if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1404	1404	lc->stat_coeff[sb_type]++;
@@ -1417,7 +1417,7 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, · 12 unmodified lines
1417	1417	trans_coeff_level = -trans_coeff_level;
1418	1418	coeff_sign_flag <<= 1;
1419	1419	if(!lc->cu.cu_transquant_bypass_flag) {
1420		− if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
	1420	+ if (s->ps.sps->scaling_list_enabled && !(transform_skip_flag && log2_trafo_size > 2)) {
1421	1421	if(y_c \|\| x_c \|\| log2_trafo_size < 4) {
1422	1422	switch(log2_trafo_size) {
1423	1423	case 3: pos = (y_c << 3) + x_c; break;
@@ -1445,15 +1445,15 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, · 21 unmodified lines
1445	1445	}
1446	1446
1447	1447	if (lc->cu.cu_transquant_bypass_flag) {
1448		− if (explicit_rdpcm_flag \|\| (s->ps.sps->implicit_rdpcm_enabled_flag &&
	1448	+ if (explicit_rdpcm_flag \|\| (s->ps.sps->implicit_rdpcm_enabled &&
1449	1449	(pred_mode_intra == 10 \|\| pred_mode_intra == 26))) {
1450		− int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
	1450	+ int mode = s->ps.sps->implicit_rdpcm_enabled ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1451	1451
1452	1452	s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1453	1453	}
1454	1454	} else {
1455	1455	if (transform_skip_flag) {
1456		− int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
	1456	+ int rot = s->ps.sps->transform_skip_rotation_enabled &&
1457	1457	log2_trafo_size == 2 &&
1458	1458	lc->cu.pred_mode == MODE_INTRA;
1459	1459	if (rot) {
@@ -1463,7 +1463,7 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, · 3 unmodified lines
1463	1463
1464	1464	s->hevcdsp.dequant(coeffs, log2_trafo_size);
1465	1465
1466		− if (explicit_rdpcm_flag \|\| (s->ps.sps->implicit_rdpcm_enabled_flag &&
	1466	+ if (explicit_rdpcm_flag \|\| (s->ps.sps->implicit_rdpcm_enabled &&
1467	1467	lc->cu.pred_mode == MODE_INTRA &&
1468	1468	(pred_mode_intra == 10 \|\| pred_mode_intra == 26))) {
1469	1469	int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);

libavcodec/hevc_filter.c+4−4

@@ -224,7 +224,7 @@ static void restore_tqb_pixels(const HEVCContext *s, · 223 unmodified lines
224	224	int x0, int y0, int width, int height, int c_idx)
225	225	{
226	226	if ( s->ps.pps->transquant_bypass_enable_flag \|\|
227		− (s->ps.sps->pcm.loop_filter_disable_flag && s->ps.sps->pcm_enabled_flag)) {
	227	+ (s->ps.sps->pcm_loop_filter_disabled && s->ps.sps->pcm_enabled)) {
228	228	int x, y;
229	229	int min_pu_size = 1 << s->ps.sps->log2_min_pu_size;
230	230	int hshift = s->ps.sps->hshift[c_idx];
@@ -330,7 +330,7 @@ static void sao_filter_CTB(HEVCLocalContext lc, const HEVCContext s, int x, in · 99 unmodified lines
330	330	copy_CTB_to_hv(s, src, stride_src, x0, y0, width, height, c_idx,
331	331	x_ctb, y_ctb);
332	332	if (s->ps.pps->transquant_bypass_enable_flag \|\|
333		− (s->ps.sps->pcm.loop_filter_disable_flag && s->ps.sps->pcm_enabled_flag)) {
	333	+ (s->ps.sps->pcm_loop_filter_disabled && s->ps.sps->pcm_enabled)) {
334	334	dst = lc->edge_emu_buffer;
335	335	stride_dst = 2*MAX_PB_SIZE;
336	336	copy_CTB(dst, src, width << s->ps.sps->pixel_shift, height, stride_dst, stride_src);
@@ -500,8 +500,8 @@ static void deblocking_filter_CTB(const HEVCContext *s, int x0, int y0) · 163 unmodified lines
500	500	int cur_beta_offset = s->deblock[ctb].beta_offset;
501	501	int left_tc_offset, left_beta_offset;
502	502	int tc_offset, beta_offset;
503		− int pcmf = (s->ps.sps->pcm_enabled_flag &&
504		− s->ps.sps->pcm.loop_filter_disable_flag) \|\|
	503	+ int pcmf = (s->ps.sps->pcm_enabled &&
	504	+ s->ps.sps->pcm_loop_filter_disabled) \|\|
505	505	s->ps.pps->transquant_bypass_enable_flag;
506	506
507	507	if (x0) {

libavcodec/hevc_parser.c+1−1

@@ -150,7 +150,7 @@ static int hevc_parse_slice_header(AVCodecParserContext s, H2645NAL nal, · 149 unmodified lines
150	150	if (ps->pps->output_flag_present_flag)
151	151	skip_bits1(gb); // pic_output_flag
152	152
153		− if (ps->sps->separate_colour_plane_flag)
	153	+ if (ps->sps->separate_colour_plane)
154	154	skip_bits(gb, 2); // colour_plane_id
155	155
156	156	if (!IS_IDR_NAL(nal)) {

libavcodec/hevc_ps.c+47−48

@@ -895,7 +895,7 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 894 unmodified lines
895	895	return AVERROR_INVALIDDATA;
896	896	}
897	897
898		− sps->temporal_id_nesting_flag = get_bits(gb, 1);
	898	+ sps->temporal_id_nesting = get_bits(gb, 1);
899	899
900	900	if ((ret = parse_ptl(gb, avctx, &sps->ptl, sps->max_sub_layers)) < 0)
901	901	return ret;
@@ -913,9 +913,9 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 11 unmodified lines
913	913	}
914	914
915	915	if (sps->chroma_format_idc == 3)
916		− sps->separate_colour_plane_flag = get_bits1(gb);
	916	+ sps->separate_colour_plane = get_bits1(gb);
917	917
918		− if (sps->separate_colour_plane_flag)
	918	+ if (sps->separate_colour_plane)
919	919	sps->chroma_format_idc = 0;
920	920
921	921	sps->width = get_ue_golomb_long(gb);
@@ -924,8 +924,8 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 2 unmodified lines
924	924	sps->height, 0, avctx)) < 0)
925	925	return ret;
926	926
927		− sps->conformance_window_flag = get_bits1(gb);
928		− if (sps->conformance_window_flag) {
	927	+ sps->conformance_window = get_bits1(gb);
	928	+ if (sps->conformance_window) {
929	929	int vert_mult = hevc_sub_height_c[sps->chroma_format_idc];
930	930	int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
931	931	sps->pic_conf_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
@@ -982,8 +982,8 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 50 unmodified lines
982	982	return AVERROR_INVALIDDATA;
983	983	}
984	984
985		− sps->sublayer_ordering_info_flag = get_bits1(gb);
986		− start = sps->sublayer_ordering_info_flag ? 0 : sps->max_sub_layers - 1;
	985	+ sps->sublayer_ordering_info = get_bits1(gb);
	986	+ start = sps->sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
987	987	for (i = start; i < sps->max_sub_layers; i++) {
988	988	sps->temporal_layer[i].max_dec_pic_buffering = get_ue_golomb_long(gb) + 1;
989	989	sps->temporal_layer[i].num_reorder_pics = get_ue_golomb_long(gb);
@@ -1004,7 +1004,7 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 14 unmodified lines
1004	1004	}
1005	1005	}
1006	1006
1007		− if (!sps->sublayer_ordering_info_flag) {
	1007	+ if (!sps->sublayer_ordering_info) {
1008	1008	for (i = 0; i < start; i++) {
1009	1009	sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[start].max_dec_pic_buffering;
1010	1010	sps->temporal_layer[i].num_reorder_pics = sps->temporal_layer[start].num_reorder_pics;
@@ -1043,8 +1043,8 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 32 unmodified lines
1043	1043	sps->max_transform_hierarchy_depth_inter = get_ue_golomb_long(gb);
1044	1044	sps->max_transform_hierarchy_depth_intra = get_ue_golomb_long(gb);
1045	1045
1046		− sps->scaling_list_enable_flag = get_bits1(gb);
1047		− if (sps->scaling_list_enable_flag) {
	1046	+ sps->scaling_list_enabled = get_bits1(gb);
	1047	+ if (sps->scaling_list_enabled) {
1048	1048	set_default_scaling_list_data(&sps->scaling_list);
1049	1049
1050	1050	if (get_bits1(gb)) {
@@ -1054,11 +1054,11 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 3 unmodified lines
1054	1054	}
1055	1055	}
1056	1056
1057		− sps->amp_enabled_flag = get_bits1(gb);
1058		− sps->sao_enabled = get_bits1(gb);
	1057	+ sps->amp_enabled = get_bits1(gb);
	1058	+ sps->sao_enabled = get_bits1(gb);
1059	1059
1060		− sps->pcm_enabled_flag = get_bits1(gb);
1061		− if (sps->pcm_enabled_flag) {
	1060	+ sps->pcm_enabled = get_bits1(gb);
	1061	+ if (sps->pcm_enabled) {
1062	1062	sps->pcm.bit_depth = get_bits(gb, 4) + 1;
1063	1063	sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
1064	1064	sps->pcm.log2_min_pcm_cb_size = get_ue_golomb_long(gb) + 3;
@@ -1071,7 +1071,7 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 6 unmodified lines
1071	1071	return AVERROR_INVALIDDATA;
1072	1072	}
1073	1073
1074		− sps->pcm.loop_filter_disable_flag = get_bits1(gb);
	1074	+ sps->pcm_loop_filter_disabled = get_bits1(gb);
1075	1075	}
1076	1076
1077	1077	sps->nb_st_rps = get_ue_golomb_long(gb);
@@ -1086,8 +1086,8 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 8 unmodified lines
1086	1086	return ret;
1087	1087	}
1088	1088
1089		− sps->long_term_ref_pics_present_flag = get_bits1(gb);
1090		− if (sps->long_term_ref_pics_present_flag) {
	1089	+ sps->long_term_ref_pics_present = get_bits1(gb);
	1090	+ if (sps->long_term_ref_pics_present) {
1091	1091	sps->num_long_term_ref_pics_sps = get_ue_golomb_long(gb);
1092	1092	if (sps->num_long_term_ref_pics_sps > HEVC_MAX_LONG_TERM_REF_PICS) {
1093	1093	av_log(avctx, AV_LOG_ERROR, "Too many long term ref pics: %d.\n",
@@ -1102,54 +1102,53 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 8 unmodified lines
1102	1102	}
1103	1103	}
1104	1104
1105		− sps->sps_temporal_mvp_enabled_flag = get_bits1(gb);
1106		− sps->sps_strong_intra_smoothing_enable_flag = get_bits1(gb);
	1105	+ sps->temporal_mvp_enabled = get_bits1(gb);
	1106	+ sps->strong_intra_smoothing_enabled = get_bits1(gb);
1107	1107	sps->vui.common.sar = (AVRational){0, 1};
1108	1108	sps->vui_present = get_bits1(gb);
1109	1109	if (sps->vui_present)
1110	1110	decode_vui(gb, avctx, apply_defdispwin, sps);
1111	1111
1112		− sps->sps_extension_present_flag = get_bits1(gb);
1113		− if (sps->sps_extension_present_flag) {
1114		− sps->sps_range_extension_flag = get_bits1(gb);
1115		− sps->sps_multilayer_extension_flag = get_bits1(gb);
1116		− sps->sps_3d_extension_flag = get_bits1(gb);
1117		− sps->sps_scc_extension_flag = get_bits1(gb);
	1112	+ sps->extension_present = get_bits1(gb);
	1113	+ if (sps->extension_present) {
	1114	+ sps->range_extension = get_bits1(gb);
	1115	+ sps->multilayer_extension = get_bits1(gb);
	1116	+ sps->sps_3d_extension = get_bits1(gb);
	1117	+ sps->scc_extension = get_bits1(gb);
1118	1118	skip_bits(gb, 4); // sps_extension_4bits
1119	1119
1120		− if (sps->sps_range_extension_flag) {
1121		− sps->transform_skip_rotation_enabled_flag = get_bits1(gb);
1122		− sps->transform_skip_context_enabled_flag = get_bits1(gb);
1123		− sps->implicit_rdpcm_enabled_flag = get_bits1(gb);
	1120	+ if (sps->range_extension) {
	1121	+ sps->transform_skip_rotation_enabled = get_bits1(gb);
	1122	+ sps->transform_skip_context_enabled = get_bits1(gb);
	1123	+ sps->implicit_rdpcm_enabled = get_bits1(gb);
	1124	+ sps->explicit_rdpcm_enabled = get_bits1(gb);
1124	1125
1125		− sps->explicit_rdpcm_enabled_flag = get_bits1(gb);
1126		−
1127		− sps->extended_precision_processing_flag = get_bits1(gb);
1128		− if (sps->extended_precision_processing_flag)
	1126	+ sps->extended_precision_processing = get_bits1(gb);
	1127	+ if (sps->extended_precision_processing)
1129	1128	av_log(avctx, AV_LOG_WARNING,
1130	1129	"extended_precision_processing_flag not yet implemented\n");
1131	1130
1132		− sps->intra_smoothing_disabled_flag = get_bits1(gb);
1133		− sps->high_precision_offsets_enabled_flag = get_bits1(gb);
1134		− if (sps->high_precision_offsets_enabled_flag)
	1131	+ sps->intra_smoothing_disabled = get_bits1(gb);
	1132	+ sps->high_precision_offsets_enabled = get_bits1(gb);
	1133	+ if (sps->high_precision_offsets_enabled)
1135	1134	av_log(avctx, AV_LOG_WARNING,
1136	1135	"high_precision_offsets_enabled_flag not yet implemented\n");
1137	1136
1138		− sps->persistent_rice_adaptation_enabled_flag = get_bits1(gb);
	1137	+ sps->persistent_rice_adaptation_enabled = get_bits1(gb);
1139	1138
1140		− sps->cabac_bypass_alignment_enabled_flag = get_bits1(gb);
1141		− if (sps->cabac_bypass_alignment_enabled_flag)
	1139	+ sps->cabac_bypass_alignment_enabled = get_bits1(gb);
	1140	+ if (sps->cabac_bypass_alignment_enabled)
1142	1141	av_log(avctx, AV_LOG_WARNING,
1143	1142	"cabac_bypass_alignment_enabled_flag not yet implemented\n");
1144	1143	}
1145	1144
1146		− if (sps->sps_multilayer_extension_flag) {
	1145	+ if (sps->multilayer_extension) {
1147	1146	skip_bits1(gb); // inter_view_mv_vert_constraint_flag
1148	1147	av_log(avctx, AV_LOG_WARNING,
1149	1148	"sps_multilayer_extension_flag not yet implemented\n");
1150	1149	}
1151	1150
1152		− if (sps->sps_3d_extension_flag) {
	1151	+ if (sps->sps_3d_extension) {
1153	1152	for (i = 0; i <= 1; i++) {
1154	1153	skip_bits1(gb); // iv_di_mc_enabled_flag
1155	1154	skip_bits1(gb); // iv_mv_scal_enabled_flag
@@ -1173,15 +1172,15 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 17 unmodified lines
1173	1172	"sps_3d_extension_flag not yet implemented\n");
1174	1173	}
1175	1174
1176		− if (sps->sps_scc_extension_flag) {
1177		− sps->sps_curr_pic_ref_enabled_flag = get_bits1(gb);
1178		− sps->palette_mode_enabled_flag = get_bits1(gb);
1179		− if (sps->palette_mode_enabled_flag) {
	1175	+ if (sps->scc_extension) {
	1176	+ sps->curr_pic_ref_enabled = get_bits1(gb);
	1177	+ sps->palette_mode_enabled = get_bits1(gb);
	1178	+ if (sps->palette_mode_enabled) {
1180	1179	sps->palette_max_size = get_ue_golomb(gb);
1181	1180	sps->delta_palette_max_predictor_size = get_ue_golomb(gb);
1182		− sps->sps_palette_predictor_initializers_present_flag = get_bits1(gb);
	1181	+ sps->palette_predictor_initializers_present = get_bits1(gb);
1183	1182
1184		− if (sps->sps_palette_predictor_initializers_present_flag) {
	1183	+ if (sps->palette_predictor_initializers_present) {
1185	1184	sps->sps_num_palette_predictor_initializers = get_ue_golomb(gb) + 1;
1186	1185	if (sps->sps_num_palette_predictor_initializers > HEVC_MAX_PALETTE_PREDICTOR_SIZE) {
1187	1186	av_log(avctx, AV_LOG_ERROR,
@@ -1198,7 +1197,7 @@ int ff_hevc_parse_sps(HEVCSPS sps, GetBitContext gb, unsigned int *sps_id, · 10 unmodified lines
1198	1197	}
1199	1198	}
1200	1199	sps->motion_vector_resolution_control_idc = get_bits(gb, 2);
1201		− sps->intra_boundary_filtering_disabled_flag = get_bits1(gb);
	1200	+ sps->intra_boundary_filtering_disabled = get_bits1(gb);
1202	1201	}
1203	1202	}
1204	1203	if (apply_defdispwin) {

libavcodec/hevc_ps.h+33−33

@@ -188,11 +188,9 @@ typedef struct ScalingList { · 187 unmodified lines
188	188	typedef struct HEVCSPS {
189	189	unsigned vps_id;
190	190	int chroma_format_idc;
191		− uint8_t separate_colour_plane_flag;
192	191
193	192	HEVCWindow output_window;
194	193
195		− uint8_t conformance_window_flag;
196	194	HEVCWindow pic_conf_win;
197	195
198	196	HEVCHdrParams hdr;
@@ -203,32 +201,23 @@ typedef struct HEVCSPS { · 4 unmodified lines
203	201	enum AVPixelFormat pix_fmt;
204	202
205	203	unsigned int log2_max_poc_lsb;
206		− int pcm_enabled_flag;
207	204
208		− uint8_t sublayer_ordering_info_flag;
209	205	int max_sub_layers;
210	206	struct {
211	207	int max_dec_pic_buffering;
212	208	int num_reorder_pics;
213	209	int max_latency_increase;
214	210	} temporal_layer[HEVC_MAX_SUB_LAYERS];
215		− uint8_t temporal_id_nesting_flag;
216	211
217	212	int vui_present;
218	213	VUI vui;
219	214	PTL ptl;
220	215
221		− uint8_t sps_extension_present_flag;
222		− uint8_t scaling_list_enable_flag;
223	216	ScalingList scaling_list;
224	217
225	218	unsigned int nb_st_rps;
226	219	ShortTermRPS st_rps[HEVC_MAX_SHORT_TERM_REF_PIC_SETS];
227	220
228		− uint8_t amp_enabled_flag;
229		− uint8_t sao_enabled;
230		−
231		− uint8_t long_term_ref_pics_present_flag;
232	221	uint16_t lt_ref_pic_poc_lsb_sps[HEVC_MAX_LONG_TERM_REF_PICS];
233	222	uint32_t used_by_curr_pic_lt;
234	223	uint8_t num_long_term_ref_pics_sps;
@@ -238,10 +227,7 @@ typedef struct HEVCSPS { · 3 unmodified lines
238	227	uint8_t bit_depth_chroma;
239	228	unsigned int log2_min_pcm_cb_size;
240	229	unsigned int log2_max_pcm_cb_size;
241		− uint8_t loop_filter_disable_flag;
242	230	} pcm;
243		− uint8_t sps_temporal_mvp_enabled_flag;
244		− uint8_t sps_strong_intra_smoothing_enable_flag;
245	231
246	232	unsigned int log2_min_cb_size;
247	233	unsigned int log2_diff_max_min_coding_block_size;
@@ -254,30 +240,44 @@ typedef struct HEVCSPS { · 6 unmodified lines
254	240	int max_transform_hierarchy_depth_inter;
255	241	int max_transform_hierarchy_depth_intra;
256	242
257		− int sps_range_extension_flag;
258		− int transform_skip_rotation_enabled_flag;
259		− int transform_skip_context_enabled_flag;
260		− int implicit_rdpcm_enabled_flag;
261		− int explicit_rdpcm_enabled_flag;
262		− int extended_precision_processing_flag;
263		− int intra_smoothing_disabled_flag;
264		− int high_precision_offsets_enabled_flag;
265		− int persistent_rice_adaptation_enabled_flag;
266		− int cabac_bypass_alignment_enabled_flag;
267		−
268		− int sps_multilayer_extension_flag;
269		− int sps_3d_extension_flag;
270		−
271		− int sps_scc_extension_flag;
272		− int sps_curr_pic_ref_enabled_flag;
273		− int palette_mode_enabled_flag;
	243	+ uint8_t separate_colour_plane;
	244	+ uint8_t conformance_window;
	245	+ uint8_t pcm_enabled;
	246	+ uint8_t pcm_loop_filter_disabled;
	247	+ uint8_t sublayer_ordering_info;
	248	+ uint8_t temporal_id_nesting;
	249	+ uint8_t extension_present;
	250	+ uint8_t scaling_list_enabled;
	251	+ uint8_t amp_enabled;
	252	+ uint8_t sao_enabled;
	253	+ uint8_t long_term_ref_pics_present;
	254	+ uint8_t temporal_mvp_enabled;
	255	+ uint8_t strong_intra_smoothing_enabled;
	256	+ uint8_t range_extension;
	257	+ uint8_t transform_skip_rotation_enabled;
	258	+ uint8_t transform_skip_context_enabled;
	259	+ uint8_t implicit_rdpcm_enabled;
	260	+ uint8_t explicit_rdpcm_enabled;
	261	+ uint8_t extended_precision_processing;
	262	+ uint8_t intra_smoothing_disabled;
	263	+ uint8_t high_precision_offsets_enabled;
	264	+ uint8_t persistent_rice_adaptation_enabled;
	265	+ uint8_t cabac_bypass_alignment_enabled;
	266	+
	267	+ uint8_t multilayer_extension;
	268	+ uint8_t sps_3d_extension;
	269	+
	270	+ uint8_t scc_extension;
	271	+ uint8_t curr_pic_ref_enabled;
	272	+ uint8_t palette_mode_enabled;
	273	+ uint8_t palette_predictor_initializers_present;
	274	+ uint8_t intra_boundary_filtering_disabled;
	275	+
274	276	int palette_max_size;
275	277	int delta_palette_max_predictor_size;
276		− int sps_palette_predictor_initializers_present_flag;
277	278	int sps_num_palette_predictor_initializers;
278	279	int sps_palette_predictor_initializer[3][HEVC_MAX_PALETTE_PREDICTOR_SIZE];
279	280	int motion_vector_resolution_control_idc;
280		− int intra_boundary_filtering_disabled_flag;
281	281
282	282	///< coded frame dimension in various units
283	283	int width;

libavcodec/hevcdec.c+5−5

@@ -272,7 +272,7 @@ static int decode_lt_rps(HEVCContext s, LongTermRPS rps, GetBitContext *gb) · 271 unmodified lines
272	272	int i;
273	273
274	274	rps->nb_refs = 0;
275		− if (!sps->long_term_ref_pics_present_flag)
	275	+ if (!sps->long_term_ref_pics_present)
276	276	return 0;
277	277
278	278	if (sps->num_long_term_ref_pics_sps > 0)
@@ -705,7 +705,7 @@ static int hls_slice_header(HEVCContext *s) · 426 unmodified lines
705	705	if (s->ps.pps->output_flag_present_flag)
706	706	sh->pic_output_flag = get_bits1(gb);
707	707
708		− if (s->ps.sps->separate_colour_plane_flag)
	708	+ if (s->ps.sps->separate_colour_plane)
709	709	sh->colour_plane_id = get_bits(gb, 2);
710	710
711	711	if (!IS_IDR(s)) {
@@ -753,7 +753,7 @@ static int hls_slice_header(HEVCContext *s) · 41 unmodified lines
753	753	}
754	754	sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
755	755
756		− if (s->ps.sps->sps_temporal_mvp_enabled_flag)
	756	+ if (s->ps.sps->temporal_mvp_enabled)
757	757	sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
758	758	else
759	759	sh->slice_temporal_mvp_enabled_flag = 0;
@@ -2294,7 +2294,7 @@ static int hls_coding_unit(HEVCLocalContext lc, const HEVCContext s, int x0, i · 1534 unmodified lines
2294	2294	}
2295	2295
2296	2296	if (lc->cu.pred_mode == MODE_INTRA) {
2297		− if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
	2297	+ if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled &&
2298	2298	log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2299	2299	log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2300	2300	pcm_flag = ff_hevc_pcm_flag_decode(lc);
@@ -2302,7 +2302,7 @@ static int hls_coding_unit(HEVCLocalContext lc, const HEVCContext s, int x0, i · 1 unmodified line
2302	2302	if (pcm_flag) {
2303	2303	intra_prediction_unit_default_value(lc, x0, y0, log2_cb_size);
2304	2304	ret = hls_pcm_sample(lc, x0, y0, log2_cb_size);
2305		− if (s->ps.sps->pcm.loop_filter_disable_flag)
	2305	+ if (s->ps.sps->pcm_loop_filter_disabled)
2306	2306	set_deblocking_bypass(s, x0, y0, log2_cb_size);
2307	2307
2308	2308	if (ret < 0)

libavcodec/hevcpred_template.c+2−2

@@ -285,14 +285,14 @@ do { \ · 284 unmodified lines
285	285	top[-1] = left[-1];
286	286
287	287	// Filtering process
288		− if (!s->ps.sps->intra_smoothing_disabled_flag && (c_idx == 0 \|\| s->ps.sps->chroma_format_idc == 3)) {
	288	+ if (!s->ps.sps->intra_smoothing_disabled && (c_idx == 0 \|\| s->ps.sps->chroma_format_idc == 3)) {
289	289	if (mode != INTRA_DC && size != 4){
290	290	int intra_hor_ver_dist_thresh[] = { 7, 1, 0 };
291	291	int min_dist_vert_hor = FFMIN(FFABS((int)(mode - 26U)),
292	292	FFABS((int)(mode - 10U)));
293	293	if (min_dist_vert_hor > intra_hor_ver_dist_thresh[log2_size - 3]) {
294	294	int threshold = 1 << (BIT_DEPTH - 5);
295		− if (s->ps.sps->sps_strong_intra_smoothing_enable_flag && c_idx == 0 &&
	295	+ if (s->ps.sps->strong_intra_smoothing_enabled && c_idx == 0 &&
296	296	log2_size == 5 &&
297	297	FFABS(top[-1] + top[63] - 2 * top[31]) < threshold &&
298	298	FFABS(left[-1] + left[63] - 2 * left[31]) < threshold) {

libavcodec/mips/hevcpred_msa.c+3−3

@@ -2369,7 +2369,7 @@ void ff_intra_pred_8_16x16_msa(HEVCLocalContext *lc, int x0, int y0, int c_idx) · 2368 unmodified lines
2369	2369	top[-1] = left[-1];
2370	2370
2371	2371
2372		− if (!s->ps.sps->intra_smoothing_disabled_flag
	2372	+ if (!s->ps.sps->intra_smoothing_disabled
2373	2373	&& (c_idx == 0 \|\| s->ps.sps->chroma_format_idc == 3)) {
2374	2374	if (mode != INTRA_DC && 16 != 4) {
2375	2375	int intra_hor_ver_dist_thresh[] = { 7, 1, 0 };
@@ -2886,7 +2886,7 @@ void ff_intra_pred_8_32x32_msa(HEVCLocalContext *lc, int x0, int y0, int c_idx) · 510 unmodified lines
2886	2886	top[-1] = left[-1];
2887	2887
2888	2888
2889		− if (!s->ps.sps->intra_smoothing_disabled_flag
	2889	+ if (!s->ps.sps->intra_smoothing_disabled
2890	2890	&& (c_idx == 0 \|\| s->ps.sps->chroma_format_idc == 3)) {
2891	2891	if (mode != INTRA_DC && 32 != 4) {
2892	2892	int intra_hor_ver_dist_thresh[] = { 7, 1, 0 };
@@ -2901,7 +2901,7 @@ void ff_intra_pred_8_32x32_msa(HEVCLocalContext *lc, int x0, int y0, int c_idx) · 8 unmodified lines
2901	2901	0 ? ((int) (mode - 26U)) : (-((int) (mode - 26U))))));
2902	2902	if (min_dist_vert_hor > intra_hor_ver_dist_thresh[5 - 3]) {
2903	2903	int threshold = 1 << (8 - 5);
2904		− if (s->ps.sps->sps_strong_intra_smoothing_enable_flag
	2904	+ if (s->ps.sps->strong_intra_smoothing_enabled
2905	2905	&& c_idx == 0
2906	2906	&& ((top[-1] + top[63] - 2 * top[31]) >=
2907	2907	0 ? (top[-1] + top[63] -

libavcodec/nvdec_hevc.c+21−21

@@ -105,44 +105,44 @@ static int nvdec_hevc_start_frame(AVCodecContext *avctx, · 104 unmodified lines
105	105	.log2_diff_max_min_luma_coding_block_size = sps->log2_diff_max_min_coding_block_size,
106	106	.log2_min_transform_block_size_minus2 = sps->log2_min_tb_size - 2,
107	107	.log2_diff_max_min_transform_block_size = sps->log2_max_trafo_size - sps->log2_min_tb_size,
108		− .pcm_enabled_flag = sps->pcm_enabled_flag,
109		− .log2_min_pcm_luma_coding_block_size_minus3 = sps->pcm_enabled_flag ? sps->pcm.log2_min_pcm_cb_size - 3 : 0,
	108	+ .pcm_enabled_flag = sps->pcm_enabled,
	109	+ .log2_min_pcm_luma_coding_block_size_minus3 = sps->pcm_enabled ? sps->pcm.log2_min_pcm_cb_size - 3 : 0,
110	110	.log2_diff_max_min_pcm_luma_coding_block_size = sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size,
111		− .pcm_sample_bit_depth_luma_minus1 = sps->pcm_enabled_flag ? sps->pcm.bit_depth - 1 : 0,
112		− .pcm_sample_bit_depth_chroma_minus1 = sps->pcm_enabled_flag ? sps->pcm.bit_depth_chroma - 1 : 0,
	111	+ .pcm_sample_bit_depth_luma_minus1 = sps->pcm_enabled ? sps->pcm.bit_depth - 1 : 0,
	112	+ .pcm_sample_bit_depth_chroma_minus1 = sps->pcm_enabled ? sps->pcm.bit_depth_chroma - 1 : 0,
113	113	#if NVDECAPI_CHECK_VERSION(8, 1)
114	114	.log2_max_transform_skip_block_size_minus2 = pps->log2_max_transform_skip_block_size - 2,
115	115	.log2_sao_offset_scale_luma = pps->log2_sao_offset_scale_luma,
116	116	.log2_sao_offset_scale_chroma = pps->log2_sao_offset_scale_chroma,
117		− .high_precision_offsets_enabled_flag = sps->high_precision_offsets_enabled_flag,
	117	+ .high_precision_offsets_enabled_flag = sps->high_precision_offsets_enabled,
118	118	#endif
119		− .pcm_loop_filter_disabled_flag = sps->pcm.loop_filter_disable_flag,
120		− .strong_intra_smoothing_enabled_flag = sps->sps_strong_intra_smoothing_enable_flag,
	119	+ .pcm_loop_filter_disabled_flag = sps->pcm_loop_filter_disabled,
	120	+ .strong_intra_smoothing_enabled_flag = sps->strong_intra_smoothing_enabled,
121	121	.max_transform_hierarchy_depth_intra = sps->max_transform_hierarchy_depth_intra,
122	122	.max_transform_hierarchy_depth_inter = sps->max_transform_hierarchy_depth_inter,
123		− .amp_enabled_flag = sps->amp_enabled_flag,
124		− .separate_colour_plane_flag = sps->separate_colour_plane_flag,
	123	+ .amp_enabled_flag = sps->amp_enabled,
	124	+ .separate_colour_plane_flag = sps->separate_colour_plane,
125	125	.log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4,
126	126	.num_short_term_ref_pic_sets = sps->nb_st_rps,
127		− .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present_flag,
	127	+ .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present,
128	128	.num_long_term_ref_pics_sps = sps->num_long_term_ref_pics_sps,
129		− .sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag,
	129	+ .sps_temporal_mvp_enabled_flag = sps->temporal_mvp_enabled,
130	130	.sample_adaptive_offset_enabled_flag = sps->sao_enabled,
131		− .scaling_list_enable_flag = sps->scaling_list_enable_flag,
	131	+ .scaling_list_enable_flag = sps->scaling_list_enabled,
132	132	.IrapPicFlag = IS_IRAP(s),
133	133	.IdrPicFlag = IS_IDR(s),
134	134	.bit_depth_luma_minus8 = sps->bit_depth - 8,
135	135	.bit_depth_chroma_minus8 = sps->bit_depth - 8,
136	136	#if NVDECAPI_CHECK_VERSION(9, 0)
137		− .sps_range_extension_flag = sps->sps_range_extension_flag,
138		− .transform_skip_rotation_enabled_flag = sps->transform_skip_rotation_enabled_flag,
139		− .transform_skip_context_enabled_flag = sps->transform_skip_context_enabled_flag,
140		− .implicit_rdpcm_enabled_flag = sps->implicit_rdpcm_enabled_flag,
141		− .explicit_rdpcm_enabled_flag = sps->explicit_rdpcm_enabled_flag,
142		− .extended_precision_processing_flag = sps->extended_precision_processing_flag,
143		− .intra_smoothing_disabled_flag = sps->intra_smoothing_disabled_flag,
144		− .persistent_rice_adaptation_enabled_flag = sps->persistent_rice_adaptation_enabled_flag,
145		− .cabac_bypass_alignment_enabled_flag = sps->cabac_bypass_alignment_enabled_flag,
	137	+ .sps_range_extension_flag = sps->range_extension,
	138	+ .transform_skip_rotation_enabled_flag = sps->transform_skip_rotation_enabled,
	139	+ .transform_skip_context_enabled_flag = sps->transform_skip_context_enabled,
	140	+ .implicit_rdpcm_enabled_flag = sps->implicit_rdpcm_enabled,
	141	+ .explicit_rdpcm_enabled_flag = sps->explicit_rdpcm_enabled,
	142	+ .extended_precision_processing_flag = sps->extended_precision_processing,
	143	+ .intra_smoothing_disabled_flag = sps->intra_smoothing_disabled,
	144	+ .persistent_rice_adaptation_enabled_flag = sps->persistent_rice_adaptation_enabled,
	145	+ .cabac_bypass_alignment_enabled_flag = sps->cabac_bypass_alignment_enabled,
146	146	#endif
147	147
148	148	.dependent_slice_segments_enabled_flag = pps->dependent_slice_segments_enabled_flag,

libavcodec/qsvenc_hevc.c+1−1

@@ -108,7 +108,7 @@ static int generate_fake_vps(QSVEncContext q, AVCodecContext avctx) · 107 unmodified lines
108	108	/* generate the VPS */
109	109	vps.vps_max_layers = 1;
110	110	vps.vps_max_sub_layers = sps.max_sub_layers;
111		− vps.vps_temporal_id_nesting_flag = sps.temporal_id_nesting_flag;
	111	+ vps.vps_temporal_id_nesting_flag = sps.temporal_id_nesting;
112	112	memcpy(&vps.ptl, &sps.ptl, sizeof(vps.ptl));
113	113	vps.vps_sub_layer_ordering_info_present_flag = 1;
114	114	for (i = 0; i < HEVC_MAX_SUB_LAYERS; i++) {

libavcodec/vaapi_hevc.c+21−21

@@ -171,12 +171,12 @@ static int vaapi_hevc_start_frame(AVCodecContext *avctx, · 170 unmodified lines
171	171	.pic_fields.bits = {
172	172	.chroma_format_idc = sps->chroma_format_idc,
173	173	.tiles_enabled_flag = pps->tiles_enabled_flag,
174		− .separate_colour_plane_flag = sps->separate_colour_plane_flag,
175		− .pcm_enabled_flag = sps->pcm_enabled_flag,
176		− .scaling_list_enabled_flag = sps->scaling_list_enable_flag,
	174	+ .separate_colour_plane_flag = sps->separate_colour_plane,
	175	+ .pcm_enabled_flag = sps->pcm_enabled,
	176	+ .scaling_list_enabled_flag = sps->scaling_list_enabled,
177	177	.transform_skip_enabled_flag = pps->transform_skip_enabled_flag,
178		− .amp_enabled_flag = sps->amp_enabled_flag,
179		− .strong_intra_smoothing_enabled_flag = sps->sps_strong_intra_smoothing_enable_flag,
	178	+ .amp_enabled_flag = sps->amp_enabled,
	179	+ .strong_intra_smoothing_enabled_flag = sps->strong_intra_smoothing_enabled,
180	180	.sign_data_hiding_enabled_flag = pps->sign_data_hiding_flag,
181	181	.constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
182	182	.cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag,
@@ -186,12 +186,12 @@ static int vaapi_hevc_start_frame(AVCodecContext *avctx, · 3 unmodified lines
186	186	.entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag,
187	187	.pps_loop_filter_across_slices_enabled_flag = pps->seq_loop_filter_across_slices_enabled_flag,
188	188	.loop_filter_across_tiles_enabled_flag = pps->loop_filter_across_tiles_enabled_flag,
189		− .pcm_loop_filter_disabled_flag = sps->pcm.loop_filter_disable_flag,
	189	+ .pcm_loop_filter_disabled_flag = sps->pcm_loop_filter_disabled,
190	190	},
191	191	.slice_parsing_fields.bits = {
192	192	.lists_modification_present_flag = pps->lists_modification_present_flag,
193		− .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present_flag,
194		− .sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag,
	193	+ .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present,
	194	+ .sps_temporal_mvp_enabled_flag = sps->temporal_mvp_enabled,
195	195	.cabac_init_present_flag = pps->cabac_init_present_flag,
196	196	.output_flag_present_flag = pps->output_flag_present_flag,
197	197	.dependent_slice_segments_enabled_flag = pps->dependent_slice_segments_enabled_flag,
@@ -231,15 +231,15 @@ static int vaapi_hevc_start_frame(AVCodecContext *avctx, · 33 unmodified lines
231	231	avctx->profile == AV_PROFILE_HEVC_SCC) {
232	232	pic->pic_param.rext = (VAPictureParameterBufferHEVCRext) {
233	233	.range_extension_pic_fields.bits = {
234		− .transform_skip_rotation_enabled_flag = sps->transform_skip_rotation_enabled_flag,
235		− .transform_skip_context_enabled_flag = sps->transform_skip_context_enabled_flag,
236		− .implicit_rdpcm_enabled_flag = sps->implicit_rdpcm_enabled_flag,
237		− .explicit_rdpcm_enabled_flag = sps->explicit_rdpcm_enabled_flag,
238		− .extended_precision_processing_flag = sps->extended_precision_processing_flag,
239		− .intra_smoothing_disabled_flag = sps->intra_smoothing_disabled_flag,
240		− .high_precision_offsets_enabled_flag = sps->high_precision_offsets_enabled_flag,
241		− .persistent_rice_adaptation_enabled_flag = sps->persistent_rice_adaptation_enabled_flag,
242		− .cabac_bypass_alignment_enabled_flag = sps->cabac_bypass_alignment_enabled_flag,
	234	+ .transform_skip_rotation_enabled_flag = sps->transform_skip_rotation_enabled,
	235	+ .transform_skip_context_enabled_flag = sps->transform_skip_context_enabled,
	236	+ .implicit_rdpcm_enabled_flag = sps->implicit_rdpcm_enabled,
	237	+ .explicit_rdpcm_enabled_flag = sps->explicit_rdpcm_enabled,
	238	+ .extended_precision_processing_flag = sps->extended_precision_processing,
	239	+ .intra_smoothing_disabled_flag = sps->intra_smoothing_disabled,
	240	+ .high_precision_offsets_enabled_flag = sps->high_precision_offsets_enabled,
	241	+ .persistent_rice_adaptation_enabled_flag = sps->persistent_rice_adaptation_enabled,
	242	+ .cabac_bypass_alignment_enabled_flag = sps->cabac_bypass_alignment_enabled,
243	243	.cross_component_prediction_enabled_flag = pps->cross_component_prediction_enabled_flag,
244	244	.chroma_qp_offset_list_enabled_flag = pps->chroma_qp_offset_list_enabled_flag,
245	245	},
@@ -258,7 +258,7 @@ static int vaapi_hevc_start_frame(AVCodecContext *avctx, · 12 unmodified lines
258	258
259	259	pre_palette_size = pps->pps_palette_predictor_initializers_present_flag ?
260	260	pps->pps_num_palette_predictor_initializers :
261		− (sps->sps_palette_predictor_initializers_present_flag ?
	261	+ (sps->palette_predictor_initializers_present ?
262	262	sps->sps_num_palette_predictor_initializers :
263	263	0);
264	264
@@ -266,9 +266,9 @@ static int vaapi_hevc_start_frame(AVCodecContext *avctx, · 1 unmodified line
266	266	pic->pic_param.scc = (VAPictureParameterBufferHEVCScc) {
267	267	.screen_content_pic_fields.bits = {
268	268	.pps_curr_pic_ref_enabled_flag = pps->pps_curr_pic_ref_enabled_flag,
269		− .palette_mode_enabled_flag = sps->palette_mode_enabled_flag,
	269	+ .palette_mode_enabled_flag = sps->palette_mode_enabled,
270	270	.motion_vector_resolution_control_idc = sps->motion_vector_resolution_control_idc,
271		− .intra_boundary_filtering_disabled_flag = sps->intra_boundary_filtering_disabled_flag,
	271	+ .intra_boundary_filtering_disabled_flag = sps->intra_boundary_filtering_disabled,
272	272	.residual_adaptive_colour_transform_enabled_flag
273	273	= pps->residual_adaptive_colour_transform_enabled_flag,
274	274	.pps_slice_act_qp_offsets_present_flag = pps->pps_slice_act_qp_offsets_present_flag,
@@ -305,7 +305,7 @@ static int vaapi_hevc_start_frame(AVCodecContext *avctx, · 30 unmodified lines
305	305
306	306	if (pps->scaling_list_data_present_flag)
307	307	scaling_list = &pps->scaling_list;
308		− else if (sps->scaling_list_enable_flag)
	308	+ else if (sps->scaling_list_enabled)
309	309	scaling_list = &sps->scaling_list;
310	310
311	311	if (scaling_list) {

libavcodec/vdpau_hevc.c+18−18

@@ -53,7 +53,7 @@ static int vdpau_hevc_start_frame(AVCodecContext *avctx, · 52 unmodified lines
53	53
54	54	/* SPS */
55	55	info->chroma_format_idc = sps->chroma_format_idc;
56		− info->separate_colour_plane_flag = sps->separate_colour_plane_flag;
	56	+ info->separate_colour_plane_flag = sps->separate_colour_plane;
57	57	info->pic_width_in_luma_samples = sps->width;
58	58	info->pic_height_in_luma_samples = sps->height;
59	59	info->bit_depth_luma_minus8 = sps->bit_depth - 8;
@@ -68,7 +68,7 @@ static int vdpau_hevc_start_frame(AVCodecContext *avctx, · 8 unmodified lines
68	68	info->log2_diff_max_min_transform_block_size = sps->log2_max_trafo_size - sps->log2_min_tb_size;
69	69	info->max_transform_hierarchy_depth_inter = sps->max_transform_hierarchy_depth_inter;
70	70	info->max_transform_hierarchy_depth_intra = sps->max_transform_hierarchy_depth_intra;
71		− info->scaling_list_enabled_flag = sps->scaling_list_enable_flag;
	71	+ info->scaling_list_enabled_flag = sps->scaling_list_enabled;
72	72	/* Scaling lists, in diagonal order, to be used for this frame. */
73	73	for (size_t i = 0; i < 6; i++) {
74	74	for (size_t j = 0; j < 16; j++) {
@@ -100,9 +100,9 @@ static int vdpau_hevc_start_frame(AVCodecContext *avctx, · 25 unmodified lines
100	100	info->ScalingListDCCoeff32x32[i] = sl->sl_dc[1][i * 3];
101	101	}
102	102	}
103		− info->amp_enabled_flag = sps->amp_enabled_flag;
	103	+ info->amp_enabled_flag = sps->amp_enabled;
104	104	info->sample_adaptive_offset_enabled_flag = sps->sao_enabled;
105		− info->pcm_enabled_flag = sps->pcm_enabled_flag;
	105	+ info->pcm_enabled_flag = sps->pcm_enabled;
106	106	if (info->pcm_enabled_flag) {
107	107	/* Only needs to be set if pcm_enabled_flag is set. Ignored otherwise. */
108	108	info->pcm_sample_bit_depth_luma_minus1 = sps->pcm.bit_depth - 1;
@@ -113,17 +113,17 @@ static int vdpau_hevc_start_frame(AVCodecContext *avctx, · 4 unmodified lines
113	113	/* Only needs to be set if pcm_enabled_flag is set. Ignored otherwise. */
114	114	info->log2_diff_max_min_pcm_luma_coding_block_size = sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size;
115	115	/* Only needs to be set if pcm_enabled_flag is set. Ignored otherwise. */
116		− info->pcm_loop_filter_disabled_flag = sps->pcm.loop_filter_disable_flag;
	116	+ info->pcm_loop_filter_disabled_flag = sps->pcm_loop_filter_disabled;
117	117	}
118	118	/* Per spec, when zero, assume short_term_ref_pic_set_sps_flag
119	119	is also zero. */
120	120	info->num_short_term_ref_pic_sets = sps->nb_st_rps;
121		− info->long_term_ref_pics_present_flag = sps->long_term_ref_pics_present_flag;
	121	+ info->long_term_ref_pics_present_flag = sps->long_term_ref_pics_present;
122	122	/* Only needed if long_term_ref_pics_present_flag is set. Ignored
123	123	otherwise. */
124	124	info->num_long_term_ref_pics_sps = sps->num_long_term_ref_pics_sps;
125		− info->sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag;
126		− info->strong_intra_smoothing_enabled_flag = sps->sps_strong_intra_smoothing_enable_flag;
	125	+ info->sps_temporal_mvp_enabled_flag = sps->temporal_mvp_enabled;
	126	+ info->strong_intra_smoothing_enabled_flag = sps->strong_intra_smoothing_enabled;
127	127
128	128	/* Copy the HEVC Picture Parameter Set bitstream fields. */
129	129	info->dependent_slice_segments_enabled_flag = pps->dependent_slice_segments_enabled_flag;
@@ -360,17 +360,17 @@ static int vdpau_hevc_start_frame(AVCodecContext *avctx, · 230 unmodified lines
360	360	}
361	361
362	362	#ifdef VDP_YCBCR_FORMAT_Y_U_V_444
363		− if (sps->sps_range_extension_flag) {
	363	+ if (sps->range_extension) {
364	364	info2->sps_range_extension_flag = 1;
365		− info2->transformSkipRotationEnableFlag = sps->transform_skip_rotation_enabled_flag;
366		− info2->transformSkipContextEnableFlag = sps->transform_skip_context_enabled_flag;
367		− info2->implicitRdpcmEnableFlag = sps->implicit_rdpcm_enabled_flag;
368		− info2->explicitRdpcmEnableFlag = sps->explicit_rdpcm_enabled_flag;
369		− info2->extendedPrecisionProcessingFlag = sps->extended_precision_processing_flag;
370		− info2->intraSmoothingDisabledFlag = sps->intra_smoothing_disabled_flag;
371		− info2->highPrecisionOffsetsEnableFlag = sps->high_precision_offsets_enabled_flag;
372		− info2->persistentRiceAdaptationEnableFlag = sps->persistent_rice_adaptation_enabled_flag;
373		− info2->cabacBypassAlignmentEnableFlag = sps->cabac_bypass_alignment_enabled_flag;
	365	+ info2->transformSkipRotationEnableFlag = sps->transform_skip_rotation_enabled;
	366	+ info2->transformSkipContextEnableFlag = sps->transform_skip_context_enabled;
	367	+ info2->implicitRdpcmEnableFlag = sps->implicit_rdpcm_enabled;
	368	+ info2->explicitRdpcmEnableFlag = sps->explicit_rdpcm_enabled;
	369	+ info2->extendedPrecisionProcessingFlag = sps->extended_precision_processing;
	370	+ info2->intraSmoothingDisabledFlag = sps->intra_smoothing_disabled;
	371	+ info2->highPrecisionOffsetsEnableFlag = sps->high_precision_offsets_enabled;
	372	+ info2->persistentRiceAdaptationEnableFlag = sps->persistent_rice_adaptation_enabled;
	373	+ info2->cabacBypassAlignmentEnableFlag = sps->cabac_bypass_alignment_enabled;
374	374	} else {
375	375	info2->sps_range_extension_flag = 0;
376	376	}

libavcodec/vulkan_hevc.c+28−28

@@ -395,36 +395,36 @@ static void set_sps(const HEVCSPS *sps, int sps_idx, · 394 unmodified lines
395	395
396	396	*vksps = (StdVideoH265SequenceParameterSet) {
397	397	.flags = (StdVideoH265SpsFlags) {
398		− .sps_temporal_id_nesting_flag = sps->temporal_id_nesting_flag,
399		− .separate_colour_plane_flag = sps->separate_colour_plane_flag,
400		− .conformance_window_flag = sps->conformance_window_flag,
401		− .sps_sub_layer_ordering_info_present_flag = sps->sublayer_ordering_info_flag,
402		− .scaling_list_enabled_flag = sps->scaling_list_enable_flag,
403		− .sps_scaling_list_data_present_flag = sps->scaling_list_enable_flag,
404		− .amp_enabled_flag = sps->amp_enabled_flag,
	398	+ .sps_temporal_id_nesting_flag = sps->temporal_id_nesting,
	399	+ .separate_colour_plane_flag = sps->separate_colour_plane,
	400	+ .conformance_window_flag = sps->conformance_window,
	401	+ .sps_sub_layer_ordering_info_present_flag = sps->sublayer_ordering_info,
	402	+ .scaling_list_enabled_flag = sps->scaling_list_enabled,
	403	+ .sps_scaling_list_data_present_flag = sps->scaling_list_enabled,
	404	+ .amp_enabled_flag = sps->amp_enabled,
405	405	.sample_adaptive_offset_enabled_flag = sps->sao_enabled,
406		− .pcm_enabled_flag = sps->pcm_enabled_flag,
407		− .pcm_loop_filter_disabled_flag = sps->pcm.loop_filter_disable_flag,
408		− .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present_flag,
409		− .sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag,
410		− .strong_intra_smoothing_enabled_flag = sps->sps_strong_intra_smoothing_enable_flag,
	406	+ .pcm_enabled_flag = sps->pcm_enabled,
	407	+ .pcm_loop_filter_disabled_flag = sps->pcm_loop_filter_disabled,
	408	+ .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present,
	409	+ .sps_temporal_mvp_enabled_flag = sps->temporal_mvp_enabled,
	410	+ .strong_intra_smoothing_enabled_flag = sps->strong_intra_smoothing_enabled,
411	411	.vui_parameters_present_flag = sps->vui_present,
412		− .sps_extension_present_flag = sps->sps_extension_present_flag,
413		− .sps_range_extension_flag = sps->sps_range_extension_flag,
414		− .transform_skip_rotation_enabled_flag = sps->transform_skip_rotation_enabled_flag,
415		− .transform_skip_context_enabled_flag = sps->transform_skip_context_enabled_flag,
416		− .implicit_rdpcm_enabled_flag = sps->implicit_rdpcm_enabled_flag,
417		− .explicit_rdpcm_enabled_flag = sps->explicit_rdpcm_enabled_flag,
418		− .extended_precision_processing_flag = sps->extended_precision_processing_flag,
419		− .intra_smoothing_disabled_flag = sps->intra_smoothing_disabled_flag,
420		− .high_precision_offsets_enabled_flag = sps->high_precision_offsets_enabled_flag,
421		− .persistent_rice_adaptation_enabled_flag = sps->persistent_rice_adaptation_enabled_flag,
422		− .cabac_bypass_alignment_enabled_flag = sps->cabac_bypass_alignment_enabled_flag,
423		− .sps_scc_extension_flag = sps->sps_scc_extension_flag,
424		− .sps_curr_pic_ref_enabled_flag = sps->sps_curr_pic_ref_enabled_flag,
425		− .palette_mode_enabled_flag = sps->palette_mode_enabled_flag,
426		− .sps_palette_predictor_initializers_present_flag = sps->sps_palette_predictor_initializers_present_flag,
427		− .intra_boundary_filtering_disabled_flag = sps->intra_boundary_filtering_disabled_flag,
	412	+ .sps_extension_present_flag = sps->extension_present,
	413	+ .sps_range_extension_flag = sps->range_extension,
	414	+ .transform_skip_rotation_enabled_flag = sps->transform_skip_rotation_enabled,
	415	+ .transform_skip_context_enabled_flag = sps->transform_skip_context_enabled,
	416	+ .implicit_rdpcm_enabled_flag = sps->implicit_rdpcm_enabled,
	417	+ .explicit_rdpcm_enabled_flag = sps->explicit_rdpcm_enabled,
	418	+ .extended_precision_processing_flag = sps->extended_precision_processing,
	419	+ .intra_smoothing_disabled_flag = sps->intra_smoothing_disabled,
	420	+ .high_precision_offsets_enabled_flag = sps->high_precision_offsets_enabled,
	421	+ .persistent_rice_adaptation_enabled_flag = sps->persistent_rice_adaptation_enabled,
	422	+ .cabac_bypass_alignment_enabled_flag = sps->cabac_bypass_alignment_enabled,
	423	+ .sps_scc_extension_flag = sps->scc_extension,
	424	+ .sps_curr_pic_ref_enabled_flag = sps->curr_pic_ref_enabled,
	425	+ .palette_mode_enabled_flag = sps->palette_mode_enabled,
	426	+ .sps_palette_predictor_initializers_present_flag = sps->palette_predictor_initializers_present,
	427	+ .intra_boundary_filtering_disabled_flag = sps->intra_boundary_filtering_disabled,
428	428	},
429	429	.chroma_format_idc = sps->chroma_format_idc,
430	430	.pic_width_in_luma_samples = sps->width,

lavc/hevc_ps/HEVCSPS: change flags into uint8_t

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code