36 16, 16, 16, 16, 17, 18, 21, 24,
37 16, 16, 16, 16, 17, 19, 22, 25,
38 16, 16, 17, 18, 20, 22, 25, 29,
39 16, 16, 18, 21, 24, 27, 31, 36,
40 17, 17, 20, 24, 30, 35, 41, 47,
41 18, 19, 22, 27, 35, 44, 54, 65,
42 21, 22, 25, 31, 41, 54, 70, 88,
43 24, 25, 29, 36, 47, 65, 88, 115
47 16, 16, 16, 16, 17, 18, 20, 24,
48 16, 16, 16, 17, 18, 20, 24, 25,
49 16, 16, 17, 18, 20, 24, 25, 28,
50 16, 17, 18, 20, 24, 25, 28, 33,
51 17, 18, 20, 24, 25, 28, 33, 41,
52 18, 20, 24, 25, 28, 33, 41, 54,
53 20, 24, 25, 28, 33, 41, 54, 71,
54 24, 25, 28, 33, 41, 54, 71, 91
68 if (
s->sps_list[
id]) {
71 if (
s->pps_list[
i] &&
s->pps_list[
i]->sps_id ==
id)
81 if (
s->vps_list[
id]) {
83 if (
s->sps_list[
i] &&
s->sps_list[
i]->vps_id ==
id)
100 if (rps !=
sps->st_rps &&
sps->nb_st_rps)
105 uint8_t used[32] = { 0 };
108 if (is_slice_header) {
112 "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
119 rps_ridx = &
sps->st_rps[rps -
sps->st_rps - 1];
125 "Invalid value of abs_delta_rps: %d\n",
138 if (i < rps_ridx->num_delta_pocs)
139 delta_poc = delta_rps + rps_ridx->
delta_poc[
i];
141 delta_poc = delta_rps;
151 "Invalid num_delta_pocs: %d\n", k);
163 for (k =
i - 1; k >= 0; k--) {
165 if (delta_poc <
tmp) {
167 used[k + 1] = used[k];
190 rps->
used |= (uint32_t)used[
i] <<
i;
192 unsigned int nb_positive_pics;
209 if (delta_poc < 1 || delta_poc > 32768) {
211 "Invalid value of delta_poc: %d\n",
220 for (
i = 0;
i < nb_positive_pics;
i++) {
222 if (delta_poc < 1 || delta_poc > 32768) {
224 "Invalid value of delta_poc: %d\n",
241 const char *profile_name =
NULL;
259 "%s profile bitstream\n", profile_name ? profile_name :
"Unknown");
261 for (
i = 0;
i < 32;
i++) {
264 if (
ptl->profile_idc == 0 &&
i > 0 &&
ptl->profile_compatibility_flag[
i])
265 ptl->profile_idc =
i;
272 #define check_profile_idc(idc) \
273 ptl->profile_idc == idc || ptl->profile_compatibility_flag[idc]
308 #undef check_profile_idc
314 int profile_present,
PTL *
ptl,
int max_num_sub_layers)
318 if (profile_present) {
321 memset(&
ptl->general_ptl, 0,
sizeof(
ptl->general_ptl));
331 for (
i = 0;
i < max_num_sub_layers - 1;
i++) {
336 if (max_num_sub_layers - 1> 0)
337 for (
i = max_num_sub_layers - 1;
i < 8;
i++)
339 for (
i = 0;
i < max_num_sub_layers - 1;
i++) {
343 "PTL information for sublayer %i too short\n",
i);
349 "Not enough data for sublayer %i level_idc\n",
i);
364 for (
i = 0;
i < nb_cpb;
i++) {
368 if (subpic_params_present) {
380 if (common_inf_present) {
407 for (
int i = 0;
i < max_sublayers;
i++) {
408 unsigned fixed_pic_rate_general_flag =
get_bits1(gb);
409 unsigned fixed_pic_rate_within_cvs_flag = 0;
410 unsigned low_delay_hrd_flag = 0;
413 if (!fixed_pic_rate_general_flag)
414 fixed_pic_rate_within_cvs_flag =
get_bits1(gb);
417 if (fixed_pic_rate_within_cvs_flag || fixed_pic_rate_general_flag)
423 if (!low_delay_hrd_flag) {
425 if (cpb_cnt_minus1 > 31) {
460 uint64_t layer1_id_included)
464 uint8_t dimension_id_len[16] = {0};
465 uint8_t dimension_id[16] = {0};
468 int splitting_flag, view_id_len, num_add_olss, num_scalability_types,
469 default_output_layer_idc, direct_dep_type_len, direct_dep_type,
470 sub_layers_max_present, sub_layer_flag_info_present_flag, nb_ptl;
471 unsigned non_vui_extension_length;
473 if (
vps->vps_max_layers == 1) {
478 if (
vps->vps_max_layers > 2) {
480 "VPS has %d layers, only 2 layers are supported\n",
481 vps->vps_max_layers);
484 if (
vps->vps_num_layer_sets > 2) {
486 "VPS has %d layer sets, only 2 layer sets are supported\n",
487 vps->vps_num_layer_sets);
527 if (
parse_ptl(gb, avctx, 0, &ptl_dummy,
vps->vps_max_sub_layers) < 0)
533 if (!num_scalability_types) {
538 if (!(
vps->scalability_mask_flag &
541 15 -
ff_ctz(
vps->scalability_mask_flag));
545 if (num_scalability_types > 1)
549 for (
int i = 0;
i < num_scalability_types - splitting_flag;
i++) {
550 dimension_id_len[
i] =
get_bits(gb, 3) + 1;
551 n += dimension_id_len[
i];
554 dimension_id_len[num_scalability_types - 1] = 5 - n;
557 int layer_id_in_nuh =
get_bits(gb, 6);
563 vps->layer_idx[layer_id_in_nuh] = 1;
564 vps->layer_id_in_nuh[1] = layer_id_in_nuh;
566 vps->layer_idx[1] = 1;
567 vps->layer_id_in_nuh[1] = 1;
570 if (!splitting_flag) {
573 for (
int i = 0;
i < num_scalability_types;
i++)
574 dimension_id[
i] =
get_bits(gb, dimension_id_len[
i]);
583 "Unsupported dimension_id %d for HEVC_SCALABILITY_AUXILIARY\n",
584 dimension_id[
index]);
592 for (
int i = 0;
i < n;
i++)
598 if (!
vps->num_direct_ref_layers[1]) {
600 if (
vps->num_add_layer_sets > 1) {
602 "Unsupported num_add_layer_sets: %d\n",
vps->num_add_layer_sets);
606 if (
vps->num_add_layer_sets) {
612 vps->num_output_layer_sets =
vps->vps_num_layer_sets +
vps->num_add_layer_sets;
613 if (
vps->num_output_layer_sets != 2)
617 if (sub_layers_max_present) {
618 for (
int i = 0;
i <
vps->vps_max_layers;
i++)
619 max_sub_layers[
i] = sub_layers_max_present ?
get_bits(gb, 3) + 1 :
620 vps->vps_max_sub_layers;
632 for (
int i = 2;
i < nb_ptl;
i++) {
634 if (
parse_ptl(gb, avctx, profile_present, &ptl_dummy,
vps->vps_max_sub_layers) < 0)
639 if (num_add_olss != 0) {
646 default_output_layer_idc =
get_bits(gb, 2);
647 if (default_output_layer_idc != 0) {
649 default_output_layer_idc);
654 if (layer1_id_included &&
655 layer1_id_included != ((1 <<
vps->layer_id_in_nuh[0]) |
656 (1 <<
vps->layer_id_in_nuh[1]))) {
658 "Dependent layer not included in layer ID?\n");
661 if (!layer1_id_included)
666 if (
vps->vps_num_layer_sets == 1 || default_output_layer_idc == 2)
671 if (ptl_idx >= nb_ptl) {
682 vps->rep_format.pic_width_in_luma_samples =
get_bits(gb, 16);
683 vps->rep_format.pic_height_in_luma_samples =
get_bits(gb, 16);
687 "chroma_and_bit_depth_vps_present_flag=0 in first rep_format\n");
690 vps->rep_format.chroma_format_idc =
get_bits(gb, 2);
691 if (
vps->rep_format.chroma_format_idc == 3)
692 vps->rep_format.separate_colour_plane_flag =
get_bits1(gb);
693 vps->rep_format.bit_depth_luma =
get_bits(gb, 4) + 8;
694 vps->rep_format.bit_depth_chroma =
get_bits(gb, 4) + 8;
695 if (
vps->rep_format.bit_depth_luma > 16 ||
696 vps->rep_format.bit_depth_chroma > 16 ||
697 vps->rep_format.bit_depth_luma !=
vps->rep_format.bit_depth_chroma) {
699 vps->rep_format.bit_depth_luma,
vps->rep_format.bit_depth_chroma);
714 if (!
vps->num_direct_ref_layers[1])
717 sub_layer_flag_info_present_flag =
get_bits1(gb);
718 for (
int j = 0; j <
FFMAX(max_sub_layers[0], max_sub_layers[1]); j++) {
719 int sub_layer_dpb_info_present_flag = 1;
720 if (j > 0 && sub_layer_flag_info_present_flag)
721 sub_layer_dpb_info_present_flag =
get_bits1(gb);
722 if (sub_layer_dpb_info_present_flag) {
731 if (direct_dep_type_len > 32) {
733 direct_dep_type_len);
748 if (non_vui_extension_length > 4096) {
750 non_vui_extension_length);
768 uint64_t layer1_id_included = 0;
769 unsigned vps_base_layer_internal_flag, vps_base_layer_available_flag;
785 vps->data_size = nal_size;
791 vps->vps_id = vps_id;
793 vps_base_layer_internal_flag =
get_bits1(gb);
794 vps_base_layer_available_flag =
get_bits1(gb);
795 if (!vps_base_layer_internal_flag || !vps_base_layer_available_flag) {
797 "vps_base_layer_internal_flag or vps_base_layer_available_flag not set\n");
813 vps->vps_max_sub_layers);
820 vps->vps_sub_layer_ordering_info_present_flag =
get_bits1(gb);
822 i =
vps->vps_sub_layer_ordering_info_present_flag ? 0 :
vps->vps_max_sub_layers - 1;
823 for (;
i <
vps->vps_max_sub_layers;
i++) {
830 vps->vps_max_dec_pic_buffering[
i] - 1);
833 if (
vps->vps_num_reorder_pics[
i] >
vps->vps_max_dec_pic_buffering[
i] - 1) {
835 vps->vps_num_reorder_pics[
i]);
843 if (
vps->vps_num_layer_sets < 1 ||
vps->vps_num_layer_sets > 1024 ||
849 vps->num_output_layer_sets = 1;
853 if (
vps->vps_num_layer_sets > 1)
854 layer1_id_included =
get_bits64(gb,
vps->vps_max_layer_id + 1);
855 if (
vps->vps_num_layer_sets > 2)
859 if (
vps->vps_timing_info_present_flag) {
862 vps->vps_poc_proportional_to_timing_flag =
get_bits1(gb);
863 if (
vps->vps_poc_proportional_to_timing_flag)
866 if (
vps->vps_num_hrd_parameters > (
unsigned)
vps->vps_num_layer_sets) {
868 "vps_num_hrd_parameters %d is invalid\n",
vps->vps_num_hrd_parameters);
872 if (
vps->vps_num_hrd_parameters) {
878 for (
i = 0;
i <
vps->vps_num_hrd_parameters;
i++) {
879 int common_inf_present = 1;
885 vps->vps_max_sub_layers);
890 vps->layer_idx[0] = 0;
892 vps->layer_idx[
i] = -1;
924 VUI backup_vui, *vui = &
sps->vui;
935 switch (
sps->pix_fmt) {
955 memcpy(&backup, gb,
sizeof(backup));
956 memcpy(&backup_vui, vui,
sizeof(backup_vui));
971 if (apply_defdispwin &&
974 "discarding vui default display window, "
975 "original values are l:%u r:%u t:%u b:%u\n",
996 "Strange VUI timing information, retrying...\n");
997 memcpy(vui, &backup_vui,
sizeof(backup_vui));
998 memcpy(gb, &backup,
sizeof(backup));
1020 "Strange VUI bitstream restriction information, retrying"
1021 " from timing information...\n");
1022 memcpy(vui, &backup_vui,
sizeof(backup_vui));
1023 memcpy(gb, &backup,
sizeof(backup));
1040 "Overread in VUI, retrying from timing information...\n");
1041 memcpy(vui, &backup_vui,
sizeof(backup_vui));
1042 memcpy(gb, &backup,
sizeof(backup));
1052 for (matrixId = 0; matrixId < 6; matrixId++) {
1054 memset(sl->
sl[0][matrixId], 16, 16);
1055 sl->
sl_dc[0][matrixId] = 16;
1056 sl->
sl_dc[1][matrixId] = 16;
1081 uint8_t scaling_list_pred_mode_flag;
1082 uint8_t scaling_list_dc_coef[2][6];
1083 int size_id, matrix_id,
pos;
1086 for (size_id = 0; size_id < 4; size_id++)
1087 for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
1088 scaling_list_pred_mode_flag =
get_bits1(gb);
1089 if (!scaling_list_pred_mode_flag) {
1095 delta *= (size_id == 3) ? 3 : 1;
1096 if (matrix_id <
delta) {
1098 "Invalid delta in scaling list data: %d.\n",
delta);
1102 memcpy(sl->
sl[size_id][matrix_id],
1103 sl->
sl[size_id][matrix_id -
delta],
1104 size_id > 0 ? 64 : 16);
1106 sl->
sl_dc[size_id - 2][matrix_id] = sl->
sl_dc[size_id - 2][matrix_id -
delta];
1109 int next_coef, coef_num;
1110 int32_t scaling_list_delta_coef;
1113 coef_num =
FFMIN(64, 1 << (4 + (size_id << 1)));
1116 if (scaling_list_coeff_minus8 < -7 ||
1117 scaling_list_coeff_minus8 > 247)
1119 scaling_list_dc_coef[size_id - 2][matrix_id] = scaling_list_coeff_minus8 + 8;
1120 next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
1121 sl->
sl_dc[size_id - 2][matrix_id] = next_coef;
1123 for (
i = 0;
i < coef_num;
i++) {
1132 next_coef = (next_coef + 256
U + scaling_list_delta_coef) % 256;
1133 sl->
sl[size_id][matrix_id][
pos] = next_coef;
1138 if (
sps->chroma_format_idc == 3) {
1139 for (
i = 0;
i < 64;
i++) {
1140 sl->
sl[3][1][
i] = sl->
sl[2][1][
i];
1141 sl->
sl[3][2][
i] = sl->
sl[2][2][
i];
1142 sl->
sl[3][4][
i] = sl->
sl[2][4][
i];
1143 sl->
sl[3][5][
i] = sl->
sl[2][5][
i];
1158 switch (
sps->bit_depth) {
1185 "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
1186 "chroma_format_idc is %d, depth is %d\n",
1187 sps->chroma_format_idc,
sps->bit_depth);
1195 sps->hshift[0] =
sps->vshift[0] = 0;
1196 sps->hshift[2] =
sps->hshift[1] =
desc->log2_chroma_w;
1197 sps->vshift[2] =
sps->vshift[1] =
desc->log2_chroma_h;
1199 sps->pixel_shift =
sps->bit_depth > 8;
1205 unsigned nuh_layer_id,
int apply_defdispwin,
1210 int bit_depth_chroma, num_comps, multi_layer_ext;
1211 int vps_max_sub_layers;
1219 if (!vps_list[
sps->vps_id]) {
1228 multi_layer_ext = nuh_layer_id > 0 &&
1230 if (multi_layer_ext) {
1234 sps->max_sub_layers =
sps->vps->vps_max_sub_layers;
1236 vps_max_sub_layers =
sps->vps ?
sps->vps->vps_max_sub_layers
1239 if (
sps->max_sub_layers > vps_max_sub_layers) {
1241 sps->max_sub_layers);
1245 if (!multi_layer_ext) {
1251 sps->temporal_id_nesting =
sps->max_sub_layers > 1 ?
1252 sps->vps->vps_max_sub_layers : 1;
1261 if (multi_layer_ext) {
1264 if (
sps->vps->nb_layers == 1) {
1277 sps->chroma_format_idc =
sps->separate_colour_plane ? 0 :
1290 if (
sps->chroma_format_idc > 3
U) {
1295 if (
sps->chroma_format_idc == 3)
1298 if (
sps->separate_colour_plane)
1299 sps->chroma_format_idc = 0;
1304 sps->height, 0, avctx)) < 0)
1308 if (
sps->conformance_window) {
1318 "discarding sps conformance window, "
1319 "original values are l:%u r:%u t:%u b:%u\n",
1320 sps->pic_conf_win.left_offset,
1321 sps->pic_conf_win.right_offset,
1322 sps->pic_conf_win.top_offset,
1323 sps->pic_conf_win.bottom_offset);
1325 sps->pic_conf_win.left_offset =
1326 sps->pic_conf_win.right_offset =
1327 sps->pic_conf_win.top_offset =
1328 sps->pic_conf_win.bottom_offset = 0;
1333 if (
sps->bit_depth > 16) {
1339 if (bit_depth_chroma > 16) {
1344 if (
sps->chroma_format_idc && bit_depth_chroma !=
sps->bit_depth) {
1346 "Luma bit depth (%d) is different from chroma bit depth (%d), "
1347 "this is unsupported.\n",
1348 sps->bit_depth, bit_depth_chroma);
1351 sps->bit_depth_chroma = bit_depth_chroma;
1354 sps->output_window =
sps->pic_conf_win;
1361 if (
sps->log2_max_poc_lsb > 16) {
1363 sps->log2_max_poc_lsb - 4);
1367 if (!multi_layer_ext) {
1371 start =
sps->sublayer_ordering_info ? 0 :
sps->max_sub_layers - 1;
1372 for (
i = start;
i <
sps->max_sub_layers;
i++) {
1378 sps->temporal_layer[
i].max_dec_pic_buffering - 1
U);
1381 if (
sps->temporal_layer[
i].num_reorder_pics >
sps->temporal_layer[
i].max_dec_pic_buffering - 1) {
1383 sps->temporal_layer[
i].num_reorder_pics);
1388 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[
i].num_reorder_pics + 1;
1392 if (!
sps->sublayer_ordering_info) {
1393 for (
i = 0;
i < start;
i++) {
1394 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[start].max_dec_pic_buffering;
1395 sps->temporal_layer[
i].num_reorder_pics =
sps->temporal_layer[start].num_reorder_pics;
1396 sps->temporal_layer[
i].max_latency_increase =
sps->temporal_layer[start].max_latency_increase;
1400 for (
int i = 0;
i <
sps->max_sub_layers;
i++) {
1401 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->vps->dpb_size.max_dec_pic_buffering;
1402 sps->temporal_layer[
i].num_reorder_pics =
sps->vps->dpb_size.max_num_reorder_pics;
1403 sps->temporal_layer[
i].max_latency_increase =
sps->vps->dpb_size.max_latency_increase;
1411 sps->log2_max_trafo_size =
sps->log2_diff_max_min_transform_block_size +
1412 sps->log2_min_tb_size;
1414 if (
sps->log2_min_cb_size < 3 ||
sps->log2_min_cb_size > 30) {
1419 if (
sps->log2_diff_max_min_coding_block_size > 30) {
1420 av_log(avctx,
AV_LOG_ERROR,
"Invalid value %d for log2_diff_max_min_coding_block_size",
sps->log2_diff_max_min_coding_block_size);
1424 if (
sps->log2_min_tb_size >=
sps->log2_min_cb_size ||
sps->log2_min_tb_size < 2) {
1429 if (
sps->log2_diff_max_min_transform_block_size > 30) {
1430 av_log(avctx,
AV_LOG_ERROR,
"Invalid value %d for log2_diff_max_min_transform_block_size",
1431 sps->log2_diff_max_min_transform_block_size);
1439 if (
sps->scaling_list_enabled) {
1458 if (
sps->pcm_enabled) {
1462 sps->pcm.log2_max_pcm_cb_size =
sps->pcm.log2_min_pcm_cb_size +
1464 if (
FFMAX(
sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma) >
sps->bit_depth) {
1466 "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1467 sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma,
sps->bit_depth);
1480 for (
i = 0;
i <
sps->nb_st_rps;
i++) {
1487 if (
sps->long_term_ref_pics_present) {
1491 sps->num_long_term_ref_pics_sps);
1495 sps->used_by_curr_pic_lt = 0;
1496 for (
i = 0;
i <
sps->num_long_term_ref_pics_sps;
i++) {
1506 if (
sps->vui_present)
1510 if (
sps->extension_present) {
1517 if (
sps->range_extension) {
1524 if (
sps->extended_precision_processing)
1526 "extended_precision_processing_flag not yet implemented\n");
1530 if (
sps->high_precision_offsets_enabled)
1532 "high_precision_offsets_enabled_flag not yet implemented\n");
1534 sps->persistent_rice_adaptation_enabled =
get_bits1(gb);
1537 if (
sps->cabac_bypass_alignment_enabled)
1539 "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1542 if (
sps->multilayer_extension) {
1546 if (
sps->sps_3d_extension) {
1547 for (
i = 0;
i <= 1;
i++) {
1567 "sps_3d_extension_flag not yet implemented\n");
1570 if (
sps->scc_extension) {
1573 if (
sps->palette_mode_enabled) {
1576 sps->palette_predictor_initializers_present =
get_bits1(gb);
1578 if (
sps->palette_predictor_initializers_present) {
1582 "sps_num_palette_predictor_initializers out of range: %u\n",
1583 sps->sps_num_palette_predictor_initializers);
1586 num_comps = !
sps->chroma_format_idc ? 1 : 3;
1589 for (
i = 0;
i <
sps->sps_num_palette_predictor_initializers;
i++)
1594 sps->motion_vector_resolution_control_idc =
get_bits(gb, 2);
1595 sps->intra_boundary_filtering_disabled =
get_bits1(gb);
1598 if (apply_defdispwin) {
1599 sps->output_window.left_offset +=
sps->vui.def_disp_win.left_offset;
1600 sps->output_window.right_offset +=
sps->vui.def_disp_win.right_offset;
1601 sps->output_window.top_offset +=
sps->vui.def_disp_win.top_offset;
1602 sps->output_window.bottom_offset +=
sps->vui.def_disp_win.bottom_offset;
1605 ow = &
sps->output_window;
1616 "Displaying the whole video surface.\n");
1617 memset(ow, 0,
sizeof(*ow));
1618 memset(&
sps->pic_conf_win, 0,
sizeof(
sps->pic_conf_win));
1622 sps->log2_ctb_size =
sps->log2_min_cb_size +
1623 sps->log2_diff_max_min_coding_block_size;
1624 sps->log2_min_pu_size =
sps->log2_min_cb_size - 1;
1630 if (
sps->log2_ctb_size < 4) {
1633 "log2_ctb_size %d differs from the bounds of any known profile\n",
1634 sps->log2_ctb_size);
1639 sps->ctb_width = (
sps->width + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1640 sps->ctb_height = (
sps->height + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1641 sps->ctb_size =
sps->ctb_width *
sps->ctb_height;
1643 sps->min_cb_width =
sps->width >>
sps->log2_min_cb_size;
1644 sps->min_cb_height =
sps->height >>
sps->log2_min_cb_size;
1645 sps->min_tb_width =
sps->width >>
sps->log2_min_tb_size;
1646 sps->min_tb_height =
sps->height >>
sps->log2_min_tb_size;
1647 sps->min_pu_width =
sps->width >>
sps->log2_min_pu_size;
1648 sps->min_pu_height =
sps->height >>
sps->log2_min_pu_size;
1649 sps->tb_mask = (1 << (
sps->log2_ctb_size -
sps->log2_min_tb_size)) - 1;
1651 sps->qp_bd_offset = 6 * (
sps->bit_depth - 8);
1659 if (
sps->max_transform_hierarchy_depth_inter >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1660 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_inter out of range: %d\n",
1661 sps->max_transform_hierarchy_depth_inter);
1664 if (
sps->max_transform_hierarchy_depth_intra >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1665 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_intra out of range: %d\n",
1666 sps->max_transform_hierarchy_depth_intra);
1669 if (
sps->log2_max_trafo_size >
FFMIN(
sps->log2_ctb_size, 5)) {
1671 "max transform block size out of range: %d\n",
1672 sps->log2_max_trafo_size);
1702 int apply_defdispwin)
1721 nuh_layer_id, apply_defdispwin,
1728 "Parsed SPS: id %d; coded wxh: %dx%d; "
1729 "cropped wxh: %dx%d; pix_fmt: %s.\n",
1731 sps->width - (
sps->output_window.left_offset +
sps->output_window.right_offset),
1732 sps->height - (
sps->output_window.top_offset +
sps->output_window.bottom_offset),
1773 int idx_y,
int idx_cb,
int idx_cr,
int inp_length)
1775 unsigned int split_octant_flag, part_num_y, coded_res_flag, res_coeff_q, res_coeff_r;
1778 part_num_y = 1 <<
pps->cm_y_part_num_log2;
1780 split_octant_flag = inp_depth <
pps->cm_octant_depth ?
get_bits1(gb) : 0;
1782 if (split_octant_flag)
1783 for (
int k = 0; k < 2; k++)
1784 for (
int m = 0; m < 2; m++)
1785 for (
int n = 0; n < 2; n++)
1787 idx_y + part_num_y * k * inp_length / 2,
1788 idx_cb + m * inp_length / 2,
1789 idx_cr + n * inp_length / 2,
1792 for (
int i = 0;
i < part_num_y;
i++) {
1793 for (
int j = 0; j < 4; j++) {
1796 for (
int c = 0;
c < 3;
c++) {
1798 cm_res_bits =
FFMAX(0, 10 +
pps->luma_bit_depth_cm_input -
1799 pps->luma_bit_depth_cm_output -
1800 pps->cm_res_quant_bits -
pps->cm_delta_flc_bits);
1801 res_coeff_r = cm_res_bits ?
get_bits(gb, cm_res_bits) : 0;
1802 if (res_coeff_q || res_coeff_r)
1812 if (
pps->num_cm_ref_layers > 62) {
1814 "num_cm_ref_layers_minus1 shall be in the range [0, 61].\n");
1817 for (
int i = 0;
i <
pps->num_cm_ref_layers;
i++)
1831 if (
pps->cm_octant_depth == 1) {
1846 if (
pps->pps_infer_scaling_list_flag)
1847 pps->pps_scaling_list_ref_layer_id =
get_bits(gb, 6);
1850 if (
pps->num_ref_loc_offsets >
vps->vps_max_layers - 1)
1853 for (
int i = 0;
i <
pps->num_ref_loc_offsets;
i++) {
1855 pps->scaled_ref_layer_offset_present_flag[
i] =
get_bits1(gb);
1856 if (
pps->scaled_ref_layer_offset_present_flag[
i]) {
1864 if (
pps->ref_region_offset_present_flag[
i]) {
1872 if (
pps->resample_phase_set_present_flag[
i]) {
1881 if (
pps->colour_mapping_enabled_flag) {
1892 unsigned int num_val_delta_dlt, max_diff = 0;
1893 int min_diff_minus1 = -1;
1896 num_val_delta_dlt =
get_bits(gb,
pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1897 if (num_val_delta_dlt) {
1898 if (num_val_delta_dlt > 1)
1899 max_diff =
get_bits(gb,
pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1900 if (num_val_delta_dlt > 2 && max_diff) {
1904 if (max_diff > (min_diff_minus1 + 1))
1905 for (
int k = 1; k < num_val_delta_dlt; k++) {
1906 len =
av_log2(max_diff - (min_diff_minus1 + 1)) + 1;
1915 unsigned int pps_depth_layers_minus1;
1918 pps_depth_layers_minus1 =
get_bits(gb, 6);
1919 pps->pps_bit_depth_for_depth_layers_minus8 =
get_bits(gb, 4);
1920 for (
int i = 0;
i <= pps_depth_layers_minus1;
i++) {
1924 for (
int j = 0; j <= ((1 << (
pps->pps_bit_depth_for_depth_layers_minus8 + 8)) - 1); j++)
1939 if (
pps->transform_skip_enabled_flag) {
1942 pps->cross_component_prediction_enabled_flag =
get_bits1(gb);
1943 pps->chroma_qp_offset_list_enabled_flag =
get_bits1(gb);
1944 if (
pps->chroma_qp_offset_list_enabled_flag) {
1947 if (
pps->chroma_qp_offset_list_len_minus1 > 5) {
1949 "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1952 for (
int i = 0;
i <=
pps->chroma_qp_offset_list_len_minus1;
i++) {
1954 if (
pps->cb_qp_offset_list[
i]) {
1956 "cb_qp_offset_list not tested yet.\n");
1959 if (
pps->cr_qp_offset_list[
i]) {
1961 "cb_qp_offset_list not tested yet.\n");
1968 if (
pps->log2_sao_offset_scale_luma >
FFMAX(
sps->bit_depth - 10, 0)
1969 ||
pps->log2_sao_offset_scale_chroma >
FFMAX(
sps->bit_depth_chroma - 10, 0)
1982 if (
pps->residual_adaptive_colour_transform_enabled_flag =
get_bits1(gb)) {
1983 pps->pps_slice_act_qp_offsets_present_flag =
get_bits1(gb);
1988 #define CHECK_QP_OFFSET(name) (pps->pps_act_ ## name ## _qp_offset <= -12 || \
1989 pps->pps_act_ ## name ## _qp_offset >= 12)
1991 #undef CHECK_QP_OFFSET
1994 "PpsActQpOffsetY/Cb/Cr shall be in the range of [-12, 12].\n");
1999 if (
pps->pps_palette_predictor_initializers_present_flag =
get_bits1(gb)) {
2001 if (
pps->pps_num_palette_predictor_initializers > 0) {
2004 "pps_num_palette_predictor_initializers out of range: %u\n",
2005 pps->pps_num_palette_predictor_initializers);
2010 if (
pps->luma_bit_depth_entry !=
sps->bit_depth)
2012 if (!
pps->monochrome_palette_flag) {
2014 if (
pps->chroma_bit_depth_entry !=
sps->bit_depth_chroma)
2018 num_comps =
pps->monochrome_palette_flag ? 1 : 3;
2021 for (
int i = 0;
i <
pps->pps_num_palette_predictor_initializers;
i++)
2034 int pic_area_in_ctbs;
2035 int i, j, x, y, ctb_addr_rs,
tile_id;
2041 if (!
pps->col_bd || !
pps->row_bd || !
pps->col_idxX)
2044 if (
pps->uniform_spacing_flag) {
2045 if (!
pps->column_width) {
2049 if (!
pps->column_width || !
pps->row_height)
2052 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
2053 pps->column_width[
i] = ((
i + 1) *
sps->ctb_width) /
pps->num_tile_columns -
2054 (
i *
sps->ctb_width) /
pps->num_tile_columns;
2057 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
2058 pps->row_height[
i] = ((
i + 1) *
sps->ctb_height) /
pps->num_tile_rows -
2059 (
i *
sps->ctb_height) /
pps->num_tile_rows;
2064 for (
i = 0;
i <
pps->num_tile_columns;
i++)
2065 pps->col_bd[
i + 1] =
pps->col_bd[
i] +
pps->column_width[
i];
2068 for (
i = 0;
i <
pps->num_tile_rows;
i++)
2069 pps->row_bd[
i + 1] =
pps->row_bd[
i] +
pps->row_height[
i];
2071 for (
i = 0, j = 0;
i <
sps->ctb_width;
i++) {
2072 if (
i >
pps->col_bd[j])
2074 pps->col_idxX[
i] = j;
2080 pic_area_in_ctbs =
sps->ctb_width *
sps->ctb_height;
2086 if (!
pps->ctb_addr_rs_to_ts || !
pps->ctb_addr_ts_to_rs ||
2087 !
pps->tile_id || !
pps->min_tb_addr_zs_tab) {
2091 for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
2092 int tb_x = ctb_addr_rs %
sps->ctb_width;
2093 int tb_y = ctb_addr_rs /
sps->ctb_width;
2098 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
2099 if (tb_x < pps->
col_bd[
i + 1]) {
2105 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
2106 if (tb_y < pps->
row_bd[
i + 1]) {
2112 for (
i = 0;
i < tile_x;
i++)
2113 val +=
pps->row_height[tile_y] *
pps->column_width[
i];
2114 for (
i = 0;
i < tile_y;
i++)
2117 val += (tb_y -
pps->row_bd[tile_y]) *
pps->column_width[tile_x] +
2118 tb_x -
pps->col_bd[tile_x];
2120 pps->ctb_addr_rs_to_ts[ctb_addr_rs] =
val;
2121 pps->ctb_addr_ts_to_rs[
val] = ctb_addr_rs;
2124 for (j = 0,
tile_id = 0; j <
pps->num_tile_rows; j++)
2126 for (y =
pps->row_bd[j]; y < pps->
row_bd[j + 1]; y++)
2127 for (x =
pps->col_bd[
i]; x < pps->
col_bd[
i + 1]; x++)
2131 if (!
pps->tile_pos_rs)
2134 for (j = 0; j <
pps->num_tile_rows; j++)
2135 for (
i = 0;
i <
pps->num_tile_columns;
i++)
2136 pps->tile_pos_rs[j *
pps->num_tile_columns +
i] =
2137 pps->row_bd[j] *
sps->ctb_width +
pps->col_bd[
i];
2139 log2_diff =
sps->log2_ctb_size -
sps->log2_min_tb_size;
2140 pps->min_tb_addr_zs = &
pps->min_tb_addr_zs_tab[1*(
sps->tb_mask+2)+1];
2141 for (y = 0; y <
sps->tb_mask+2; y++) {
2142 pps->min_tb_addr_zs_tab[y*(
sps->tb_mask+2)] = -1;
2143 pps->min_tb_addr_zs_tab[y] = -1;
2145 for (y = 0; y <
sps->tb_mask+1; y++) {
2146 for (x = 0; x <
sps->tb_mask+1; x++) {
2147 int tb_x = x >> log2_diff;
2148 int tb_y = y >> log2_diff;
2149 int rs =
sps->ctb_width * tb_y + tb_x;
2150 int val =
pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
2151 for (
i = 0;
i < log2_diff;
i++) {
2153 val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
2155 pps->min_tb_addr_zs[y * (
sps->tb_mask+2) + x] =
val;
2170 unsigned log2_parallel_merge_level_minus2;
2191 pps->data_size = nal_size;
2199 pps->loop_filter_across_tiles_enabled_flag = 1;
2200 pps->num_tile_columns = 1;
2201 pps->num_tile_rows = 1;
2202 pps->uniform_spacing_flag = 1;
2203 pps->disable_dbf = 0;
2204 pps->beta_offset = 0;
2206 pps->log2_max_transform_skip_block_size = 2;
2226 pps->dependent_slice_segments_enabled_flag =
get_bits1(gb);
2228 pps->num_extra_slice_header_bits =
get_bits(gb, 3);
2239 pps->num_ref_idx_l0_default_active,
pps->num_ref_idx_l1_default_active);
2249 pps->diff_cu_qp_delta_depth = 0;
2250 if (
pps->cu_qp_delta_enabled_flag)
2253 if (
pps->diff_cu_qp_delta_depth < 0 ||
2254 pps->diff_cu_qp_delta_depth >
sps->log2_diff_max_min_coding_block_size) {
2256 pps->diff_cu_qp_delta_depth);
2262 if (
pps->cb_qp_offset < -12 ||
pps->cb_qp_offset > 12) {
2269 if (
pps->cr_qp_offset < -12 ||
pps->cr_qp_offset > 12) {
2275 pps->pic_slice_level_chroma_qp_offsets_present_flag =
get_bits1(gb);
2284 if (
pps->tiles_enabled_flag) {
2288 if (num_tile_columns_minus1 < 0 ||
2289 num_tile_columns_minus1 >=
sps->ctb_width) {
2291 num_tile_columns_minus1);
2295 if (num_tile_rows_minus1 < 0 ||
2296 num_tile_rows_minus1 >=
sps->ctb_height) {
2298 num_tile_rows_minus1);
2302 pps->num_tile_columns = num_tile_columns_minus1 + 1;
2303 pps->num_tile_rows = num_tile_rows_minus1 + 1;
2307 if (!
pps->column_width || !
pps->row_height) {
2313 if (!
pps->uniform_spacing_flag) {
2315 for (
i = 0;
i <
pps->num_tile_columns - 1;
i++) {
2317 sum +=
pps->column_width[
i];
2319 if (sum >=
sps->ctb_width) {
2324 pps->column_width[
pps->num_tile_columns - 1] =
sps->ctb_width - sum;
2327 for (
i = 0;
i <
pps->num_tile_rows - 1;
i++) {
2329 sum +=
pps->row_height[
i];
2331 if (sum >=
sps->ctb_height) {
2336 pps->row_height[
pps->num_tile_rows - 1] =
sps->ctb_height - sum;
2338 pps->loop_filter_across_tiles_enabled_flag =
get_bits1(gb);
2341 pps->seq_loop_filter_across_slices_enabled_flag =
get_bits1(gb);
2343 pps->deblocking_filter_control_present_flag =
get_bits1(gb);
2344 if (
pps->deblocking_filter_control_present_flag) {
2345 pps->deblocking_filter_override_enabled_flag =
get_bits1(gb);
2347 if (!
pps->disable_dbf) {
2350 if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
2356 if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
2362 pps->beta_offset = 2 * beta_offset_div2;
2363 pps->tc_offset = 2 * tc_offset_div2;
2368 if (
pps->scaling_list_data_present_flag) {
2376 if (log2_parallel_merge_level_minus2 >
sps->log2_ctb_size) {
2378 log2_parallel_merge_level_minus2);
2382 pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
2384 pps->slice_header_extension_present_flag =
get_bits1(gb);
2387 if (
pps->pps_extension_present_flag) {
2399 if (
pps->pps_multilayer_extension_flag) {
2404 if (
pps->pps_3d_extension_flag) {
2409 if (
pps->pps_scc_extension_flag) {
2448 int max_poc_lsb = 1 <<
sps->log2_max_poc_lsb;
2449 int prev_poc_lsb = pocTid0 % max_poc_lsb;
2450 int prev_poc_msb = pocTid0 - prev_poc_lsb;
2453 if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
2454 poc_msb = prev_poc_msb + max_poc_lsb;
2455 else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
2456 poc_msb = prev_poc_msb - max_poc_lsb;
2458 poc_msb = prev_poc_msb;
2466 return poc_msb + poc_lsb;