34 16, 16, 16, 16, 17, 18, 21, 24,
35 16, 16, 16, 16, 17, 19, 22, 25,
36 16, 16, 17, 18, 20, 22, 25, 29,
37 16, 16, 18, 21, 24, 27, 31, 36,
38 17, 17, 20, 24, 30, 35, 41, 47,
39 18, 19, 22, 27, 35, 44, 54, 65,
40 21, 22, 25, 31, 41, 54, 70, 88,
41 24, 25, 29, 36, 47, 65, 88, 115
45 16, 16, 16, 16, 17, 18, 20, 24,
46 16, 16, 16, 17, 18, 20, 24, 25,
47 16, 16, 17, 18, 20, 24, 25, 28,
48 16, 17, 18, 20, 24, 25, 28, 33,
49 17, 18, 20, 24, 25, 28, 33, 41,
50 18, 20, 24, 25, 28, 33, 41, 54,
51 20, 24, 25, 28, 33, 41, 54, 71,
52 24, 25, 28, 33, 41, 54, 71, 91
65 if (
s->pps ==
s->pps_list[
id])
73 if (
s->sps_list[
id]) {
74 if (
s->sps ==
s->sps_list[
id])
79 if (
s->pps_list[
i] &&
s->pps_list[
i]->sps_id ==
id)
90 if (
s->vps_list[
id]) {
91 if (
s->vps ==
s->vps_list[
id])
95 if (
s->sps_list[
i] &&
s->sps_list[
i]->vps_id ==
id)
111 if (rps !=
sps->st_rps &&
sps->nb_st_rps)
118 if (is_slice_header) {
122 "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
129 rps_ridx = &
sps->st_rps[rps -
sps->st_rps - 1];
135 "Invalid value of abs_delta_rps: %d\n",
148 if (i < rps_ridx->num_delta_pocs)
149 delta_poc = delta_rps + rps_ridx->
delta_poc[
i];
151 delta_poc = delta_rps;
161 "Invalid num_delta_pocs: %d\n", k);
173 for (k =
i - 1; k >= 0; k--) {
175 if (delta_poc <
tmp) {
199 unsigned int prev, nb_positive_pics;
214 if (delta_poc < 1 || delta_poc > 32768) {
216 "Invalid value of delta_poc: %d\n",
225 for (
i = 0;
i < nb_positive_pics;
i++) {
227 if (delta_poc < 1 || delta_poc > 32768) {
229 "Invalid value of delta_poc: %d\n",
267 for (
i = 0;
i < 32;
i++) {
270 if (
ptl->profile_idc == 0 &&
i > 0 &&
ptl->profile_compatibility_flag[
i])
271 ptl->profile_idc =
i;
278 #define check_profile_idc(idc) \
279 ptl->profile_idc == idc || ptl->profile_compatibility_flag[idc]
314 #undef check_profile_idc
320 PTL *
ptl,
int max_num_sub_layers)
324 get_bits_left(gb) < 8 + (8*2 * (max_num_sub_layers - 1 > 0))) {
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) {
466 if (nal_size >
sizeof(
vps->data)) {
469 nal_size,
sizeof(
vps->data));
470 vps->data_size =
sizeof(
vps->data);
472 vps->data_size = nal_size;
494 vps->vps_max_sub_layers);
501 vps->vps_sub_layer_ordering_info_present_flag =
get_bits1(gb);
503 i =
vps->vps_sub_layer_ordering_info_present_flag ? 0 :
vps->vps_max_sub_layers - 1;
504 for (;
i <
vps->vps_max_sub_layers;
i++) {
511 vps->vps_max_dec_pic_buffering[
i] - 1);
514 if (
vps->vps_num_reorder_pics[
i] >
vps->vps_max_dec_pic_buffering[
i] - 1) {
516 vps->vps_num_reorder_pics[
i]);
524 if (
vps->vps_num_layer_sets < 1 ||
vps->vps_num_layer_sets > 1024 ||
530 for (
i = 1;
i <
vps->vps_num_layer_sets;
i++)
531 for (j = 0; j <=
vps->vps_max_layer_id; j++)
535 if (
vps->vps_timing_info_present_flag) {
538 vps->vps_poc_proportional_to_timing_flag =
get_bits1(gb);
539 if (
vps->vps_poc_proportional_to_timing_flag)
542 if (
vps->vps_num_hrd_parameters > (
unsigned)
vps->vps_num_layer_sets) {
544 "vps_num_hrd_parameters %d is invalid\n",
vps->vps_num_hrd_parameters);
552 for (
i = 0;
i <
vps->vps_num_hrd_parameters;
i++) {
553 int common_inf_present = 1;
559 vps->vps_max_sub_layers);
589 VUI backup_vui, *vui = &
sps->vui;
600 switch (
sps->pix_fmt) {
620 memcpy(&backup, gb,
sizeof(backup));
621 memcpy(&backup_vui, vui,
sizeof(backup_vui));
636 if (apply_defdispwin &&
639 "discarding vui default display window, "
640 "original values are l:%u r:%u t:%u b:%u\n",
661 "Strange VUI timing information, retrying...\n");
662 memcpy(vui, &backup_vui,
sizeof(backup_vui));
663 memcpy(gb, &backup,
sizeof(backup));
685 "Strange VUI bitstream restriction information, retrying"
686 " from timing information...\n");
687 memcpy(vui, &backup_vui,
sizeof(backup_vui));
688 memcpy(gb, &backup,
sizeof(backup));
705 "Overread in VUI, retrying from timing information...\n");
706 memcpy(vui, &backup_vui,
sizeof(backup_vui));
707 memcpy(gb, &backup,
sizeof(backup));
717 for (matrixId = 0; matrixId < 6; matrixId++) {
719 memset(sl->
sl[0][matrixId], 16, 16);
720 sl->
sl_dc[0][matrixId] = 16;
721 sl->
sl_dc[1][matrixId] = 16;
746 uint8_t scaling_list_pred_mode_flag;
747 uint8_t scaling_list_dc_coef[2][6];
748 int size_id, matrix_id,
pos;
751 for (size_id = 0; size_id < 4; size_id++)
752 for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
753 scaling_list_pred_mode_flag =
get_bits1(gb);
754 if (!scaling_list_pred_mode_flag) {
760 delta *= (size_id == 3) ? 3 : 1;
761 if (matrix_id <
delta) {
763 "Invalid delta in scaling list data: %d.\n",
delta);
767 memcpy(sl->
sl[size_id][matrix_id],
768 sl->
sl[size_id][matrix_id -
delta],
769 size_id > 0 ? 64 : 16);
771 sl->
sl_dc[size_id - 2][matrix_id] = sl->
sl_dc[size_id - 2][matrix_id -
delta];
774 int next_coef, coef_num;
775 int32_t scaling_list_delta_coef;
778 coef_num =
FFMIN(64, 1 << (4 + (size_id << 1)));
781 if (scaling_list_coeff_minus8 < -7 ||
782 scaling_list_coeff_minus8 > 247)
784 scaling_list_dc_coef[size_id - 2][matrix_id] = scaling_list_coeff_minus8 + 8;
785 next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
786 sl->
sl_dc[size_id - 2][matrix_id] = next_coef;
788 for (
i = 0;
i < coef_num;
i++) {
797 next_coef = (next_coef + 256
U + scaling_list_delta_coef) % 256;
798 sl->
sl[size_id][matrix_id][
pos] = next_coef;
803 if (
sps->chroma_format_idc == 3) {
804 for (
i = 0;
i < 64;
i++) {
805 sl->
sl[3][1][
i] = sl->
sl[2][1][
i];
806 sl->
sl[3][2][
i] = sl->
sl[2][2][
i];
807 sl->
sl[3][4][
i] = sl->
sl[2][4][
i];
808 sl->
sl[3][5][
i] = sl->
sl[2][5][
i];
823 switch (
sps->bit_depth) {
850 "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
851 "chroma_format_idc is %d, depth is %d\n",
852 sps->chroma_format_idc,
sps->bit_depth);
860 sps->hshift[0] =
sps->vshift[0] = 0;
861 sps->hshift[2] =
sps->hshift[1] =
desc->log2_chroma_w;
862 sps->vshift[2] =
sps->vshift[1] =
desc->log2_chroma_h;
864 sps->pixel_shift =
sps->bit_depth > 8;
870 int apply_defdispwin,
const HEVCVPS *
const *vps_list,
875 int bit_depth_chroma, start, num_comps;
882 if (vps_list && !vps_list[
sps->vps_id]) {
891 sps->max_sub_layers);
907 if (
sps->chroma_format_idc > 3
U) {
912 if (
sps->chroma_format_idc == 3)
915 if (
sps->separate_colour_plane_flag)
916 sps->chroma_format_idc = 0;
921 sps->height, 0, avctx)) < 0)
925 if (
sps->conformance_window_flag) {
935 "discarding sps conformance window, "
936 "original values are l:%u r:%u t:%u b:%u\n",
937 sps->pic_conf_win.left_offset,
938 sps->pic_conf_win.right_offset,
939 sps->pic_conf_win.top_offset,
940 sps->pic_conf_win.bottom_offset);
942 sps->pic_conf_win.left_offset =
943 sps->pic_conf_win.right_offset =
944 sps->pic_conf_win.top_offset =
945 sps->pic_conf_win.bottom_offset = 0;
947 sps->output_window =
sps->pic_conf_win;
951 if (
sps->bit_depth > 16) {
957 if (bit_depth_chroma > 16) {
962 if (
sps->chroma_format_idc && bit_depth_chroma !=
sps->bit_depth) {
964 "Luma bit depth (%d) is different from chroma bit depth (%d), "
965 "this is unsupported.\n",
966 sps->bit_depth, bit_depth_chroma);
969 sps->bit_depth_chroma = bit_depth_chroma;
976 if (
sps->log2_max_poc_lsb > 16) {
978 sps->log2_max_poc_lsb - 4);
983 start =
sps->sublayer_ordering_info_flag ? 0 :
sps->max_sub_layers - 1;
984 for (
i = start;
i <
sps->max_sub_layers;
i++) {
990 sps->temporal_layer[
i].max_dec_pic_buffering - 1
U);
993 if (
sps->temporal_layer[
i].num_reorder_pics >
sps->temporal_layer[
i].max_dec_pic_buffering - 1) {
995 sps->temporal_layer[
i].num_reorder_pics);
1000 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[
i].num_reorder_pics + 1;
1004 if (!
sps->sublayer_ordering_info_flag) {
1005 for (
i = 0;
i < start;
i++) {
1006 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[start].max_dec_pic_buffering;
1007 sps->temporal_layer[
i].num_reorder_pics =
sps->temporal_layer[start].num_reorder_pics;
1008 sps->temporal_layer[
i].max_latency_increase =
sps->temporal_layer[start].max_latency_increase;
1016 sps->log2_max_trafo_size =
sps->log2_diff_max_min_transform_block_size +
1017 sps->log2_min_tb_size;
1019 if (
sps->log2_min_cb_size < 3 ||
sps->log2_min_cb_size > 30) {
1024 if (
sps->log2_diff_max_min_coding_block_size > 30) {
1025 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);
1029 if (
sps->log2_min_tb_size >=
sps->log2_min_cb_size ||
sps->log2_min_tb_size < 2) {
1034 if (
sps->log2_diff_max_min_transform_block_size > 30) {
1035 av_log(avctx,
AV_LOG_ERROR,
"Invalid value %d for log2_diff_max_min_transform_block_size",
1036 sps->log2_diff_max_min_transform_block_size);
1044 if (
sps->scaling_list_enable_flag) {
1058 if (
sps->pcm_enabled_flag) {
1062 sps->pcm.log2_max_pcm_cb_size =
sps->pcm.log2_min_pcm_cb_size +
1064 if (
FFMAX(
sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma) >
sps->bit_depth) {
1066 "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1067 sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma,
sps->bit_depth);
1080 for (
i = 0;
i <
sps->nb_st_rps;
i++) {
1087 if (
sps->long_term_ref_pics_present_flag) {
1091 sps->num_long_term_ref_pics_sps);
1094 for (
i = 0;
i <
sps->num_long_term_ref_pics_sps;
i++) {
1101 sps->sps_strong_intra_smoothing_enable_flag =
get_bits1(gb);
1104 if (
sps->vui_present)
1108 if (
sps->sps_extension_present_flag) {
1115 if (
sps->sps_range_extension_flag) {
1116 sps->transform_skip_rotation_enabled_flag =
get_bits1(gb);
1117 sps->transform_skip_context_enabled_flag =
get_bits1(gb);
1122 sps->extended_precision_processing_flag =
get_bits1(gb);
1123 if (
sps->extended_precision_processing_flag)
1125 "extended_precision_processing_flag not yet implemented\n");
1128 sps->high_precision_offsets_enabled_flag =
get_bits1(gb);
1129 if (
sps->high_precision_offsets_enabled_flag)
1131 "high_precision_offsets_enabled_flag not yet implemented\n");
1133 sps->persistent_rice_adaptation_enabled_flag =
get_bits1(gb);
1135 sps->cabac_bypass_alignment_enabled_flag =
get_bits1(gb);
1136 if (
sps->cabac_bypass_alignment_enabled_flag)
1138 "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1141 if (
sps->sps_multilayer_extension_flag) {
1144 "sps_multilayer_extension_flag not yet implemented\n");
1147 if (
sps->sps_3d_extension_flag) {
1148 for (
i = 0;
i <= 1;
i++) {
1168 "sps_3d_extension_flag not yet implemented\n");
1171 if (
sps->sps_scc_extension_flag) {
1174 if (
sps->palette_mode_enabled_flag) {
1177 sps->sps_palette_predictor_initializers_present_flag =
get_bits1(gb);
1179 if (
sps->sps_palette_predictor_initializers_present_flag) {
1183 "sps_num_palette_predictor_initializers out of range: %u\n",
1184 sps->sps_num_palette_predictor_initializers);
1187 num_comps = !
sps->chroma_format_idc ? 1 : 3;
1190 for (
i = 0;
i <
sps->sps_num_palette_predictor_initializers;
i++)
1195 sps->motion_vector_resolution_control_idc =
get_bits(gb, 2);
1196 sps->intra_boundary_filtering_disabled_flag =
get_bits1(gb);
1199 if (apply_defdispwin) {
1200 sps->output_window.left_offset +=
sps->vui.def_disp_win.left_offset;
1201 sps->output_window.right_offset +=
sps->vui.def_disp_win.right_offset;
1202 sps->output_window.top_offset +=
sps->vui.def_disp_win.top_offset;
1203 sps->output_window.bottom_offset +=
sps->vui.def_disp_win.bottom_offset;
1206 ow = &
sps->output_window;
1217 "Displaying the whole video surface.\n");
1218 memset(ow, 0,
sizeof(*ow));
1219 memset(&
sps->pic_conf_win, 0,
sizeof(
sps->pic_conf_win));
1223 sps->log2_ctb_size =
sps->log2_min_cb_size +
1224 sps->log2_diff_max_min_coding_block_size;
1225 sps->log2_min_pu_size =
sps->log2_min_cb_size - 1;
1231 if (
sps->log2_ctb_size < 4) {
1234 "log2_ctb_size %d differs from the bounds of any known profile\n",
1235 sps->log2_ctb_size);
1240 sps->ctb_width = (
sps->width + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1241 sps->ctb_height = (
sps->height + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1242 sps->ctb_size =
sps->ctb_width *
sps->ctb_height;
1244 sps->min_cb_width =
sps->width >>
sps->log2_min_cb_size;
1245 sps->min_cb_height =
sps->height >>
sps->log2_min_cb_size;
1246 sps->min_tb_width =
sps->width >>
sps->log2_min_tb_size;
1247 sps->min_tb_height =
sps->height >>
sps->log2_min_tb_size;
1248 sps->min_pu_width =
sps->width >>
sps->log2_min_pu_size;
1249 sps->min_pu_height =
sps->height >>
sps->log2_min_pu_size;
1250 sps->tb_mask = (1 << (
sps->log2_ctb_size -
sps->log2_min_tb_size)) - 1;
1252 sps->qp_bd_offset = 6 * (
sps->bit_depth - 8);
1260 if (
sps->max_transform_hierarchy_depth_inter >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1261 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_inter out of range: %d\n",
1262 sps->max_transform_hierarchy_depth_inter);
1265 if (
sps->max_transform_hierarchy_depth_intra >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1266 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_intra out of range: %d\n",
1267 sps->max_transform_hierarchy_depth_intra);
1270 if (
sps->log2_max_trafo_size >
FFMIN(
sps->log2_ctb_size, 5)) {
1272 "max transform block size out of range: %d\n",
1273 sps->log2_max_trafo_size);
1290 unsigned int sps_id;
1300 if (nal_size >
sizeof(
sps->data)) {
1303 nal_size,
sizeof(
sps->data));
1304 sps->data_size =
sizeof(
sps->data);
1306 sps->data_size = nal_size;
1320 "Parsed SPS: id %d; coded wxh: %dx%d; "
1321 "cropped wxh: %dx%d; pix_fmt: %s.\n",
1322 sps_id,
sps->width,
sps->height,
1323 sps->width - (
sps->output_window.left_offset +
sps->output_window.right_offset),
1324 sps->height - (
sps->output_window.top_offset +
sps->output_window.bottom_offset),
1359 int idx_y,
int idx_cb,
int idx_cr,
int inp_length)
1361 unsigned int split_octant_flag, part_num_y, coded_res_flag, res_coeff_q, res_coeff_r;
1364 part_num_y = 1 <<
pps->cm_y_part_num_log2;
1366 split_octant_flag = inp_depth <
pps->cm_octant_depth ?
get_bits1(gb) : 0;
1368 if (split_octant_flag)
1369 for (
int k = 0; k < 2; k++)
1370 for (
int m = 0; m < 2; m++)
1371 for (
int n = 0; n < 2; n++)
1373 idx_y + part_num_y * k * inp_length / 2,
1374 idx_cb + m * inp_length / 2,
1375 idx_cr + n * inp_length / 2,
1378 for (
int i = 0;
i < part_num_y;
i++) {
1379 for (
int j = 0; j < 4; j++) {
1382 for (
int c = 0;
c < 3;
c++) {
1384 cm_res_bits =
FFMAX(0, 10 +
pps->luma_bit_depth_cm_input -
1385 pps->luma_bit_depth_cm_output -
1386 pps->cm_res_quant_bits -
pps->cm_delta_flc_bits);
1387 res_coeff_r = cm_res_bits ?
get_bits(gb, cm_res_bits) : 0;
1388 if (res_coeff_q || res_coeff_r)
1398 if (
pps->num_cm_ref_layers > 62) {
1400 "num_cm_ref_layers_minus1 shall be in the range [0, 61].\n");
1403 for (
int i = 0;
i <
pps->num_cm_ref_layers;
i++)
1417 if (
pps->cm_octant_depth == 1) {
1432 if (
pps->pps_infer_scaling_list_flag)
1433 pps->pps_scaling_list_ref_layer_id =
get_bits(gb, 6);
1436 if (
pps->num_ref_loc_offsets >
vps->vps_max_layers - 1)
1439 for (
int i = 0;
i <
pps->num_ref_loc_offsets;
i++) {
1441 pps->scaled_ref_layer_offset_present_flag[
i] =
get_bits1(gb);
1442 if (
pps->scaled_ref_layer_offset_present_flag[
i]) {
1450 if (
pps->ref_region_offset_present_flag[
i]) {
1458 if (
pps->resample_phase_set_present_flag[
i]) {
1467 if (
pps->colour_mapping_enabled_flag) {
1478 unsigned int num_val_delta_dlt, max_diff = 0;
1479 int min_diff_minus1 = -1;
1482 num_val_delta_dlt =
get_bits(gb,
pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1483 if (num_val_delta_dlt) {
1484 if (num_val_delta_dlt > 1)
1485 max_diff =
get_bits(gb,
pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1486 if (num_val_delta_dlt > 2 && max_diff) {
1490 if (max_diff > (min_diff_minus1 + 1))
1491 for (
int k = 1; k < num_val_delta_dlt; k++) {
1492 len =
av_log2(max_diff - (min_diff_minus1 + 1)) + 1;
1501 unsigned int pps_depth_layers_minus1;
1504 pps_depth_layers_minus1 =
get_bits(gb, 6);
1505 pps->pps_bit_depth_for_depth_layers_minus8 =
get_bits(gb, 4);
1506 for (
int i = 0;
i <= pps_depth_layers_minus1;
i++) {
1510 for (
int j = 0; j <= ((1 << (
pps->pps_bit_depth_for_depth_layers_minus8 + 8)) - 1); j++)
1525 if (
pps->transform_skip_enabled_flag) {
1528 pps->cross_component_prediction_enabled_flag =
get_bits1(gb);
1529 pps->chroma_qp_offset_list_enabled_flag =
get_bits1(gb);
1530 if (
pps->chroma_qp_offset_list_enabled_flag) {
1533 if (
pps->chroma_qp_offset_list_len_minus1 > 5) {
1535 "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1538 for (
int i = 0;
i <=
pps->chroma_qp_offset_list_len_minus1;
i++) {
1540 if (
pps->cb_qp_offset_list[
i]) {
1542 "cb_qp_offset_list not tested yet.\n");
1545 if (
pps->cr_qp_offset_list[
i]) {
1547 "cb_qp_offset_list not tested yet.\n");
1554 if (
pps->log2_sao_offset_scale_luma >
FFMAX(
sps->bit_depth - 10, 0)
1555 ||
pps->log2_sao_offset_scale_chroma >
FFMAX(
sps->bit_depth_chroma - 10, 0)
1568 if (
pps->residual_adaptive_colour_transform_enabled_flag =
get_bits1(gb)) {
1569 pps->pps_slice_act_qp_offsets_present_flag =
get_bits1(gb);
1574 #define CHECK_QP_OFFSET(name) (pps->pps_act_ ## name ## _qp_offset <= -12 || \
1575 pps->pps_act_ ## name ## _qp_offset >= 12)
1577 #undef CHECK_QP_OFFSET
1580 "PpsActQpOffsetY/Cb/Cr shall be in the range of [-12, 12].\n");
1585 if (
pps->pps_palette_predictor_initializers_present_flag =
get_bits1(gb)) {
1587 if (
pps->pps_num_palette_predictor_initializers > 0) {
1590 "pps_num_palette_predictor_initializers out of range: %u\n",
1591 pps->pps_num_palette_predictor_initializers);
1596 if (
pps->luma_bit_depth_entry !=
sps->bit_depth)
1598 if (!
pps->monochrome_palette_flag) {
1600 if (
pps->chroma_bit_depth_entry !=
sps->bit_depth_chroma)
1604 num_comps =
pps->monochrome_palette_flag ? 1 : 3;
1607 for (
int i = 0;
i <
pps->pps_num_palette_predictor_initializers;
i++)
1620 int pic_area_in_ctbs;
1621 int i, j, x, y, ctb_addr_rs, tile_id;
1627 if (!
pps->col_bd || !
pps->row_bd || !
pps->col_idxX)
1630 if (
pps->uniform_spacing_flag) {
1631 if (!
pps->column_width) {
1635 if (!
pps->column_width || !
pps->row_height)
1638 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
1639 pps->column_width[
i] = ((
i + 1) *
sps->ctb_width) /
pps->num_tile_columns -
1640 (
i *
sps->ctb_width) /
pps->num_tile_columns;
1643 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
1644 pps->row_height[
i] = ((
i + 1) *
sps->ctb_height) /
pps->num_tile_rows -
1645 (
i *
sps->ctb_height) /
pps->num_tile_rows;
1650 for (
i = 0;
i <
pps->num_tile_columns;
i++)
1651 pps->col_bd[
i + 1] =
pps->col_bd[
i] +
pps->column_width[
i];
1654 for (
i = 0;
i <
pps->num_tile_rows;
i++)
1655 pps->row_bd[
i + 1] =
pps->row_bd[
i] +
pps->row_height[
i];
1657 for (
i = 0, j = 0;
i <
sps->ctb_width;
i++) {
1658 if (
i >
pps->col_bd[j])
1660 pps->col_idxX[
i] = j;
1666 pic_area_in_ctbs =
sps->ctb_width *
sps->ctb_height;
1672 if (!
pps->ctb_addr_rs_to_ts || !
pps->ctb_addr_ts_to_rs ||
1673 !
pps->tile_id || !
pps->min_tb_addr_zs_tab) {
1677 for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1678 int tb_x = ctb_addr_rs %
sps->ctb_width;
1679 int tb_y = ctb_addr_rs /
sps->ctb_width;
1684 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
1685 if (tb_x < pps->col_bd[
i + 1]) {
1691 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
1692 if (tb_y < pps->row_bd[
i + 1]) {
1698 for (
i = 0;
i < tile_x;
i++)
1699 val +=
pps->row_height[tile_y] *
pps->column_width[
i];
1700 for (
i = 0;
i < tile_y;
i++)
1703 val += (tb_y -
pps->row_bd[tile_y]) *
pps->column_width[tile_x] +
1704 tb_x -
pps->col_bd[tile_x];
1706 pps->ctb_addr_rs_to_ts[ctb_addr_rs] =
val;
1707 pps->ctb_addr_ts_to_rs[
val] = ctb_addr_rs;
1710 for (j = 0, tile_id = 0; j <
pps->num_tile_rows; j++)
1711 for (
i = 0;
i <
pps->num_tile_columns;
i++, tile_id++)
1712 for (y =
pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1713 for (x =
pps->col_bd[
i]; x < pps->col_bd[
i + 1]; x++)
1714 pps->tile_id[
pps->ctb_addr_rs_to_ts[y *
sps->ctb_width + x]] = tile_id;
1717 if (!
pps->tile_pos_rs)
1720 for (j = 0; j <
pps->num_tile_rows; j++)
1721 for (
i = 0;
i <
pps->num_tile_columns;
i++)
1722 pps->tile_pos_rs[j *
pps->num_tile_columns +
i] =
1723 pps->row_bd[j] *
sps->ctb_width +
pps->col_bd[
i];
1725 log2_diff =
sps->log2_ctb_size -
sps->log2_min_tb_size;
1726 pps->min_tb_addr_zs = &
pps->min_tb_addr_zs_tab[1*(
sps->tb_mask+2)+1];
1727 for (y = 0; y <
sps->tb_mask+2; y++) {
1728 pps->min_tb_addr_zs_tab[y*(
sps->tb_mask+2)] = -1;
1729 pps->min_tb_addr_zs_tab[y] = -1;
1731 for (y = 0; y <
sps->tb_mask+1; y++) {
1732 for (x = 0; x <
sps->tb_mask+1; x++) {
1733 int tb_x = x >> log2_diff;
1734 int tb_y = y >> log2_diff;
1735 int rs =
sps->ctb_width * tb_y + tb_x;
1736 int val =
pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
1737 for (
i = 0;
i < log2_diff;
i++) {
1739 val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1741 pps->min_tb_addr_zs[y * (
sps->tb_mask+2) + x] =
val;
1754 unsigned int pps_id = 0;
1756 unsigned log2_parallel_merge_level_minus2;
1766 if (nal_size >
sizeof(
pps->data)) {
1769 nal_size,
sizeof(
pps->data));
1770 pps->data_size =
sizeof(
pps->data);
1772 pps->data_size = nal_size;
1777 pps->loop_filter_across_tiles_enabled_flag = 1;
1778 pps->num_tile_columns = 1;
1779 pps->num_tile_rows = 1;
1780 pps->uniform_spacing_flag = 1;
1781 pps->disable_dbf = 0;
1782 pps->beta_offset = 0;
1784 pps->log2_max_transform_skip_block_size = 2;
1807 pps->dependent_slice_segments_enabled_flag =
get_bits1(gb);
1809 pps->num_extra_slice_header_bits =
get_bits(gb, 3);
1820 pps->num_ref_idx_l0_default_active,
pps->num_ref_idx_l1_default_active);
1830 pps->diff_cu_qp_delta_depth = 0;
1831 if (
pps->cu_qp_delta_enabled_flag)
1834 if (
pps->diff_cu_qp_delta_depth < 0 ||
1835 pps->diff_cu_qp_delta_depth >
sps->log2_diff_max_min_coding_block_size) {
1837 pps->diff_cu_qp_delta_depth);
1843 if (
pps->cb_qp_offset < -12 ||
pps->cb_qp_offset > 12) {
1850 if (
pps->cr_qp_offset < -12 ||
pps->cr_qp_offset > 12) {
1856 pps->pic_slice_level_chroma_qp_offsets_present_flag =
get_bits1(gb);
1865 if (
pps->tiles_enabled_flag) {
1869 if (num_tile_columns_minus1 < 0 ||
1870 num_tile_columns_minus1 >=
sps->ctb_width) {
1872 num_tile_columns_minus1);
1876 if (num_tile_rows_minus1 < 0 ||
1877 num_tile_rows_minus1 >=
sps->ctb_height) {
1879 num_tile_rows_minus1);
1883 pps->num_tile_columns = num_tile_columns_minus1 + 1;
1884 pps->num_tile_rows = num_tile_rows_minus1 + 1;
1888 if (!
pps->column_width || !
pps->row_height) {
1894 if (!
pps->uniform_spacing_flag) {
1896 for (
i = 0;
i <
pps->num_tile_columns - 1;
i++) {
1898 sum +=
pps->column_width[
i];
1900 if (sum >=
sps->ctb_width) {
1905 pps->column_width[
pps->num_tile_columns - 1] =
sps->ctb_width - sum;
1908 for (
i = 0;
i <
pps->num_tile_rows - 1;
i++) {
1910 sum +=
pps->row_height[
i];
1912 if (sum >=
sps->ctb_height) {
1917 pps->row_height[
pps->num_tile_rows - 1] =
sps->ctb_height - sum;
1919 pps->loop_filter_across_tiles_enabled_flag =
get_bits1(gb);
1922 pps->seq_loop_filter_across_slices_enabled_flag =
get_bits1(gb);
1924 pps->deblocking_filter_control_present_flag =
get_bits1(gb);
1925 if (
pps->deblocking_filter_control_present_flag) {
1926 pps->deblocking_filter_override_enabled_flag =
get_bits1(gb);
1928 if (!
pps->disable_dbf) {
1931 if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
1937 if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1943 pps->beta_offset = 2 * beta_offset_div2;
1944 pps->tc_offset = 2 * tc_offset_div2;
1949 if (
pps->scaling_list_data_present_flag) {
1957 if (log2_parallel_merge_level_minus2 >
sps->log2_ctb_size) {
1959 log2_parallel_merge_level_minus2);
1963 pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
1965 pps->slice_header_extension_present_flag =
get_bits1(gb);
1968 if (
pps->pps_extension_present_flag) {
1980 if (
pps->pps_multilayer_extension_flag) {
1985 if (
pps->pps_3d_extension_flag) {
1990 if (
pps->pps_scc_extension_flag) {
2033 int max_poc_lsb = 1 <<
sps->log2_max_poc_lsb;
2034 int prev_poc_lsb = pocTid0 % max_poc_lsb;
2035 int prev_poc_msb = pocTid0 - prev_poc_lsb;
2038 if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
2039 poc_msb = prev_poc_msb + max_poc_lsb;
2040 else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
2041 poc_msb = prev_poc_msb - max_poc_lsb;
2043 poc_msb = prev_poc_msb;
2051 return poc_msb + poc_lsb;