33 16, 16, 16, 16, 17, 18, 21, 24,
34 16, 16, 16, 16, 17, 19, 22, 25,
35 16, 16, 17, 18, 20, 22, 25, 29,
36 16, 16, 18, 21, 24, 27, 31, 36,
37 17, 17, 20, 24, 30, 35, 41, 47,
38 18, 19, 22, 27, 35, 44, 54, 65,
39 21, 22, 25, 31, 41, 54, 70, 88,
40 24, 25, 29, 36, 47, 65, 88, 115
44 16, 16, 16, 16, 17, 18, 20, 24,
45 16, 16, 16, 17, 18, 20, 24, 25,
46 16, 16, 17, 18, 20, 24, 25, 28,
47 16, 17, 18, 20, 24, 25, 28, 33,
48 17, 18, 20, 24, 25, 28, 33, 41,
49 18, 20, 24, 25, 28, 33, 41, 54,
50 20, 24, 25, 28, 33, 41, 54, 71,
51 24, 25, 28, 33, 41, 54, 71, 91
64 if (
s->pps_list[
id] &&
s->pps == (
const HEVCPPS*)
s->pps_list[
id]->data)
72 if (
s->sps_list[
id]) {
73 if (
s->sps == (
const HEVCSPS*)
s->sps_list[
id]->data)
78 if (
s->pps_list[
i] && ((
HEVCPPS*)
s->pps_list[
i]->data)->sps_id ==
id)
89 if (
s->vps_list[
id]) {
90 if (
s->vps == (
const HEVCVPS*)
s->vps_list[
id]->data)
94 if (
s->sps_list[
i] && ((
HEVCSPS*)
s->sps_list[
i]->data)->vps_id ==
id)
110 if (rps !=
sps->st_rps &&
sps->nb_st_rps)
117 if (is_slice_header) {
121 "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
128 rps_ridx = &
sps->st_rps[rps -
sps->st_rps - 1];
134 "Invalid value of abs_delta_rps: %d\n",
147 if (i < rps_ridx->num_delta_pocs)
148 delta_poc = delta_rps + rps_ridx->
delta_poc[
i];
150 delta_poc = delta_rps;
160 "Invalid num_delta_pocs: %d\n", k);
172 for (k =
i - 1; k >= 0; k--) {
174 if (delta_poc <
tmp) {
198 unsigned int prev, nb_positive_pics;
213 if (delta_poc < 1 || delta_poc > 32768) {
215 "Invalid value of delta_poc: %d\n",
224 for (
i = 0;
i < nb_positive_pics;
i++) {
226 if (delta_poc < 1 || delta_poc > 32768) {
228 "Invalid value of delta_poc: %d\n",
266 for (
i = 0;
i < 32;
i++) {
269 if (
ptl->profile_idc == 0 &&
i > 0 &&
ptl->profile_compatibility_flag[
i])
270 ptl->profile_idc =
i;
277 #define check_profile_idc(idc) \
278 ptl->profile_idc == idc || ptl->profile_compatibility_flag[idc]
313 #undef check_profile_idc
319 PTL *
ptl,
int max_num_sub_layers)
323 get_bits_left(gb) < 8 + (8*2 * (max_num_sub_layers - 1 > 0))) {
330 for (
i = 0;
i < max_num_sub_layers - 1;
i++) {
335 if (max_num_sub_layers - 1> 0)
336 for (
i = max_num_sub_layers - 1;
i < 8;
i++)
338 for (
i = 0;
i < max_num_sub_layers - 1;
i++) {
342 "PTL information for sublayer %i too short\n",
i);
348 "Not enough data for sublayer %i level_idc\n",
i);
363 for (
i = 0;
i < nb_cpb;
i++) {
367 if (subpic_params_present) {
379 if (common_inf_present) {
406 for (
int i = 0;
i < max_sublayers;
i++) {
455 if (nal_size >
sizeof(
vps->data)) {
458 nal_size,
sizeof(
vps->data));
459 vps->data_size =
sizeof(
vps->data);
461 vps->data_size = nal_size;
483 vps->vps_max_sub_layers);
490 vps->vps_sub_layer_ordering_info_present_flag =
get_bits1(gb);
492 i =
vps->vps_sub_layer_ordering_info_present_flag ? 0 :
vps->vps_max_sub_layers - 1;
493 for (;
i <
vps->vps_max_sub_layers;
i++) {
500 vps->vps_max_dec_pic_buffering[
i] - 1);
503 if (
vps->vps_num_reorder_pics[
i] >
vps->vps_max_dec_pic_buffering[
i] - 1) {
505 vps->vps_num_reorder_pics[
i]);
513 if (
vps->vps_num_layer_sets < 1 ||
vps->vps_num_layer_sets > 1024 ||
519 for (
i = 1;
i <
vps->vps_num_layer_sets;
i++)
520 for (j = 0; j <=
vps->vps_max_layer_id; j++)
524 if (
vps->vps_timing_info_present_flag) {
527 vps->vps_poc_proportional_to_timing_flag =
get_bits1(gb);
528 if (
vps->vps_poc_proportional_to_timing_flag)
531 if (
vps->vps_num_hrd_parameters > (
unsigned)
vps->vps_num_layer_sets) {
533 "vps_num_hrd_parameters %d is invalid\n",
vps->vps_num_hrd_parameters);
536 for (
i = 0;
i <
vps->vps_num_hrd_parameters;
i++) {
537 int common_inf_present = 1;
543 vps->vps_max_sub_layers);
573 VUI backup_vui, *vui = &
sps->vui;
584 switch (
sps->pix_fmt) {
604 memcpy(&backup, gb,
sizeof(backup));
605 memcpy(&backup_vui, vui,
sizeof(backup_vui));
620 if (apply_defdispwin &&
623 "discarding vui default display window, "
624 "original values are l:%u r:%u t:%u b:%u\n",
645 "Strange VUI timing information, retrying...\n");
646 memcpy(vui, &backup_vui,
sizeof(backup_vui));
647 memcpy(gb, &backup,
sizeof(backup));
669 "Strange VUI bitstream restriction information, retrying"
670 " from timing information...\n");
671 memcpy(vui, &backup_vui,
sizeof(backup_vui));
672 memcpy(gb, &backup,
sizeof(backup));
689 "Overread in VUI, retrying from timing information...\n");
690 memcpy(vui, &backup_vui,
sizeof(backup_vui));
691 memcpy(gb, &backup,
sizeof(backup));
701 for (matrixId = 0; matrixId < 6; matrixId++) {
703 memset(sl->
sl[0][matrixId], 16, 16);
704 sl->
sl_dc[0][matrixId] = 16;
705 sl->
sl_dc[1][matrixId] = 16;
730 uint8_t scaling_list_pred_mode_flag;
731 uint8_t scaling_list_dc_coef[2][6];
732 int size_id, matrix_id,
pos;
735 for (size_id = 0; size_id < 4; size_id++)
736 for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
737 scaling_list_pred_mode_flag =
get_bits1(gb);
738 if (!scaling_list_pred_mode_flag) {
744 delta *= (size_id == 3) ? 3 : 1;
745 if (matrix_id <
delta) {
747 "Invalid delta in scaling list data: %d.\n",
delta);
751 memcpy(sl->
sl[size_id][matrix_id],
752 sl->
sl[size_id][matrix_id -
delta],
753 size_id > 0 ? 64 : 16);
755 sl->
sl_dc[size_id - 2][matrix_id] = sl->
sl_dc[size_id - 2][matrix_id -
delta];
758 int next_coef, coef_num;
759 int32_t scaling_list_delta_coef;
762 coef_num =
FFMIN(64, 1 << (4 + (size_id << 1)));
765 if (scaling_list_coeff_minus8 < -7 ||
766 scaling_list_coeff_minus8 > 247)
768 scaling_list_dc_coef[size_id - 2][matrix_id] = scaling_list_coeff_minus8 + 8;
769 next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
770 sl->
sl_dc[size_id - 2][matrix_id] = next_coef;
772 for (
i = 0;
i < coef_num;
i++) {
781 next_coef = (next_coef + 256
U + scaling_list_delta_coef) % 256;
782 sl->
sl[size_id][matrix_id][
pos] = next_coef;
787 if (
sps->chroma_format_idc == 3) {
788 for (
i = 0;
i < 64;
i++) {
789 sl->
sl[3][1][
i] = sl->
sl[2][1][
i];
790 sl->
sl[3][2][
i] = sl->
sl[2][2][
i];
791 sl->
sl[3][4][
i] = sl->
sl[2][4][
i];
792 sl->
sl[3][5][
i] = sl->
sl[2][5][
i];
807 switch (
sps->bit_depth) {
834 "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
835 "chroma_format_idc is %d, depth is %d\n",
836 sps->chroma_format_idc,
sps->bit_depth);
844 sps->hshift[0] =
sps->vshift[0] = 0;
845 sps->hshift[2] =
sps->hshift[1] =
desc->log2_chroma_w;
846 sps->vshift[2] =
sps->vshift[1] =
desc->log2_chroma_h;
848 sps->pixel_shift =
sps->bit_depth > 8;
858 int bit_depth_chroma, start, num_comps;
865 if (vps_list && !vps_list[
sps->vps_id]) {
874 sps->max_sub_layers);
890 if (
sps->chroma_format_idc > 3
U) {
895 if (
sps->chroma_format_idc == 3)
898 if (
sps->separate_colour_plane_flag)
899 sps->chroma_format_idc = 0;
904 sps->height, 0, avctx)) < 0)
908 if (
sps->conformance_window_flag) {
918 "discarding sps conformance window, "
919 "original values are l:%u r:%u t:%u b:%u\n",
920 sps->pic_conf_win.left_offset,
921 sps->pic_conf_win.right_offset,
922 sps->pic_conf_win.top_offset,
923 sps->pic_conf_win.bottom_offset);
925 sps->pic_conf_win.left_offset =
926 sps->pic_conf_win.right_offset =
927 sps->pic_conf_win.top_offset =
928 sps->pic_conf_win.bottom_offset = 0;
930 sps->output_window =
sps->pic_conf_win;
934 if (
sps->bit_depth > 16) {
940 if (bit_depth_chroma > 16) {
945 if (
sps->chroma_format_idc && bit_depth_chroma !=
sps->bit_depth) {
947 "Luma bit depth (%d) is different from chroma bit depth (%d), "
948 "this is unsupported.\n",
949 sps->bit_depth, bit_depth_chroma);
952 sps->bit_depth_chroma = bit_depth_chroma;
959 if (
sps->log2_max_poc_lsb > 16) {
961 sps->log2_max_poc_lsb - 4);
966 start =
sps->sublayer_ordering_info_flag ? 0 :
sps->max_sub_layers - 1;
967 for (
i = start;
i <
sps->max_sub_layers;
i++) {
973 sps->temporal_layer[
i].max_dec_pic_buffering - 1
U);
976 if (
sps->temporal_layer[
i].num_reorder_pics >
sps->temporal_layer[
i].max_dec_pic_buffering - 1) {
978 sps->temporal_layer[
i].num_reorder_pics);
983 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[
i].num_reorder_pics + 1;
987 if (!
sps->sublayer_ordering_info_flag) {
988 for (
i = 0;
i < start;
i++) {
989 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[start].max_dec_pic_buffering;
990 sps->temporal_layer[
i].num_reorder_pics =
sps->temporal_layer[start].num_reorder_pics;
991 sps->temporal_layer[
i].max_latency_increase =
sps->temporal_layer[start].max_latency_increase;
999 sps->log2_max_trafo_size =
sps->log2_diff_max_min_transform_block_size +
1000 sps->log2_min_tb_size;
1002 if (
sps->log2_min_cb_size < 3 ||
sps->log2_min_cb_size > 30) {
1007 if (
sps->log2_diff_max_min_coding_block_size > 30) {
1008 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);
1012 if (
sps->log2_min_tb_size >=
sps->log2_min_cb_size ||
sps->log2_min_tb_size < 2) {
1017 if (
sps->log2_diff_max_min_transform_block_size > 30) {
1018 av_log(avctx,
AV_LOG_ERROR,
"Invalid value %d for log2_diff_max_min_transform_block_size",
1019 sps->log2_diff_max_min_transform_block_size);
1027 if (
sps->scaling_list_enable_flag) {
1041 if (
sps->pcm_enabled_flag) {
1045 sps->pcm.log2_max_pcm_cb_size =
sps->pcm.log2_min_pcm_cb_size +
1047 if (
FFMAX(
sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma) >
sps->bit_depth) {
1049 "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1050 sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma,
sps->bit_depth);
1063 for (
i = 0;
i <
sps->nb_st_rps;
i++) {
1070 if (
sps->long_term_ref_pics_present_flag) {
1074 sps->num_long_term_ref_pics_sps);
1077 for (
i = 0;
i <
sps->num_long_term_ref_pics_sps;
i++) {
1084 sps->sps_strong_intra_smoothing_enable_flag =
get_bits1(gb);
1087 if (
sps->vui_present)
1091 if (
sps->sps_extension_present_flag) {
1098 if (
sps->sps_range_extension_flag) {
1099 sps->transform_skip_rotation_enabled_flag =
get_bits1(gb);
1100 sps->transform_skip_context_enabled_flag =
get_bits1(gb);
1105 sps->extended_precision_processing_flag =
get_bits1(gb);
1106 if (
sps->extended_precision_processing_flag)
1108 "extended_precision_processing_flag not yet implemented\n");
1111 sps->high_precision_offsets_enabled_flag =
get_bits1(gb);
1112 if (
sps->high_precision_offsets_enabled_flag)
1114 "high_precision_offsets_enabled_flag not yet implemented\n");
1116 sps->persistent_rice_adaptation_enabled_flag =
get_bits1(gb);
1118 sps->cabac_bypass_alignment_enabled_flag =
get_bits1(gb);
1119 if (
sps->cabac_bypass_alignment_enabled_flag)
1121 "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1124 if (
sps->sps_multilayer_extension_flag) {
1127 "sps_multilayer_extension_flag not yet implemented\n");
1130 if (
sps->sps_3d_extension_flag) {
1131 for (
i = 0;
i <= 1;
i++) {
1151 "sps_3d_extension_flag not yet implemented\n");
1154 if (
sps->sps_scc_extension_flag) {
1157 if (
sps->palette_mode_enabled_flag) {
1160 sps->sps_palette_predictor_initializers_present_flag =
get_bits1(gb);
1162 if (
sps->sps_palette_predictor_initializers_present_flag) {
1166 "sps_num_palette_predictor_initializers out of range: %u\n",
1167 sps->sps_num_palette_predictor_initializers);
1170 num_comps = !
sps->chroma_format_idc ? 1 : 3;
1173 for (
i = 0;
i <
sps->sps_num_palette_predictor_initializers;
i++)
1178 sps->motion_vector_resolution_control_idc =
get_bits(gb, 2);
1179 sps->intra_boundary_filtering_disabled_flag =
get_bits1(gb);
1182 if (apply_defdispwin) {
1183 sps->output_window.left_offset +=
sps->vui.def_disp_win.left_offset;
1184 sps->output_window.right_offset +=
sps->vui.def_disp_win.right_offset;
1185 sps->output_window.top_offset +=
sps->vui.def_disp_win.top_offset;
1186 sps->output_window.bottom_offset +=
sps->vui.def_disp_win.bottom_offset;
1189 ow = &
sps->output_window;
1200 "Displaying the whole video surface.\n");
1201 memset(ow, 0,
sizeof(*ow));
1202 memset(&
sps->pic_conf_win, 0,
sizeof(
sps->pic_conf_win));
1206 sps->log2_ctb_size =
sps->log2_min_cb_size +
1207 sps->log2_diff_max_min_coding_block_size;
1208 sps->log2_min_pu_size =
sps->log2_min_cb_size - 1;
1214 if (
sps->log2_ctb_size < 4) {
1217 "log2_ctb_size %d differs from the bounds of any known profile\n",
1218 sps->log2_ctb_size);
1223 sps->ctb_width = (
sps->width + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1224 sps->ctb_height = (
sps->height + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1225 sps->ctb_size =
sps->ctb_width *
sps->ctb_height;
1227 sps->min_cb_width =
sps->width >>
sps->log2_min_cb_size;
1228 sps->min_cb_height =
sps->height >>
sps->log2_min_cb_size;
1229 sps->min_tb_width =
sps->width >>
sps->log2_min_tb_size;
1230 sps->min_tb_height =
sps->height >>
sps->log2_min_tb_size;
1231 sps->min_pu_width =
sps->width >>
sps->log2_min_pu_size;
1232 sps->min_pu_height =
sps->height >>
sps->log2_min_pu_size;
1233 sps->tb_mask = (1 << (
sps->log2_ctb_size -
sps->log2_min_tb_size)) - 1;
1235 sps->qp_bd_offset = 6 * (
sps->bit_depth - 8);
1243 if (
sps->max_transform_hierarchy_depth_inter >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1244 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_inter out of range: %d\n",
1245 sps->max_transform_hierarchy_depth_inter);
1248 if (
sps->max_transform_hierarchy_depth_intra >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1249 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_intra out of range: %d\n",
1250 sps->max_transform_hierarchy_depth_intra);
1253 if (
sps->log2_max_trafo_size >
FFMIN(
sps->log2_ctb_size, 5)) {
1255 "max transform block size out of range: %d\n",
1256 sps->log2_max_trafo_size);
1274 unsigned int sps_id;
1285 if (nal_size >
sizeof(
sps->data)) {
1288 nal_size,
sizeof(
sps->data));
1289 sps->data_size =
sizeof(
sps->data);
1291 sps->data_size = nal_size;
1305 "Parsed SPS: id %d; coded wxh: %dx%d; "
1306 "cropped wxh: %dx%d; pix_fmt: %s.\n",
1307 sps_id,
sps->width,
sps->height,
1308 sps->width - (
sps->output_window.left_offset +
sps->output_window.right_offset),
1309 sps->height - (
sps->output_window.top_offset +
sps->output_window.bottom_offset),
1346 int idx_y,
int idx_cb,
int idx_cr,
int inp_length)
1348 unsigned int split_octant_flag, part_num_y, coded_res_flag, res_coeff_q, res_coeff_r;
1351 part_num_y = 1 <<
pps->cm_y_part_num_log2;
1353 split_octant_flag = inp_depth <
pps->cm_octant_depth ?
get_bits1(gb) : 0;
1355 if (split_octant_flag)
1356 for (
int k = 0; k < 2; k++)
1357 for (
int m = 0; m < 2; m++)
1358 for (
int n = 0; n < 2; n++)
1360 idx_y + part_num_y * k * inp_length / 2,
1361 idx_cb + m * inp_length / 2,
1362 idx_cr + n * inp_length / 2,
1365 for (
int i = 0;
i < part_num_y;
i++) {
1366 for (
int j = 0; j < 4; j++) {
1369 for (
int c = 0;
c < 3;
c++) {
1371 cm_res_bits =
FFMAX(0, 10 +
pps->luma_bit_depth_cm_input -
1372 pps->luma_bit_depth_cm_output -
1373 pps->cm_res_quant_bits -
pps->cm_delta_flc_bits);
1374 res_coeff_r = cm_res_bits ?
get_bits(gb, cm_res_bits) : 0;
1375 if (res_coeff_q || res_coeff_r)
1385 if (
pps->num_cm_ref_layers > 62) {
1387 "num_cm_ref_layers_minus1 shall be in the range [0, 61].\n");
1390 for (
int i = 0;
i <
pps->num_cm_ref_layers;
i++)
1404 if (
pps->cm_octant_depth == 1) {
1419 if (
pps->pps_infer_scaling_list_flag)
1420 pps->pps_scaling_list_ref_layer_id =
get_bits(gb, 6);
1423 if (
pps->num_ref_loc_offsets >
vps->vps_max_layers - 1)
1426 for (
int i = 0;
i <
pps->num_ref_loc_offsets;
i++) {
1428 pps->scaled_ref_layer_offset_present_flag[
i] =
get_bits1(gb);
1429 if (
pps->scaled_ref_layer_offset_present_flag[
i]) {
1437 if (
pps->ref_region_offset_present_flag[
i]) {
1445 if (
pps->resample_phase_set_present_flag[
i]) {
1454 if (
pps->colour_mapping_enabled_flag) {
1465 unsigned int num_val_delta_dlt, max_diff = 0;
1466 int min_diff_minus1 = -1;
1469 num_val_delta_dlt =
get_bits(gb,
pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1470 if (num_val_delta_dlt) {
1471 if (num_val_delta_dlt > 1)
1472 max_diff =
get_bits(gb,
pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1473 if (num_val_delta_dlt > 2 && max_diff) {
1477 if (max_diff > (min_diff_minus1 + 1))
1478 for (
int k = 1; k < num_val_delta_dlt; k++) {
1479 len =
av_log2(max_diff - (min_diff_minus1 + 1)) + 1;
1488 unsigned int pps_depth_layers_minus1;
1491 pps_depth_layers_minus1 =
get_bits(gb, 6);
1492 pps->pps_bit_depth_for_depth_layers_minus8 =
get_bits(gb, 4);
1493 for (
int i = 0;
i <= pps_depth_layers_minus1;
i++) {
1497 for (
int j = 0; j <= ((1 << (
pps->pps_bit_depth_for_depth_layers_minus8 + 8)) - 1); j++)
1512 if (
pps->transform_skip_enabled_flag) {
1515 pps->cross_component_prediction_enabled_flag =
get_bits1(gb);
1516 pps->chroma_qp_offset_list_enabled_flag =
get_bits1(gb);
1517 if (
pps->chroma_qp_offset_list_enabled_flag) {
1520 if (
pps->chroma_qp_offset_list_len_minus1 > 5) {
1522 "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1525 for (
int i = 0;
i <=
pps->chroma_qp_offset_list_len_minus1;
i++) {
1527 if (
pps->cb_qp_offset_list[
i]) {
1529 "cb_qp_offset_list not tested yet.\n");
1532 if (
pps->cr_qp_offset_list[
i]) {
1534 "cb_qp_offset_list not tested yet.\n");
1541 if (
pps->log2_sao_offset_scale_luma >
FFMAX(
sps->bit_depth - 10, 0)
1542 ||
pps->log2_sao_offset_scale_chroma >
FFMAX(
sps->bit_depth_chroma - 10, 0)
1555 if (
pps->residual_adaptive_colour_transform_enabled_flag =
get_bits1(gb)) {
1556 pps->pps_slice_act_qp_offsets_present_flag =
get_bits1(gb);
1561 #define CHECK_QP_OFFSET(name) (pps->pps_act_ ## name ## _qp_offset <= -12 || \
1562 pps->pps_act_ ## name ## _qp_offset >= 12)
1564 #undef CHECK_QP_OFFSET
1567 "PpsActQpOffsetY/Cb/Cr shall be in the range of [-12, 12].\n");
1572 if (
pps->pps_palette_predictor_initializers_present_flag =
get_bits1(gb)) {
1574 if (
pps->pps_num_palette_predictor_initializers > 0) {
1577 "pps_num_palette_predictor_initializers out of range: %u\n",
1578 pps->pps_num_palette_predictor_initializers);
1583 if (
pps->luma_bit_depth_entry !=
sps->bit_depth)
1585 if (!
pps->monochrome_palette_flag) {
1587 if (
pps->chroma_bit_depth_entry !=
sps->bit_depth_chroma)
1591 num_comps =
pps->monochrome_palette_flag ? 1 : 3;
1594 for (
int i = 0;
i <
pps->pps_num_palette_predictor_initializers;
i++)
1607 int pic_area_in_ctbs;
1608 int i, j, x, y, ctb_addr_rs, tile_id;
1614 if (!
pps->col_bd || !
pps->row_bd || !
pps->col_idxX)
1617 if (
pps->uniform_spacing_flag) {
1618 if (!
pps->column_width) {
1622 if (!
pps->column_width || !
pps->row_height)
1625 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
1626 pps->column_width[
i] = ((
i + 1) *
sps->ctb_width) /
pps->num_tile_columns -
1627 (
i *
sps->ctb_width) /
pps->num_tile_columns;
1630 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
1631 pps->row_height[
i] = ((
i + 1) *
sps->ctb_height) /
pps->num_tile_rows -
1632 (
i *
sps->ctb_height) /
pps->num_tile_rows;
1637 for (
i = 0;
i <
pps->num_tile_columns;
i++)
1638 pps->col_bd[
i + 1] =
pps->col_bd[
i] +
pps->column_width[
i];
1641 for (
i = 0;
i <
pps->num_tile_rows;
i++)
1642 pps->row_bd[
i + 1] =
pps->row_bd[
i] +
pps->row_height[
i];
1644 for (
i = 0, j = 0;
i <
sps->ctb_width;
i++) {
1645 if (
i >
pps->col_bd[j])
1647 pps->col_idxX[
i] = j;
1653 pic_area_in_ctbs =
sps->ctb_width *
sps->ctb_height;
1659 if (!
pps->ctb_addr_rs_to_ts || !
pps->ctb_addr_ts_to_rs ||
1660 !
pps->tile_id || !
pps->min_tb_addr_zs_tab) {
1664 for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1665 int tb_x = ctb_addr_rs %
sps->ctb_width;
1666 int tb_y = ctb_addr_rs /
sps->ctb_width;
1671 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
1672 if (tb_x < pps->col_bd[
i + 1]) {
1678 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
1679 if (tb_y < pps->row_bd[
i + 1]) {
1685 for (
i = 0;
i < tile_x;
i++)
1686 val +=
pps->row_height[tile_y] *
pps->column_width[
i];
1687 for (
i = 0;
i < tile_y;
i++)
1690 val += (tb_y -
pps->row_bd[tile_y]) *
pps->column_width[tile_x] +
1691 tb_x -
pps->col_bd[tile_x];
1693 pps->ctb_addr_rs_to_ts[ctb_addr_rs] =
val;
1694 pps->ctb_addr_ts_to_rs[
val] = ctb_addr_rs;
1697 for (j = 0, tile_id = 0; j <
pps->num_tile_rows; j++)
1698 for (
i = 0;
i <
pps->num_tile_columns;
i++, tile_id++)
1699 for (y =
pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1700 for (x =
pps->col_bd[
i]; x < pps->col_bd[
i + 1]; x++)
1701 pps->tile_id[
pps->ctb_addr_rs_to_ts[y *
sps->ctb_width + x]] = tile_id;
1704 if (!
pps->tile_pos_rs)
1707 for (j = 0; j <
pps->num_tile_rows; j++)
1708 for (
i = 0;
i <
pps->num_tile_columns;
i++)
1709 pps->tile_pos_rs[j *
pps->num_tile_columns +
i] =
1710 pps->row_bd[j] *
sps->ctb_width +
pps->col_bd[
i];
1712 log2_diff =
sps->log2_ctb_size -
sps->log2_min_tb_size;
1713 pps->min_tb_addr_zs = &
pps->min_tb_addr_zs_tab[1*(
sps->tb_mask+2)+1];
1714 for (y = 0; y <
sps->tb_mask+2; y++) {
1715 pps->min_tb_addr_zs_tab[y*(
sps->tb_mask+2)] = -1;
1716 pps->min_tb_addr_zs_tab[y] = -1;
1718 for (y = 0; y <
sps->tb_mask+1; y++) {
1719 for (x = 0; x <
sps->tb_mask+1; x++) {
1720 int tb_x = x >> log2_diff;
1721 int tb_y = y >> log2_diff;
1722 int rs =
sps->ctb_width * tb_y + tb_x;
1723 int val =
pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
1724 for (
i = 0;
i < log2_diff;
i++) {
1726 val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1728 pps->min_tb_addr_zs[y * (
sps->tb_mask+2) + x] =
val;
1741 unsigned int pps_id = 0;
1743 unsigned log2_parallel_merge_level_minus2;
1761 if (nal_size >
sizeof(
pps->data)) {
1764 nal_size,
sizeof(
pps->data));
1765 pps->data_size =
sizeof(
pps->data);
1767 pps->data_size = nal_size;
1772 pps->loop_filter_across_tiles_enabled_flag = 1;
1773 pps->num_tile_columns = 1;
1774 pps->num_tile_rows = 1;
1775 pps->uniform_spacing_flag = 1;
1776 pps->disable_dbf = 0;
1777 pps->beta_offset = 0;
1779 pps->log2_max_transform_skip_block_size = 2;
1802 pps->dependent_slice_segments_enabled_flag =
get_bits1(gb);
1804 pps->num_extra_slice_header_bits =
get_bits(gb, 3);
1815 pps->num_ref_idx_l0_default_active,
pps->num_ref_idx_l1_default_active);
1825 pps->diff_cu_qp_delta_depth = 0;
1826 if (
pps->cu_qp_delta_enabled_flag)
1829 if (
pps->diff_cu_qp_delta_depth < 0 ||
1830 pps->diff_cu_qp_delta_depth >
sps->log2_diff_max_min_coding_block_size) {
1832 pps->diff_cu_qp_delta_depth);
1838 if (
pps->cb_qp_offset < -12 ||
pps->cb_qp_offset > 12) {
1845 if (
pps->cr_qp_offset < -12 ||
pps->cr_qp_offset > 12) {
1851 pps->pic_slice_level_chroma_qp_offsets_present_flag =
get_bits1(gb);
1860 if (
pps->tiles_enabled_flag) {
1864 if (num_tile_columns_minus1 < 0 ||
1865 num_tile_columns_minus1 >=
sps->ctb_width) {
1867 num_tile_columns_minus1);
1871 if (num_tile_rows_minus1 < 0 ||
1872 num_tile_rows_minus1 >=
sps->ctb_height) {
1874 num_tile_rows_minus1);
1878 pps->num_tile_columns = num_tile_columns_minus1 + 1;
1879 pps->num_tile_rows = num_tile_rows_minus1 + 1;
1883 if (!
pps->column_width || !
pps->row_height) {
1889 if (!
pps->uniform_spacing_flag) {
1891 for (
i = 0;
i <
pps->num_tile_columns - 1;
i++) {
1893 sum +=
pps->column_width[
i];
1895 if (sum >=
sps->ctb_width) {
1900 pps->column_width[
pps->num_tile_columns - 1] =
sps->ctb_width - sum;
1903 for (
i = 0;
i <
pps->num_tile_rows - 1;
i++) {
1905 sum +=
pps->row_height[
i];
1907 if (sum >=
sps->ctb_height) {
1912 pps->row_height[
pps->num_tile_rows - 1] =
sps->ctb_height - sum;
1914 pps->loop_filter_across_tiles_enabled_flag =
get_bits1(gb);
1917 pps->seq_loop_filter_across_slices_enabled_flag =
get_bits1(gb);
1919 pps->deblocking_filter_control_present_flag =
get_bits1(gb);
1920 if (
pps->deblocking_filter_control_present_flag) {
1921 pps->deblocking_filter_override_enabled_flag =
get_bits1(gb);
1923 if (!
pps->disable_dbf) {
1926 if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
1932 if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1938 pps->beta_offset = 2 * beta_offset_div2;
1939 pps->tc_offset = 2 * tc_offset_div2;
1944 if (
pps->scaling_list_data_present_flag) {
1952 if (log2_parallel_merge_level_minus2 >
sps->log2_ctb_size) {
1954 log2_parallel_merge_level_minus2);
1958 pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
1960 pps->slice_header_extension_present_flag =
get_bits1(gb);
1963 if (
pps->pps_extension_present_flag) {
1975 if (
pps->pps_multilayer_extension_flag) {
1980 if (
pps->pps_3d_extension_flag) {
1985 if (
pps->pps_scc_extension_flag) {
2028 int max_poc_lsb = 1 <<
sps->log2_max_poc_lsb;
2029 int prev_poc_lsb = pocTid0 % max_poc_lsb;
2030 int prev_poc_msb = pocTid0 - prev_poc_lsb;
2033 if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
2034 poc_msb = prev_poc_msb + max_poc_lsb;
2035 else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
2036 poc_msb = prev_poc_msb - max_poc_lsb;
2038 poc_msb = prev_poc_msb;
2046 return poc_msb + poc_lsb;