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)
103 uint8_t rps_predict = 0;
109 if (rps !=
sps->st_rps &&
sps->nb_st_rps)
115 unsigned abs_delta_rps;
116 uint8_t use_delta_flag = 0;
117 uint8_t delta_rps_sign;
119 if (is_slice_header) {
121 if (delta_idx >
sps->nb_st_rps) {
123 "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
124 delta_idx,
sps->nb_st_rps);
127 rps_ridx = &
sps->st_rps[
sps->nb_st_rps - delta_idx];
130 rps_ridx = &
sps->st_rps[rps -
sps->st_rps - 1];
134 if (abs_delta_rps < 1 || abs_delta_rps > 32768) {
136 "Invalid value of abs_delta_rps: %d\n",
140 delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
147 if (used || use_delta_flag) {
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);
360 int subpic_params_present)
364 for (
i = 0;
i < nb_cpb;
i++) {
368 if (subpic_params_present) {
379 int nal_params_present = 0, vcl_params_present = 0;
380 int subpic_params_present = 0;
383 if (common_inf_present) {
387 if (nal_params_present || vcl_params_present) {
390 if (subpic_params_present) {
400 if (subpic_params_present)
409 for (
i = 0;
i < max_sublayers;
i++) {
411 unsigned int nb_cpb = 1;
424 if (nb_cpb < 1 || nb_cpb > 32) {
430 if (nal_params_present)
432 if (vcl_params_present)
454 if (nal_size >
sizeof(
vps->data)) {
457 nal_size,
sizeof(
vps->data));
458 vps->data_size =
sizeof(
vps->data);
460 vps->data_size = nal_size;
482 vps->vps_max_sub_layers);
489 vps->vps_sub_layer_ordering_info_present_flag =
get_bits1(gb);
491 i =
vps->vps_sub_layer_ordering_info_present_flag ? 0 :
vps->vps_max_sub_layers - 1;
492 for (;
i <
vps->vps_max_sub_layers;
i++) {
499 vps->vps_max_dec_pic_buffering[
i] - 1);
502 if (
vps->vps_num_reorder_pics[
i] >
vps->vps_max_dec_pic_buffering[
i] - 1) {
504 vps->vps_num_reorder_pics[
i]);
512 if (
vps->vps_num_layer_sets < 1 ||
vps->vps_num_layer_sets > 1024 ||
518 for (
i = 1;
i <
vps->vps_num_layer_sets;
i++)
519 for (j = 0; j <=
vps->vps_max_layer_id; j++)
523 if (
vps->vps_timing_info_present_flag) {
526 vps->vps_poc_proportional_to_timing_flag =
get_bits1(gb);
527 if (
vps->vps_poc_proportional_to_timing_flag)
530 if (
vps->vps_num_hrd_parameters > (
unsigned)
vps->vps_num_layer_sets) {
532 "vps_num_hrd_parameters %d is invalid\n",
vps->vps_num_hrd_parameters);
535 for (
i = 0;
i <
vps->vps_num_hrd_parameters;
i++) {
536 int common_inf_present = 1;
571 VUI backup_vui, *vui = &
sps->vui;
582 switch (
sps->pix_fmt) {
602 memcpy(&backup, gb,
sizeof(backup));
603 memcpy(&backup_vui, vui,
sizeof(backup_vui));
618 if (apply_defdispwin &&
621 "discarding vui default display window, "
622 "original values are l:%u r:%u t:%u b:%u\n",
643 "Strange VUI timing information, retrying...\n");
644 memcpy(vui, &backup_vui,
sizeof(backup_vui));
645 memcpy(gb, &backup,
sizeof(backup));
667 "Strange VUI bitstream restriction information, retrying"
668 " from timing information...\n");
669 memcpy(vui, &backup_vui,
sizeof(backup_vui));
670 memcpy(gb, &backup,
sizeof(backup));
687 "Overread in VUI, retrying from timing information...\n");
688 memcpy(vui, &backup_vui,
sizeof(backup_vui));
689 memcpy(gb, &backup,
sizeof(backup));
699 for (matrixId = 0; matrixId < 6; matrixId++) {
701 memset(sl->
sl[0][matrixId], 16, 16);
702 sl->
sl_dc[0][matrixId] = 16;
703 sl->
sl_dc[1][matrixId] = 16;
727 uint8_t scaling_list_pred_mode_flag;
728 uint8_t scaling_list_dc_coef[2][6];
729 int size_id, matrix_id,
pos;
732 for (size_id = 0; size_id < 4; size_id++)
733 for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
734 scaling_list_pred_mode_flag =
get_bits1(gb);
735 if (!scaling_list_pred_mode_flag) {
741 delta *= (size_id == 3) ? 3 : 1;
742 if (matrix_id <
delta) {
744 "Invalid delta in scaling list data: %d.\n",
delta);
748 memcpy(sl->
sl[size_id][matrix_id],
749 sl->
sl[size_id][matrix_id -
delta],
750 size_id > 0 ? 64 : 16);
752 sl->
sl_dc[size_id - 2][matrix_id] = sl->
sl_dc[size_id - 2][matrix_id -
delta];
755 int next_coef, coef_num;
756 int32_t scaling_list_delta_coef;
759 coef_num =
FFMIN(64, 1 << (4 + (size_id << 1)));
762 if (scaling_list_coeff_minus8 < -7 ||
763 scaling_list_coeff_minus8 > 247)
765 scaling_list_dc_coef[size_id - 2][matrix_id] = scaling_list_coeff_minus8 + 8;
766 next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
767 sl->
sl_dc[size_id - 2][matrix_id] = next_coef;
769 for (
i = 0;
i < coef_num;
i++) {
778 next_coef = (next_coef + 256
U + scaling_list_delta_coef) % 256;
779 sl->
sl[size_id][matrix_id][
pos] = next_coef;
784 if (
sps->chroma_format_idc == 3) {
785 for (
i = 0;
i < 64;
i++) {
786 sl->
sl[3][1][
i] = sl->
sl[2][1][
i];
787 sl->
sl[3][2][
i] = sl->
sl[2][2][
i];
788 sl->
sl[3][4][
i] = sl->
sl[2][4][
i];
789 sl->
sl[3][5][
i] = sl->
sl[2][5][
i];
804 switch (
sps->bit_depth) {
831 "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
832 "chroma_format_idc is %d, depth is %d\n",
833 sps->chroma_format_idc,
sps->bit_depth);
841 sps->hshift[0] =
sps->vshift[0] = 0;
842 sps->hshift[2] =
sps->hshift[1] =
desc->log2_chroma_w;
843 sps->vshift[2] =
sps->vshift[1] =
desc->log2_chroma_h;
845 sps->pixel_shift =
sps->bit_depth > 8;
855 int log2_diff_max_min_transform_block_size;
856 int bit_depth_chroma, start, vui_present, sublayer_ordering_info, num_comps;
863 if (vps_list && !vps_list[
sps->vps_id]) {
872 sps->max_sub_layers);
888 if (
sps->chroma_format_idc > 3
U) {
893 if (
sps->chroma_format_idc == 3)
896 if (
sps->separate_colour_plane_flag)
897 sps->chroma_format_idc = 0;
902 sps->height, 0, avctx)) < 0)
915 "discarding sps conformance window, "
916 "original values are l:%u r:%u t:%u b:%u\n",
917 sps->pic_conf_win.left_offset,
918 sps->pic_conf_win.right_offset,
919 sps->pic_conf_win.top_offset,
920 sps->pic_conf_win.bottom_offset);
922 sps->pic_conf_win.left_offset =
923 sps->pic_conf_win.right_offset =
924 sps->pic_conf_win.top_offset =
925 sps->pic_conf_win.bottom_offset = 0;
927 sps->output_window =
sps->pic_conf_win;
932 if (
sps->chroma_format_idc && bit_depth_chroma !=
sps->bit_depth) {
934 "Luma bit depth (%d) is different from chroma bit depth (%d), "
935 "this is unsupported.\n",
936 sps->bit_depth, bit_depth_chroma);
939 sps->bit_depth_chroma = bit_depth_chroma;
946 if (
sps->log2_max_poc_lsb > 16) {
948 sps->log2_max_poc_lsb - 4);
953 start = sublayer_ordering_info ? 0 :
sps->max_sub_layers - 1;
954 for (
i = start;
i <
sps->max_sub_layers;
i++) {
960 sps->temporal_layer[
i].max_dec_pic_buffering - 1
U);
963 if (
sps->temporal_layer[
i].num_reorder_pics >
sps->temporal_layer[
i].max_dec_pic_buffering - 1) {
965 sps->temporal_layer[
i].num_reorder_pics);
970 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[
i].num_reorder_pics + 1;
974 if (!sublayer_ordering_info) {
975 for (
i = 0;
i < start;
i++) {
976 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[start].max_dec_pic_buffering;
977 sps->temporal_layer[
i].num_reorder_pics =
sps->temporal_layer[start].num_reorder_pics;
978 sps->temporal_layer[
i].max_latency_increase =
sps->temporal_layer[start].max_latency_increase;
986 sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
987 sps->log2_min_tb_size;
989 if (
sps->log2_min_cb_size < 3 ||
sps->log2_min_cb_size > 30) {
994 if (
sps->log2_diff_max_min_coding_block_size > 30) {
995 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);
999 if (
sps->log2_min_tb_size >=
sps->log2_min_cb_size ||
sps->log2_min_tb_size < 2) {
1004 if (log2_diff_max_min_transform_block_size < 0 || log2_diff_max_min_transform_block_size > 30) {
1005 av_log(avctx,
AV_LOG_ERROR,
"Invalid value %d for log2_diff_max_min_transform_block_size", log2_diff_max_min_transform_block_size);
1013 if (
sps->scaling_list_enable_flag) {
1027 if (
sps->pcm_enabled_flag) {
1031 sps->pcm.log2_max_pcm_cb_size =
sps->pcm.log2_min_pcm_cb_size +
1033 if (
FFMAX(
sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma) >
sps->bit_depth) {
1035 "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1036 sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma,
sps->bit_depth);
1049 for (
i = 0;
i <
sps->nb_st_rps;
i++) {
1056 if (
sps->long_term_ref_pics_present_flag) {
1060 sps->num_long_term_ref_pics_sps);
1063 for (
i = 0;
i <
sps->num_long_term_ref_pics_sps;
i++) {
1070 sps->sps_strong_intra_smoothing_enable_flag =
get_bits1(gb);
1083 if (
sps->sps_range_extension_flag) {
1084 sps->transform_skip_rotation_enabled_flag =
get_bits1(gb);
1085 sps->transform_skip_context_enabled_flag =
get_bits1(gb);
1090 sps->extended_precision_processing_flag =
get_bits1(gb);
1091 if (
sps->extended_precision_processing_flag)
1093 "extended_precision_processing_flag not yet implemented\n");
1096 sps->high_precision_offsets_enabled_flag =
get_bits1(gb);
1097 if (
sps->high_precision_offsets_enabled_flag)
1099 "high_precision_offsets_enabled_flag not yet implemented\n");
1101 sps->persistent_rice_adaptation_enabled_flag =
get_bits1(gb);
1103 sps->cabac_bypass_alignment_enabled_flag =
get_bits1(gb);
1104 if (
sps->cabac_bypass_alignment_enabled_flag)
1106 "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1109 if (
sps->sps_multilayer_extension_flag) {
1112 "sps_multilayer_extension_flag not yet implemented\n");
1115 if (
sps->sps_3d_extension_flag) {
1116 for (
i = 0;
i <= 1;
i++) {
1136 "sps_3d_extension_flag not yet implemented\n");
1139 if (
sps->sps_scc_extension_flag) {
1142 if (
sps->palette_mode_enabled_flag) {
1145 sps->sps_palette_predictor_initializers_present_flag =
get_bits1(gb);
1147 if (
sps->sps_palette_predictor_initializers_present_flag) {
1149 num_comps = !
sps->chroma_format_idc ? 1 : 3;
1151 for (
i = 0;
i <=
sps->sps_num_palette_predictor_initializers_minus1;
i++)
1152 sps->sps_palette_predictor_initializer[
comp][
i] =
1156 sps->motion_vector_resolution_control_idc =
get_bits(gb, 2);
1157 sps->intra_boundary_filtering_disabled_flag =
get_bits1(gb);
1160 if (apply_defdispwin) {
1161 sps->output_window.left_offset +=
sps->vui.def_disp_win.left_offset;
1162 sps->output_window.right_offset +=
sps->vui.def_disp_win.right_offset;
1163 sps->output_window.top_offset +=
sps->vui.def_disp_win.top_offset;
1164 sps->output_window.bottom_offset +=
sps->vui.def_disp_win.bottom_offset;
1167 ow = &
sps->output_window;
1178 "Displaying the whole video surface.\n");
1179 memset(ow, 0,
sizeof(*ow));
1180 memset(&
sps->pic_conf_win, 0,
sizeof(
sps->pic_conf_win));
1184 sps->log2_ctb_size =
sps->log2_min_cb_size +
1185 sps->log2_diff_max_min_coding_block_size;
1186 sps->log2_min_pu_size =
sps->log2_min_cb_size - 1;
1192 if (
sps->log2_ctb_size < 4) {
1195 "log2_ctb_size %d differs from the bounds of any known profile\n",
1196 sps->log2_ctb_size);
1201 sps->ctb_width = (
sps->width + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1202 sps->ctb_height = (
sps->height + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1203 sps->ctb_size =
sps->ctb_width *
sps->ctb_height;
1205 sps->min_cb_width =
sps->width >>
sps->log2_min_cb_size;
1206 sps->min_cb_height =
sps->height >>
sps->log2_min_cb_size;
1207 sps->min_tb_width =
sps->width >>
sps->log2_min_tb_size;
1208 sps->min_tb_height =
sps->height >>
sps->log2_min_tb_size;
1209 sps->min_pu_width =
sps->width >>
sps->log2_min_pu_size;
1210 sps->min_pu_height =
sps->height >>
sps->log2_min_pu_size;
1211 sps->tb_mask = (1 << (
sps->log2_ctb_size -
sps->log2_min_tb_size)) - 1;
1213 sps->qp_bd_offset = 6 * (
sps->bit_depth - 8);
1221 if (
sps->max_transform_hierarchy_depth_inter >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1222 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_inter out of range: %d\n",
1223 sps->max_transform_hierarchy_depth_inter);
1226 if (
sps->max_transform_hierarchy_depth_intra >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1227 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_intra out of range: %d\n",
1228 sps->max_transform_hierarchy_depth_intra);
1231 if (
sps->log2_max_trafo_size >
FFMIN(
sps->log2_ctb_size, 5)) {
1233 "max transform block size out of range: %d\n",
1234 sps->log2_max_trafo_size);
1252 unsigned int sps_id;
1263 if (nal_size >
sizeof(
sps->data)) {
1266 nal_size,
sizeof(
sps->data));
1267 sps->data_size =
sizeof(
sps->data);
1269 sps->data_size = nal_size;
1283 "Parsed SPS: id %d; coded wxh: %dx%d; "
1284 "cropped wxh: %dx%d; pix_fmt: %s.\n",
1285 sps_id,
sps->width,
sps->height,
1286 sps->width - (
sps->output_window.left_offset +
sps->output_window.right_offset),
1287 sps->height - (
sps->output_window.top_offset +
sps->output_window.bottom_offset),
1324 int idx_y,
int idx_cb,
int idx_cr,
int inp_length)
1326 unsigned int split_octant_flag, part_num_y, coded_res_flag, res_coeff_q, res_coeff_r;
1327 int bit_depth_cm_input_y, bit_depth_cm_output_y, cm_res_bits;
1329 part_num_y = 1 <<
pps->cm_y_part_num_log2;
1331 split_octant_flag = inp_depth <
pps->cm_octant_depth ?
get_bits1(gb) : 0;
1333 if (split_octant_flag)
1334 for (
int k = 0; k < 2; k++)
1335 for (
int m = 0; m < 2; m++)
1336 for (
int n = 0; n < 2; n++)
1338 idx_y + part_num_y * k * inp_length / 2,
1339 idx_cb + m * inp_length / 2,
1340 idx_cr + n * inp_length / 2,
1343 for (
int i = 0;
i < part_num_y;
i++) {
1344 for (
int j = 0; j < 4; j++) {
1347 for (
int c = 0;
c < 3;
c++) {
1349 bit_depth_cm_input_y = 8 +
pps->luma_bit_depth_cm_input_minus8;
1350 bit_depth_cm_output_y = 8 +
pps->luma_bit_depth_cm_output_minus8;
1351 cm_res_bits =
FFMAX(0, 10 + bit_depth_cm_input_y - bit_depth_cm_output_y -
1352 pps->cm_res_quant_bits - (
pps->cm_delta_flc_bits_minus1 + 1));
1353 res_coeff_r = cm_res_bits ?
get_bits(gb, cm_res_bits) : 0;
1354 if (res_coeff_q || res_coeff_r)
1364 for (
int i = 0;
i <=
pps->num_cm_ref_layers_minus1;
i++)
1378 if (
pps->cm_octant_depth == 1) {
1391 if (
pps->pps_infer_scaling_list_flag)
1392 pps->pps_scaling_list_ref_layer_id =
get_bits(gb, 6);
1395 for (
int i = 0;
i <
pps->num_ref_loc_offsets;
i++) {
1397 pps->scaled_ref_layer_offset_present_flag[
i] =
get_bits1(gb);
1398 if (
pps->scaled_ref_layer_offset_present_flag[
i]) {
1406 if (
pps->ref_region_offset_present_flag[
i]) {
1414 if (
pps->resample_phase_set_present_flag[
i]) {
1423 if (
pps->colour_mapping_enabled_flag)
1431 unsigned int num_val_delta_dlt, max_diff = 0;
1432 int min_diff_minus1 = -1;
1435 num_val_delta_dlt =
get_bits(gb,
pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1436 if (num_val_delta_dlt) {
1437 if (num_val_delta_dlt > 1)
1438 max_diff =
get_bits(gb,
pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1439 if (num_val_delta_dlt > 2 && max_diff) {
1443 if (max_diff > (min_diff_minus1 + 1))
1444 for (
int k = 1; k < num_val_delta_dlt; k++) {
1445 len =
av_log2(max_diff - (min_diff_minus1 + 1)) + 1;
1454 unsigned int pps_depth_layers_minus1;
1457 pps_depth_layers_minus1 =
get_bits(gb, 6);
1458 pps->pps_bit_depth_for_depth_layers_minus8 =
get_bits(gb, 4);
1459 for (
int i = 0;
i <= pps_depth_layers_minus1;
i++) {
1463 for (
int j = 0; j <= ((1 << (
pps->pps_bit_depth_for_depth_layers_minus8 + 8)) - 1); j++)
1478 if (
pps->transform_skip_enabled_flag) {
1481 pps->cross_component_prediction_enabled_flag =
get_bits1(gb);
1482 pps->chroma_qp_offset_list_enabled_flag =
get_bits1(gb);
1483 if (
pps->chroma_qp_offset_list_enabled_flag) {
1486 if (
pps->chroma_qp_offset_list_len_minus1 > 5) {
1488 "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1491 for (
int i = 0;
i <=
pps->chroma_qp_offset_list_len_minus1;
i++) {
1493 if (
pps->cb_qp_offset_list[
i]) {
1495 "cb_qp_offset_list not tested yet.\n");
1498 if (
pps->cr_qp_offset_list[
i]) {
1500 "cb_qp_offset_list not tested yet.\n");
1507 if (
pps->log2_sao_offset_scale_luma >
FFMAX(
sps->bit_depth - 10, 0)
1508 ||
pps->log2_sao_offset_scale_chroma >
FFMAX(
sps->bit_depth_chroma - 10, 0)
1521 if (
pps->residual_adaptive_colour_transform_enabled_flag =
get_bits1(gb)) {
1522 pps->pps_slice_act_qp_offsets_present_flag =
get_bits1(gb);
1527 #define CHECK_QP_OFFSET(name) (pps->pps_act_ ## name ## _qp_offset <= -12 || \
1528 pps->pps_act_ ## name ## _qp_offset >= 12)
1530 #undef CHECK_QP_OFFSET
1533 "PpsActQpOffsetY/Cb/Cr shall be in the range of [-12, 12].\n");
1538 if (
pps->pps_palette_predictor_initializers_present_flag =
get_bits1(gb)) {
1542 if (!
pps->monochrome_palette_flag)
1544 num_comps =
pps->monochrome_palette_flag ? 1 : 3;
1546 for (
int i = 0;
i <
pps->pps_num_palette_predictor_initializers;
i++)
1547 pps->pps_palette_predictor_initializer[
comp][
i] =
1549 pps->chroma_bit_depth_entry_minus8));
1560 int pic_area_in_ctbs;
1561 int i, j, x, y, ctb_addr_rs, tile_id;
1567 if (!
pps->col_bd || !
pps->row_bd || !
pps->col_idxX)
1570 if (
pps->uniform_spacing_flag) {
1571 if (!
pps->column_width) {
1575 if (!
pps->column_width || !
pps->row_height)
1578 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
1579 pps->column_width[
i] = ((
i + 1) *
sps->ctb_width) /
pps->num_tile_columns -
1580 (
i *
sps->ctb_width) /
pps->num_tile_columns;
1583 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
1584 pps->row_height[
i] = ((
i + 1) *
sps->ctb_height) /
pps->num_tile_rows -
1585 (
i *
sps->ctb_height) /
pps->num_tile_rows;
1590 for (
i = 0;
i <
pps->num_tile_columns;
i++)
1591 pps->col_bd[
i + 1] =
pps->col_bd[
i] +
pps->column_width[
i];
1594 for (
i = 0;
i <
pps->num_tile_rows;
i++)
1595 pps->row_bd[
i + 1] =
pps->row_bd[
i] +
pps->row_height[
i];
1597 for (
i = 0, j = 0;
i <
sps->ctb_width;
i++) {
1598 if (
i >
pps->col_bd[j])
1600 pps->col_idxX[
i] = j;
1606 pic_area_in_ctbs =
sps->ctb_width *
sps->ctb_height;
1612 if (!
pps->ctb_addr_rs_to_ts || !
pps->ctb_addr_ts_to_rs ||
1613 !
pps->tile_id || !
pps->min_tb_addr_zs_tab) {
1617 for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1618 int tb_x = ctb_addr_rs %
sps->ctb_width;
1619 int tb_y = ctb_addr_rs /
sps->ctb_width;
1624 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
1625 if (tb_x < pps->col_bd[
i + 1]) {
1631 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
1632 if (tb_y < pps->row_bd[
i + 1]) {
1638 for (
i = 0;
i < tile_x;
i++)
1639 val +=
pps->row_height[tile_y] *
pps->column_width[
i];
1640 for (
i = 0;
i < tile_y;
i++)
1643 val += (tb_y -
pps->row_bd[tile_y]) *
pps->column_width[tile_x] +
1644 tb_x -
pps->col_bd[tile_x];
1646 pps->ctb_addr_rs_to_ts[ctb_addr_rs] =
val;
1647 pps->ctb_addr_ts_to_rs[
val] = ctb_addr_rs;
1650 for (j = 0, tile_id = 0; j <
pps->num_tile_rows; j++)
1651 for (
i = 0;
i <
pps->num_tile_columns;
i++, tile_id++)
1652 for (y =
pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1653 for (x =
pps->col_bd[
i]; x < pps->col_bd[
i + 1]; x++)
1654 pps->tile_id[
pps->ctb_addr_rs_to_ts[y *
sps->ctb_width + x]] = tile_id;
1657 if (!
pps->tile_pos_rs)
1660 for (j = 0; j <
pps->num_tile_rows; j++)
1661 for (
i = 0;
i <
pps->num_tile_columns;
i++)
1662 pps->tile_pos_rs[j *
pps->num_tile_columns +
i] =
1663 pps->row_bd[j] *
sps->ctb_width +
pps->col_bd[
i];
1665 log2_diff =
sps->log2_ctb_size -
sps->log2_min_tb_size;
1666 pps->min_tb_addr_zs = &
pps->min_tb_addr_zs_tab[1*(
sps->tb_mask+2)+1];
1667 for (y = 0; y <
sps->tb_mask+2; y++) {
1668 pps->min_tb_addr_zs_tab[y*(
sps->tb_mask+2)] = -1;
1669 pps->min_tb_addr_zs_tab[y] = -1;
1671 for (y = 0; y <
sps->tb_mask+1; y++) {
1672 for (x = 0; x <
sps->tb_mask+1; x++) {
1673 int tb_x = x >> log2_diff;
1674 int tb_y = y >> log2_diff;
1675 int rs =
sps->ctb_width * tb_y + tb_x;
1676 int val =
pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
1677 for (
i = 0;
i < log2_diff;
i++) {
1679 val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1681 pps->min_tb_addr_zs[y * (
sps->tb_mask+2) + x] =
val;
1693 unsigned int pps_id = 0;
1695 unsigned log2_parallel_merge_level_minus2;
1713 if (nal_size >
sizeof(
pps->data)) {
1716 nal_size,
sizeof(
pps->data));
1717 pps->data_size =
sizeof(
pps->data);
1719 pps->data_size = nal_size;
1724 pps->loop_filter_across_tiles_enabled_flag = 1;
1725 pps->num_tile_columns = 1;
1726 pps->num_tile_rows = 1;
1727 pps->uniform_spacing_flag = 1;
1728 pps->disable_dbf = 0;
1729 pps->beta_offset = 0;
1731 pps->log2_max_transform_skip_block_size = 2;
1753 pps->dependent_slice_segments_enabled_flag =
get_bits1(gb);
1755 pps->num_extra_slice_header_bits =
get_bits(gb, 3);
1770 pps->diff_cu_qp_delta_depth = 0;
1771 if (
pps->cu_qp_delta_enabled_flag)
1774 if (
pps->diff_cu_qp_delta_depth < 0 ||
1775 pps->diff_cu_qp_delta_depth >
sps->log2_diff_max_min_coding_block_size) {
1777 pps->diff_cu_qp_delta_depth);
1783 if (
pps->cb_qp_offset < -12 ||
pps->cb_qp_offset > 12) {
1790 if (
pps->cr_qp_offset < -12 ||
pps->cr_qp_offset > 12) {
1796 pps->pic_slice_level_chroma_qp_offsets_present_flag =
get_bits1(gb);
1805 if (
pps->tiles_enabled_flag) {
1809 if (num_tile_columns_minus1 < 0 ||
1810 num_tile_columns_minus1 >=
sps->ctb_width) {
1812 num_tile_columns_minus1);
1816 if (num_tile_rows_minus1 < 0 ||
1817 num_tile_rows_minus1 >=
sps->ctb_height) {
1819 num_tile_rows_minus1);
1823 pps->num_tile_columns = num_tile_columns_minus1 + 1;
1824 pps->num_tile_rows = num_tile_rows_minus1 + 1;
1828 if (!
pps->column_width || !
pps->row_height) {
1834 if (!
pps->uniform_spacing_flag) {
1836 for (
i = 0;
i <
pps->num_tile_columns - 1;
i++) {
1838 sum +=
pps->column_width[
i];
1840 if (sum >=
sps->ctb_width) {
1845 pps->column_width[
pps->num_tile_columns - 1] =
sps->ctb_width - sum;
1848 for (
i = 0;
i <
pps->num_tile_rows - 1;
i++) {
1850 sum +=
pps->row_height[
i];
1852 if (sum >=
sps->ctb_height) {
1857 pps->row_height[
pps->num_tile_rows - 1] =
sps->ctb_height - sum;
1859 pps->loop_filter_across_tiles_enabled_flag =
get_bits1(gb);
1862 pps->seq_loop_filter_across_slices_enabled_flag =
get_bits1(gb);
1864 pps->deblocking_filter_control_present_flag =
get_bits1(gb);
1865 if (
pps->deblocking_filter_control_present_flag) {
1866 pps->deblocking_filter_override_enabled_flag =
get_bits1(gb);
1868 if (!
pps->disable_dbf) {
1871 if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
1877 if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1883 pps->beta_offset = 2 * beta_offset_div2;
1884 pps->tc_offset = 2 * tc_offset_div2;
1889 if (
pps->scaling_list_data_present_flag) {
1897 if (log2_parallel_merge_level_minus2 >
sps->log2_ctb_size) {
1899 log2_parallel_merge_level_minus2);
1903 pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
1905 pps->slice_header_extension_present_flag =
get_bits1(gb);
1919 if (
pps->pps_multilayer_extension_flag) {
1924 if (
pps->pps_3d_extension_flag) {
1929 if (
pps->pps_scc_extension_flag) {
1972 int max_poc_lsb = 1 <<
sps->log2_max_poc_lsb;
1973 int prev_poc_lsb = pocTid0 % max_poc_lsb;
1974 int prev_poc_msb = pocTid0 - prev_poc_lsb;
1977 if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
1978 poc_msb = prev_poc_msb + max_poc_lsb;
1979 else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
1980 poc_msb = prev_poc_msb - max_poc_lsb;
1982 poc_msb = prev_poc_msb;
1990 return poc_msb + poc_lsb;