35 16, 16, 16, 16, 17, 18, 21, 24,
36 16, 16, 16, 16, 17, 19, 22, 25,
37 16, 16, 17, 18, 20, 22, 25, 29,
38 16, 16, 18, 21, 24, 27, 31, 36,
39 17, 17, 20, 24, 30, 35, 41, 47,
40 18, 19, 22, 27, 35, 44, 54, 65,
41 21, 22, 25, 31, 41, 54, 70, 88,
42 24, 25, 29, 36, 47, 65, 88, 115
46 16, 16, 16, 16, 17, 18, 20, 24,
47 16, 16, 16, 17, 18, 20, 24, 25,
48 16, 16, 17, 18, 20, 24, 25, 28,
49 16, 17, 18, 20, 24, 25, 28, 33,
50 17, 18, 20, 24, 25, 28, 33, 41,
51 18, 20, 24, 25, 28, 33, 41, 54,
52 20, 24, 25, 28, 33, 41, 54, 71,
53 24, 25, 28, 33, 41, 54, 71, 91
66 if (
s->pps ==
s->pps_list[
id])
74 if (
s->sps_list[
id]) {
75 if (
s->sps ==
s->sps_list[
id])
80 if (
s->pps_list[
i] &&
s->pps_list[
i]->sps_id ==
id)
91 if (
s->vps_list[
id]) {
92 if (
s->vps ==
s->vps_list[
id])
96 if (
s->sps_list[
i] &&
s->sps_list[
i]->vps_id ==
id)
112 if (rps !=
sps->st_rps &&
sps->nb_st_rps)
119 if (is_slice_header) {
123 "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
130 rps_ridx = &
sps->st_rps[rps -
sps->st_rps - 1];
136 "Invalid value of abs_delta_rps: %d\n",
149 if (i < rps_ridx->num_delta_pocs)
150 delta_poc = delta_rps + rps_ridx->
delta_poc[
i];
152 delta_poc = delta_rps;
162 "Invalid num_delta_pocs: %d\n", k);
174 for (k =
i - 1; k >= 0; k--) {
176 if (delta_poc <
tmp) {
200 unsigned int prev, nb_positive_pics;
215 if (delta_poc < 1 || delta_poc > 32768) {
217 "Invalid value of delta_poc: %d\n",
226 for (
i = 0;
i < nb_positive_pics;
i++) {
228 if (delta_poc < 1 || delta_poc > 32768) {
230 "Invalid value of delta_poc: %d\n",
268 for (
i = 0;
i < 32;
i++) {
271 if (
ptl->profile_idc == 0 &&
i > 0 &&
ptl->profile_compatibility_flag[
i])
272 ptl->profile_idc =
i;
279 #define check_profile_idc(idc) \
280 ptl->profile_idc == idc || ptl->profile_compatibility_flag[idc]
315 #undef check_profile_idc
321 PTL *
ptl,
int max_num_sub_layers)
325 get_bits_left(gb) < 8 + (8*2 * (max_num_sub_layers - 1 > 0))) {
332 for (
i = 0;
i < max_num_sub_layers - 1;
i++) {
337 if (max_num_sub_layers - 1> 0)
338 for (
i = max_num_sub_layers - 1;
i < 8;
i++)
340 for (
i = 0;
i < max_num_sub_layers - 1;
i++) {
344 "PTL information for sublayer %i too short\n",
i);
350 "Not enough data for sublayer %i level_idc\n",
i);
365 for (
i = 0;
i < nb_cpb;
i++) {
369 if (subpic_params_present) {
381 if (common_inf_present) {
408 for (
int i = 0;
i < max_sublayers;
i++) {
409 unsigned fixed_pic_rate_general_flag =
get_bits1(gb);
410 unsigned fixed_pic_rate_within_cvs_flag = 0;
411 unsigned low_delay_hrd_flag = 0;
414 if (!fixed_pic_rate_general_flag)
415 fixed_pic_rate_within_cvs_flag =
get_bits1(gb);
418 if (fixed_pic_rate_within_cvs_flag || fixed_pic_rate_general_flag)
424 if (!low_delay_hrd_flag) {
426 if (cpb_cnt_minus1 > 31) {
476 vps->data_size = nal_size;
482 vps->vps_id = vps_id;
500 vps->vps_max_sub_layers);
507 vps->vps_sub_layer_ordering_info_present_flag =
get_bits1(gb);
509 i =
vps->vps_sub_layer_ordering_info_present_flag ? 0 :
vps->vps_max_sub_layers - 1;
510 for (;
i <
vps->vps_max_sub_layers;
i++) {
517 vps->vps_max_dec_pic_buffering[
i] - 1);
520 if (
vps->vps_num_reorder_pics[
i] >
vps->vps_max_dec_pic_buffering[
i] - 1) {
522 vps->vps_num_reorder_pics[
i]);
530 if (
vps->vps_num_layer_sets < 1 ||
vps->vps_num_layer_sets > 1024 ||
536 for (
i = 1;
i <
vps->vps_num_layer_sets;
i++)
537 for (j = 0; j <=
vps->vps_max_layer_id; j++)
541 if (
vps->vps_timing_info_present_flag) {
544 vps->vps_poc_proportional_to_timing_flag =
get_bits1(gb);
545 if (
vps->vps_poc_proportional_to_timing_flag)
548 if (
vps->vps_num_hrd_parameters > (
unsigned)
vps->vps_num_layer_sets) {
550 "vps_num_hrd_parameters %d is invalid\n",
vps->vps_num_hrd_parameters);
554 if (
vps->vps_num_hrd_parameters) {
560 for (
i = 0;
i <
vps->vps_num_hrd_parameters;
i++) {
561 int common_inf_present = 1;
567 vps->vps_max_sub_layers);
592 VUI backup_vui, *vui = &
sps->vui;
603 switch (
sps->pix_fmt) {
623 memcpy(&backup, gb,
sizeof(backup));
624 memcpy(&backup_vui, vui,
sizeof(backup_vui));
639 if (apply_defdispwin &&
642 "discarding vui default display window, "
643 "original values are l:%u r:%u t:%u b:%u\n",
664 "Strange VUI timing information, retrying...\n");
665 memcpy(vui, &backup_vui,
sizeof(backup_vui));
666 memcpy(gb, &backup,
sizeof(backup));
688 "Strange VUI bitstream restriction information, retrying"
689 " from timing information...\n");
690 memcpy(vui, &backup_vui,
sizeof(backup_vui));
691 memcpy(gb, &backup,
sizeof(backup));
708 "Overread in VUI, retrying from timing information...\n");
709 memcpy(vui, &backup_vui,
sizeof(backup_vui));
710 memcpy(gb, &backup,
sizeof(backup));
720 for (matrixId = 0; matrixId < 6; matrixId++) {
722 memset(sl->
sl[0][matrixId], 16, 16);
723 sl->
sl_dc[0][matrixId] = 16;
724 sl->
sl_dc[1][matrixId] = 16;
749 uint8_t scaling_list_pred_mode_flag;
750 uint8_t scaling_list_dc_coef[2][6];
751 int size_id, matrix_id,
pos;
754 for (size_id = 0; size_id < 4; size_id++)
755 for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
756 scaling_list_pred_mode_flag =
get_bits1(gb);
757 if (!scaling_list_pred_mode_flag) {
763 delta *= (size_id == 3) ? 3 : 1;
764 if (matrix_id <
delta) {
766 "Invalid delta in scaling list data: %d.\n",
delta);
770 memcpy(sl->
sl[size_id][matrix_id],
771 sl->
sl[size_id][matrix_id -
delta],
772 size_id > 0 ? 64 : 16);
774 sl->
sl_dc[size_id - 2][matrix_id] = sl->
sl_dc[size_id - 2][matrix_id -
delta];
777 int next_coef, coef_num;
778 int32_t scaling_list_delta_coef;
781 coef_num =
FFMIN(64, 1 << (4 + (size_id << 1)));
784 if (scaling_list_coeff_minus8 < -7 ||
785 scaling_list_coeff_minus8 > 247)
787 scaling_list_dc_coef[size_id - 2][matrix_id] = scaling_list_coeff_minus8 + 8;
788 next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
789 sl->
sl_dc[size_id - 2][matrix_id] = next_coef;
791 for (
i = 0;
i < coef_num;
i++) {
800 next_coef = (next_coef + 256
U + scaling_list_delta_coef) % 256;
801 sl->
sl[size_id][matrix_id][
pos] = next_coef;
806 if (
sps->chroma_format_idc == 3) {
807 for (
i = 0;
i < 64;
i++) {
808 sl->
sl[3][1][
i] = sl->
sl[2][1][
i];
809 sl->
sl[3][2][
i] = sl->
sl[2][2][
i];
810 sl->
sl[3][4][
i] = sl->
sl[2][4][
i];
811 sl->
sl[3][5][
i] = sl->
sl[2][5][
i];
826 switch (
sps->bit_depth) {
853 "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
854 "chroma_format_idc is %d, depth is %d\n",
855 sps->chroma_format_idc,
sps->bit_depth);
863 sps->hshift[0] =
sps->vshift[0] = 0;
864 sps->hshift[2] =
sps->hshift[1] =
desc->log2_chroma_w;
865 sps->vshift[2] =
sps->vshift[1] =
desc->log2_chroma_h;
867 sps->pixel_shift =
sps->bit_depth > 8;
873 int apply_defdispwin,
const HEVCVPS *
const *vps_list,
878 int bit_depth_chroma, start, num_comps;
885 if (vps_list && !vps_list[
sps->vps_id]) {
894 sps->max_sub_layers);
910 if (
sps->chroma_format_idc > 3
U) {
915 if (
sps->chroma_format_idc == 3)
918 if (
sps->separate_colour_plane_flag)
919 sps->chroma_format_idc = 0;
924 sps->height, 0, avctx)) < 0)
928 if (
sps->conformance_window_flag) {
938 "discarding sps conformance window, "
939 "original values are l:%u r:%u t:%u b:%u\n",
940 sps->pic_conf_win.left_offset,
941 sps->pic_conf_win.right_offset,
942 sps->pic_conf_win.top_offset,
943 sps->pic_conf_win.bottom_offset);
945 sps->pic_conf_win.left_offset =
946 sps->pic_conf_win.right_offset =
947 sps->pic_conf_win.top_offset =
948 sps->pic_conf_win.bottom_offset = 0;
950 sps->output_window =
sps->pic_conf_win;
954 if (
sps->bit_depth > 16) {
960 if (bit_depth_chroma > 16) {
965 if (
sps->chroma_format_idc && bit_depth_chroma !=
sps->bit_depth) {
967 "Luma bit depth (%d) is different from chroma bit depth (%d), "
968 "this is unsupported.\n",
969 sps->bit_depth, bit_depth_chroma);
972 sps->bit_depth_chroma = bit_depth_chroma;
979 if (
sps->log2_max_poc_lsb > 16) {
981 sps->log2_max_poc_lsb - 4);
986 start =
sps->sublayer_ordering_info_flag ? 0 :
sps->max_sub_layers - 1;
987 for (
i = start;
i <
sps->max_sub_layers;
i++) {
993 sps->temporal_layer[
i].max_dec_pic_buffering - 1
U);
996 if (
sps->temporal_layer[
i].num_reorder_pics >
sps->temporal_layer[
i].max_dec_pic_buffering - 1) {
998 sps->temporal_layer[
i].num_reorder_pics);
1003 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[
i].num_reorder_pics + 1;
1007 if (!
sps->sublayer_ordering_info_flag) {
1008 for (
i = 0;
i < start;
i++) {
1009 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[start].max_dec_pic_buffering;
1010 sps->temporal_layer[
i].num_reorder_pics =
sps->temporal_layer[start].num_reorder_pics;
1011 sps->temporal_layer[
i].max_latency_increase =
sps->temporal_layer[start].max_latency_increase;
1019 sps->log2_max_trafo_size =
sps->log2_diff_max_min_transform_block_size +
1020 sps->log2_min_tb_size;
1022 if (
sps->log2_min_cb_size < 3 ||
sps->log2_min_cb_size > 30) {
1027 if (
sps->log2_diff_max_min_coding_block_size > 30) {
1028 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);
1032 if (
sps->log2_min_tb_size >=
sps->log2_min_cb_size ||
sps->log2_min_tb_size < 2) {
1037 if (
sps->log2_diff_max_min_transform_block_size > 30) {
1038 av_log(avctx,
AV_LOG_ERROR,
"Invalid value %d for log2_diff_max_min_transform_block_size",
1039 sps->log2_diff_max_min_transform_block_size);
1047 if (
sps->scaling_list_enable_flag) {
1061 if (
sps->pcm_enabled_flag) {
1065 sps->pcm.log2_max_pcm_cb_size =
sps->pcm.log2_min_pcm_cb_size +
1067 if (
FFMAX(
sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma) >
sps->bit_depth) {
1069 "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1070 sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma,
sps->bit_depth);
1083 for (
i = 0;
i <
sps->nb_st_rps;
i++) {
1090 if (
sps->long_term_ref_pics_present_flag) {
1094 sps->num_long_term_ref_pics_sps);
1097 for (
i = 0;
i <
sps->num_long_term_ref_pics_sps;
i++) {
1104 sps->sps_strong_intra_smoothing_enable_flag =
get_bits1(gb);
1107 if (
sps->vui_present)
1111 if (
sps->sps_extension_present_flag) {
1118 if (
sps->sps_range_extension_flag) {
1119 sps->transform_skip_rotation_enabled_flag =
get_bits1(gb);
1120 sps->transform_skip_context_enabled_flag =
get_bits1(gb);
1125 sps->extended_precision_processing_flag =
get_bits1(gb);
1126 if (
sps->extended_precision_processing_flag)
1128 "extended_precision_processing_flag not yet implemented\n");
1131 sps->high_precision_offsets_enabled_flag =
get_bits1(gb);
1132 if (
sps->high_precision_offsets_enabled_flag)
1134 "high_precision_offsets_enabled_flag not yet implemented\n");
1136 sps->persistent_rice_adaptation_enabled_flag =
get_bits1(gb);
1138 sps->cabac_bypass_alignment_enabled_flag =
get_bits1(gb);
1139 if (
sps->cabac_bypass_alignment_enabled_flag)
1141 "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1144 if (
sps->sps_multilayer_extension_flag) {
1147 "sps_multilayer_extension_flag not yet implemented\n");
1150 if (
sps->sps_3d_extension_flag) {
1151 for (
i = 0;
i <= 1;
i++) {
1171 "sps_3d_extension_flag not yet implemented\n");
1174 if (
sps->sps_scc_extension_flag) {
1177 if (
sps->palette_mode_enabled_flag) {
1180 sps->sps_palette_predictor_initializers_present_flag =
get_bits1(gb);
1182 if (
sps->sps_palette_predictor_initializers_present_flag) {
1186 "sps_num_palette_predictor_initializers out of range: %u\n",
1187 sps->sps_num_palette_predictor_initializers);
1190 num_comps = !
sps->chroma_format_idc ? 1 : 3;
1193 for (
i = 0;
i <
sps->sps_num_palette_predictor_initializers;
i++)
1198 sps->motion_vector_resolution_control_idc =
get_bits(gb, 2);
1199 sps->intra_boundary_filtering_disabled_flag =
get_bits1(gb);
1202 if (apply_defdispwin) {
1203 sps->output_window.left_offset +=
sps->vui.def_disp_win.left_offset;
1204 sps->output_window.right_offset +=
sps->vui.def_disp_win.right_offset;
1205 sps->output_window.top_offset +=
sps->vui.def_disp_win.top_offset;
1206 sps->output_window.bottom_offset +=
sps->vui.def_disp_win.bottom_offset;
1209 ow = &
sps->output_window;
1220 "Displaying the whole video surface.\n");
1221 memset(ow, 0,
sizeof(*ow));
1222 memset(&
sps->pic_conf_win, 0,
sizeof(
sps->pic_conf_win));
1226 sps->log2_ctb_size =
sps->log2_min_cb_size +
1227 sps->log2_diff_max_min_coding_block_size;
1228 sps->log2_min_pu_size =
sps->log2_min_cb_size - 1;
1234 if (
sps->log2_ctb_size < 4) {
1237 "log2_ctb_size %d differs from the bounds of any known profile\n",
1238 sps->log2_ctb_size);
1243 sps->ctb_width = (
sps->width + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1244 sps->ctb_height = (
sps->height + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1245 sps->ctb_size =
sps->ctb_width *
sps->ctb_height;
1247 sps->min_cb_width =
sps->width >>
sps->log2_min_cb_size;
1248 sps->min_cb_height =
sps->height >>
sps->log2_min_cb_size;
1249 sps->min_tb_width =
sps->width >>
sps->log2_min_tb_size;
1250 sps->min_tb_height =
sps->height >>
sps->log2_min_tb_size;
1251 sps->min_pu_width =
sps->width >>
sps->log2_min_pu_size;
1252 sps->min_pu_height =
sps->height >>
sps->log2_min_pu_size;
1253 sps->tb_mask = (1 << (
sps->log2_ctb_size -
sps->log2_min_tb_size)) - 1;
1255 sps->qp_bd_offset = 6 * (
sps->bit_depth - 8);
1263 if (
sps->max_transform_hierarchy_depth_inter >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1264 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_inter out of range: %d\n",
1265 sps->max_transform_hierarchy_depth_inter);
1268 if (
sps->max_transform_hierarchy_depth_intra >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1269 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_intra out of range: %d\n",
1270 sps->max_transform_hierarchy_depth_intra);
1273 if (
sps->log2_max_trafo_size >
FFMIN(
sps->log2_ctb_size, 5)) {
1275 "max transform block size out of range: %d\n",
1276 sps->log2_max_trafo_size);
1306 unsigned int sps_id;
1329 "Parsed SPS: id %d; coded wxh: %dx%d; "
1330 "cropped wxh: %dx%d; pix_fmt: %s.\n",
1331 sps_id,
sps->width,
sps->height,
1332 sps->width - (
sps->output_window.left_offset +
sps->output_window.right_offset),
1333 sps->height - (
sps->output_window.top_offset +
sps->output_window.bottom_offset),
1372 int idx_y,
int idx_cb,
int idx_cr,
int inp_length)
1374 unsigned int split_octant_flag, part_num_y, coded_res_flag, res_coeff_q, res_coeff_r;
1377 part_num_y = 1 <<
pps->cm_y_part_num_log2;
1379 split_octant_flag = inp_depth <
pps->cm_octant_depth ?
get_bits1(gb) : 0;
1381 if (split_octant_flag)
1382 for (
int k = 0; k < 2; k++)
1383 for (
int m = 0; m < 2; m++)
1384 for (
int n = 0; n < 2; n++)
1386 idx_y + part_num_y * k * inp_length / 2,
1387 idx_cb + m * inp_length / 2,
1388 idx_cr + n * inp_length / 2,
1391 for (
int i = 0;
i < part_num_y;
i++) {
1392 for (
int j = 0; j < 4; j++) {
1395 for (
int c = 0;
c < 3;
c++) {
1397 cm_res_bits =
FFMAX(0, 10 +
pps->luma_bit_depth_cm_input -
1398 pps->luma_bit_depth_cm_output -
1399 pps->cm_res_quant_bits -
pps->cm_delta_flc_bits);
1400 res_coeff_r = cm_res_bits ?
get_bits(gb, cm_res_bits) : 0;
1401 if (res_coeff_q || res_coeff_r)
1411 if (
pps->num_cm_ref_layers > 62) {
1413 "num_cm_ref_layers_minus1 shall be in the range [0, 61].\n");
1416 for (
int i = 0;
i <
pps->num_cm_ref_layers;
i++)
1430 if (
pps->cm_octant_depth == 1) {
1445 if (
pps->pps_infer_scaling_list_flag)
1446 pps->pps_scaling_list_ref_layer_id =
get_bits(gb, 6);
1449 if (
pps->num_ref_loc_offsets >
vps->vps_max_layers - 1)
1452 for (
int i = 0;
i <
pps->num_ref_loc_offsets;
i++) {
1454 pps->scaled_ref_layer_offset_present_flag[
i] =
get_bits1(gb);
1455 if (
pps->scaled_ref_layer_offset_present_flag[
i]) {
1463 if (
pps->ref_region_offset_present_flag[
i]) {
1471 if (
pps->resample_phase_set_present_flag[
i]) {
1480 if (
pps->colour_mapping_enabled_flag) {
1491 unsigned int num_val_delta_dlt, max_diff = 0;
1492 int min_diff_minus1 = -1;
1495 num_val_delta_dlt =
get_bits(gb,
pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1496 if (num_val_delta_dlt) {
1497 if (num_val_delta_dlt > 1)
1498 max_diff =
get_bits(gb,
pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1499 if (num_val_delta_dlt > 2 && max_diff) {
1503 if (max_diff > (min_diff_minus1 + 1))
1504 for (
int k = 1; k < num_val_delta_dlt; k++) {
1505 len =
av_log2(max_diff - (min_diff_minus1 + 1)) + 1;
1514 unsigned int pps_depth_layers_minus1;
1517 pps_depth_layers_minus1 =
get_bits(gb, 6);
1518 pps->pps_bit_depth_for_depth_layers_minus8 =
get_bits(gb, 4);
1519 for (
int i = 0;
i <= pps_depth_layers_minus1;
i++) {
1523 for (
int j = 0; j <= ((1 << (
pps->pps_bit_depth_for_depth_layers_minus8 + 8)) - 1); j++)
1538 if (
pps->transform_skip_enabled_flag) {
1541 pps->cross_component_prediction_enabled_flag =
get_bits1(gb);
1542 pps->chroma_qp_offset_list_enabled_flag =
get_bits1(gb);
1543 if (
pps->chroma_qp_offset_list_enabled_flag) {
1546 if (
pps->chroma_qp_offset_list_len_minus1 > 5) {
1548 "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1551 for (
int i = 0;
i <=
pps->chroma_qp_offset_list_len_minus1;
i++) {
1553 if (
pps->cb_qp_offset_list[
i]) {
1555 "cb_qp_offset_list not tested yet.\n");
1558 if (
pps->cr_qp_offset_list[
i]) {
1560 "cb_qp_offset_list not tested yet.\n");
1567 if (
pps->log2_sao_offset_scale_luma >
FFMAX(
sps->bit_depth - 10, 0)
1568 ||
pps->log2_sao_offset_scale_chroma >
FFMAX(
sps->bit_depth_chroma - 10, 0)
1581 if (
pps->residual_adaptive_colour_transform_enabled_flag =
get_bits1(gb)) {
1582 pps->pps_slice_act_qp_offsets_present_flag =
get_bits1(gb);
1587 #define CHECK_QP_OFFSET(name) (pps->pps_act_ ## name ## _qp_offset <= -12 || \
1588 pps->pps_act_ ## name ## _qp_offset >= 12)
1590 #undef CHECK_QP_OFFSET
1593 "PpsActQpOffsetY/Cb/Cr shall be in the range of [-12, 12].\n");
1598 if (
pps->pps_palette_predictor_initializers_present_flag =
get_bits1(gb)) {
1600 if (
pps->pps_num_palette_predictor_initializers > 0) {
1603 "pps_num_palette_predictor_initializers out of range: %u\n",
1604 pps->pps_num_palette_predictor_initializers);
1609 if (
pps->luma_bit_depth_entry !=
sps->bit_depth)
1611 if (!
pps->monochrome_palette_flag) {
1613 if (
pps->chroma_bit_depth_entry !=
sps->bit_depth_chroma)
1617 num_comps =
pps->monochrome_palette_flag ? 1 : 3;
1620 for (
int i = 0;
i <
pps->pps_num_palette_predictor_initializers;
i++)
1633 int pic_area_in_ctbs;
1634 int i, j, x, y, ctb_addr_rs, tile_id;
1640 if (!
pps->col_bd || !
pps->row_bd || !
pps->col_idxX)
1643 if (
pps->uniform_spacing_flag) {
1644 if (!
pps->column_width) {
1648 if (!
pps->column_width || !
pps->row_height)
1651 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
1652 pps->column_width[
i] = ((
i + 1) *
sps->ctb_width) /
pps->num_tile_columns -
1653 (
i *
sps->ctb_width) /
pps->num_tile_columns;
1656 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
1657 pps->row_height[
i] = ((
i + 1) *
sps->ctb_height) /
pps->num_tile_rows -
1658 (
i *
sps->ctb_height) /
pps->num_tile_rows;
1663 for (
i = 0;
i <
pps->num_tile_columns;
i++)
1664 pps->col_bd[
i + 1] =
pps->col_bd[
i] +
pps->column_width[
i];
1667 for (
i = 0;
i <
pps->num_tile_rows;
i++)
1668 pps->row_bd[
i + 1] =
pps->row_bd[
i] +
pps->row_height[
i];
1670 for (
i = 0, j = 0;
i <
sps->ctb_width;
i++) {
1671 if (
i >
pps->col_bd[j])
1673 pps->col_idxX[
i] = j;
1679 pic_area_in_ctbs =
sps->ctb_width *
sps->ctb_height;
1685 if (!
pps->ctb_addr_rs_to_ts || !
pps->ctb_addr_ts_to_rs ||
1686 !
pps->tile_id || !
pps->min_tb_addr_zs_tab) {
1690 for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1691 int tb_x = ctb_addr_rs %
sps->ctb_width;
1692 int tb_y = ctb_addr_rs /
sps->ctb_width;
1697 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
1698 if (tb_x < pps->col_bd[
i + 1]) {
1704 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
1705 if (tb_y < pps->row_bd[
i + 1]) {
1711 for (
i = 0;
i < tile_x;
i++)
1712 val +=
pps->row_height[tile_y] *
pps->column_width[
i];
1713 for (
i = 0;
i < tile_y;
i++)
1716 val += (tb_y -
pps->row_bd[tile_y]) *
pps->column_width[tile_x] +
1717 tb_x -
pps->col_bd[tile_x];
1719 pps->ctb_addr_rs_to_ts[ctb_addr_rs] =
val;
1720 pps->ctb_addr_ts_to_rs[
val] = ctb_addr_rs;
1723 for (j = 0, tile_id = 0; j <
pps->num_tile_rows; j++)
1724 for (
i = 0;
i <
pps->num_tile_columns;
i++, tile_id++)
1725 for (y =
pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1726 for (x =
pps->col_bd[
i]; x < pps->col_bd[
i + 1]; x++)
1727 pps->tile_id[
pps->ctb_addr_rs_to_ts[y *
sps->ctb_width + x]] = tile_id;
1730 if (!
pps->tile_pos_rs)
1733 for (j = 0; j <
pps->num_tile_rows; j++)
1734 for (
i = 0;
i <
pps->num_tile_columns;
i++)
1735 pps->tile_pos_rs[j *
pps->num_tile_columns +
i] =
1736 pps->row_bd[j] *
sps->ctb_width +
pps->col_bd[
i];
1738 log2_diff =
sps->log2_ctb_size -
sps->log2_min_tb_size;
1739 pps->min_tb_addr_zs = &
pps->min_tb_addr_zs_tab[1*(
sps->tb_mask+2)+1];
1740 for (y = 0; y <
sps->tb_mask+2; y++) {
1741 pps->min_tb_addr_zs_tab[y*(
sps->tb_mask+2)] = -1;
1742 pps->min_tb_addr_zs_tab[y] = -1;
1744 for (y = 0; y <
sps->tb_mask+1; y++) {
1745 for (x = 0; x <
sps->tb_mask+1; x++) {
1746 int tb_x = x >> log2_diff;
1747 int tb_y = y >> log2_diff;
1748 int rs =
sps->ctb_width * tb_y + tb_x;
1749 int val =
pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
1750 for (
i = 0;
i < log2_diff;
i++) {
1752 val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1754 pps->min_tb_addr_zs[y * (
sps->tb_mask+2) + x] =
val;
1769 unsigned log2_parallel_merge_level_minus2;
1790 pps->data_size = nal_size;
1798 pps->loop_filter_across_tiles_enabled_flag = 1;
1799 pps->num_tile_columns = 1;
1800 pps->num_tile_rows = 1;
1801 pps->uniform_spacing_flag = 1;
1802 pps->disable_dbf = 0;
1803 pps->beta_offset = 0;
1805 pps->log2_max_transform_skip_block_size = 2;
1808 pps->pps_id = pps_id;
1823 pps->dependent_slice_segments_enabled_flag =
get_bits1(gb);
1825 pps->num_extra_slice_header_bits =
get_bits(gb, 3);
1836 pps->num_ref_idx_l0_default_active,
pps->num_ref_idx_l1_default_active);
1846 pps->diff_cu_qp_delta_depth = 0;
1847 if (
pps->cu_qp_delta_enabled_flag)
1850 if (
pps->diff_cu_qp_delta_depth < 0 ||
1851 pps->diff_cu_qp_delta_depth >
sps->log2_diff_max_min_coding_block_size) {
1853 pps->diff_cu_qp_delta_depth);
1859 if (
pps->cb_qp_offset < -12 ||
pps->cb_qp_offset > 12) {
1866 if (
pps->cr_qp_offset < -12 ||
pps->cr_qp_offset > 12) {
1872 pps->pic_slice_level_chroma_qp_offsets_present_flag =
get_bits1(gb);
1881 if (
pps->tiles_enabled_flag) {
1885 if (num_tile_columns_minus1 < 0 ||
1886 num_tile_columns_minus1 >=
sps->ctb_width) {
1888 num_tile_columns_minus1);
1892 if (num_tile_rows_minus1 < 0 ||
1893 num_tile_rows_minus1 >=
sps->ctb_height) {
1895 num_tile_rows_minus1);
1899 pps->num_tile_columns = num_tile_columns_minus1 + 1;
1900 pps->num_tile_rows = num_tile_rows_minus1 + 1;
1904 if (!
pps->column_width || !
pps->row_height) {
1910 if (!
pps->uniform_spacing_flag) {
1912 for (
i = 0;
i <
pps->num_tile_columns - 1;
i++) {
1914 sum +=
pps->column_width[
i];
1916 if (sum >=
sps->ctb_width) {
1921 pps->column_width[
pps->num_tile_columns - 1] =
sps->ctb_width - sum;
1924 for (
i = 0;
i <
pps->num_tile_rows - 1;
i++) {
1926 sum +=
pps->row_height[
i];
1928 if (sum >=
sps->ctb_height) {
1933 pps->row_height[
pps->num_tile_rows - 1] =
sps->ctb_height - sum;
1935 pps->loop_filter_across_tiles_enabled_flag =
get_bits1(gb);
1938 pps->seq_loop_filter_across_slices_enabled_flag =
get_bits1(gb);
1940 pps->deblocking_filter_control_present_flag =
get_bits1(gb);
1941 if (
pps->deblocking_filter_control_present_flag) {
1942 pps->deblocking_filter_override_enabled_flag =
get_bits1(gb);
1944 if (!
pps->disable_dbf) {
1947 if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
1953 if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1959 pps->beta_offset = 2 * beta_offset_div2;
1960 pps->tc_offset = 2 * tc_offset_div2;
1965 if (
pps->scaling_list_data_present_flag) {
1973 if (log2_parallel_merge_level_minus2 >
sps->log2_ctb_size) {
1975 log2_parallel_merge_level_minus2);
1979 pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
1981 pps->slice_header_extension_present_flag =
get_bits1(gb);
1984 if (
pps->pps_extension_present_flag) {
1996 if (
pps->pps_multilayer_extension_flag) {
2001 if (
pps->pps_3d_extension_flag) {
2006 if (
pps->pps_scc_extension_flag) {
2049 int max_poc_lsb = 1 <<
sps->log2_max_poc_lsb;
2050 int prev_poc_lsb = pocTid0 % max_poc_lsb;
2051 int prev_poc_msb = pocTid0 - prev_poc_lsb;
2054 if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
2055 poc_msb = prev_poc_msb + max_poc_lsb;
2056 else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
2057 poc_msb = prev_poc_msb - max_poc_lsb;
2059 poc_msb = prev_poc_msb;
2067 return poc_msb + poc_lsb;