32 16, 16, 16, 16, 17, 18, 21, 24,
33 16, 16, 16, 16, 17, 19, 22, 25,
34 16, 16, 17, 18, 20, 22, 25, 29,
35 16, 16, 18, 21, 24, 27, 31, 36,
36 17, 17, 20, 24, 30, 35, 41, 47,
37 18, 19, 22, 27, 35, 44, 54, 65,
38 21, 22, 25, 31, 41, 54, 70, 88,
39 24, 25, 29, 36, 47, 65, 88, 115
43 16, 16, 16, 16, 17, 18, 20, 24,
44 16, 16, 16, 17, 18, 20, 24, 25,
45 16, 16, 17, 18, 20, 24, 25, 28,
46 16, 17, 18, 20, 24, 25, 28, 33,
47 17, 18, 20, 24, 25, 28, 33, 41,
48 18, 20, 24, 25, 28, 33, 41, 54,
49 20, 24, 25, 28, 33, 41, 54, 71,
50 24, 25, 28, 33, 41, 54, 71, 91
83 if (
s->pps_list[
id] &&
s->pps == (
const HEVCPPS*)
s->pps_list[
id]->data)
91 if (
s->sps_list[
id]) {
92 if (
s->sps == (
const HEVCSPS*)
s->sps_list[
id]->data)
97 if (
s->pps_list[
i] && ((
HEVCPPS*)
s->pps_list[
i]->data)->sps_id ==
id)
108 if (
s->vps_list[
id]) {
109 if (
s->vps == (
const HEVCVPS*)
s->vps_list[
id]->data)
113 if (
s->sps_list[
i] && ((
HEVCSPS*)
s->sps_list[
i]->data)->vps_id ==
id)
129 if (rps !=
sps->st_rps &&
sps->nb_st_rps)
135 unsigned abs_delta_rps;
139 if (is_slice_header) {
141 if (delta_idx >
sps->nb_st_rps) {
143 "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
144 delta_idx,
sps->nb_st_rps);
147 rps_ridx = &
sps->st_rps[
sps->nb_st_rps - delta_idx];
150 rps_ridx = &
sps->st_rps[rps -
sps->st_rps - 1];
154 if (abs_delta_rps < 1 || abs_delta_rps > 32768) {
156 "Invalid value of abs_delta_rps: %d\n",
160 delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
167 if (
used || use_delta_flag) {
168 if (i < rps_ridx->num_delta_pocs)
169 delta_poc = delta_rps + rps_ridx->
delta_poc[
i];
171 delta_poc = delta_rps;
183 "Invalid num_delta_pocs: %d\n", k);
195 for (k =
i - 1; k >= 0; k--) {
197 if (delta_poc <
tmp) {
221 unsigned int prev, nb_positive_pics;
236 if (delta_poc < 1 || delta_poc > 32768) {
238 "Invalid value of delta_poc: %d\n",
247 for (
i = 0;
i < nb_positive_pics;
i++) {
249 if (delta_poc < 1 || delta_poc > 32768) {
251 "Invalid value of delta_poc: %d\n",
287 for (
i = 0;
i < 32;
i++) {
290 if (
ptl->profile_idc == 0 &&
i > 0 &&
ptl->profile_compatibility_flag[
i])
291 ptl->profile_idc =
i;
298 #define check_profile_idc(idc) \
299 ptl->profile_idc == idc || ptl->profile_compatibility_flag[idc]
334 #undef check_profile_idc
340 PTL *
ptl,
int max_num_sub_layers)
344 get_bits_left(gb) < 8 + (8*2 * (max_num_sub_layers - 1 > 0))) {
351 for (
i = 0;
i < max_num_sub_layers - 1;
i++) {
356 if (max_num_sub_layers - 1> 0)
357 for (
i = max_num_sub_layers - 1;
i < 8;
i++)
359 for (
i = 0;
i < max_num_sub_layers - 1;
i++) {
363 "PTL information for sublayer %i too short\n",
i);
369 "Not enough data for sublayer %i level_idc\n",
i);
380 int subpic_params_present)
384 for (
i = 0;
i < nb_cpb;
i++) {
388 if (subpic_params_present) {
399 int nal_params_present = 0, vcl_params_present = 0;
400 int subpic_params_present = 0;
403 if (common_inf_present) {
407 if (nal_params_present || vcl_params_present) {
410 if (subpic_params_present) {
420 if (subpic_params_present)
429 for (
i = 0;
i < max_sublayers;
i++) {
431 unsigned int nb_cpb = 1;
444 if (nb_cpb < 1 || nb_cpb > 32) {
450 if (nal_params_present)
452 if (vcl_params_present)
474 if (nal_size >
sizeof(
vps->data)) {
477 nal_size,
sizeof(
vps->data));
478 vps->data_size =
sizeof(
vps->data);
480 vps->data_size = nal_size;
502 vps->vps_max_sub_layers);
509 vps->vps_sub_layer_ordering_info_present_flag =
get_bits1(gb);
511 i =
vps->vps_sub_layer_ordering_info_present_flag ? 0 :
vps->vps_max_sub_layers - 1;
512 for (;
i <
vps->vps_max_sub_layers;
i++) {
519 vps->vps_max_dec_pic_buffering[
i] - 1);
522 if (
vps->vps_num_reorder_pics[
i] >
vps->vps_max_dec_pic_buffering[
i] - 1) {
524 vps->vps_num_reorder_pics[
i]);
532 if (
vps->vps_num_layer_sets < 1 ||
vps->vps_num_layer_sets > 1024 ||
538 for (
i = 1;
i <
vps->vps_num_layer_sets;
i++)
539 for (j = 0; j <=
vps->vps_max_layer_id; j++)
543 if (
vps->vps_timing_info_present_flag) {
546 vps->vps_poc_proportional_to_timing_flag =
get_bits1(gb);
547 if (
vps->vps_poc_proportional_to_timing_flag)
550 if (
vps->vps_num_hrd_parameters > (
unsigned)
vps->vps_num_layer_sets) {
552 "vps_num_hrd_parameters %d is invalid\n",
vps->vps_num_hrd_parameters);
555 for (
i = 0;
i <
vps->vps_num_hrd_parameters;
i++) {
556 int common_inf_present = 1;
591 VUI backup_vui, *vui = &
sps->vui;
593 int sar_present, alt = 0;
602 else if (sar_idx == 255) {
607 "Unknown SAR index: %u.\n", sar_idx);
634 switch (
sps->pix_fmt) {
660 memcpy(&backup, gb,
sizeof(backup));
661 memcpy(&backup_vui, vui,
sizeof(backup_vui));
676 if (apply_defdispwin &&
679 "discarding vui default display window, "
680 "original values are l:%u r:%u t:%u b:%u\n",
701 "Strange VUI timing information, retrying...\n");
702 memcpy(vui, &backup_vui,
sizeof(backup_vui));
703 memcpy(gb, &backup,
sizeof(backup));
725 "Strange VUI bitstream restriction information, retrying"
726 " from timing information...\n");
727 memcpy(vui, &backup_vui,
sizeof(backup_vui));
728 memcpy(gb, &backup,
sizeof(backup));
745 "Overread in VUI, retrying from timing information...\n");
746 memcpy(vui, &backup_vui,
sizeof(backup_vui));
747 memcpy(gb, &backup,
sizeof(backup));
757 for (matrixId = 0; matrixId < 6; matrixId++) {
759 memset(sl->
sl[0][matrixId], 16, 16);
760 sl->
sl_dc[0][matrixId] = 16;
761 sl->
sl_dc[1][matrixId] = 16;
785 uint8_t scaling_list_pred_mode_flag;
786 int32_t scaling_list_dc_coef[2][6];
787 int size_id, matrix_id,
pos;
790 for (size_id = 0; size_id < 4; size_id++)
791 for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
792 scaling_list_pred_mode_flag =
get_bits1(gb);
793 if (!scaling_list_pred_mode_flag) {
799 delta *= (size_id == 3) ? 3 : 1;
800 if (matrix_id <
delta) {
802 "Invalid delta in scaling list data: %d.\n",
delta);
806 memcpy(sl->
sl[size_id][matrix_id],
807 sl->
sl[size_id][matrix_id -
delta],
808 size_id > 0 ? 64 : 16);
810 sl->
sl_dc[size_id - 2][matrix_id] = sl->
sl_dc[size_id - 2][matrix_id -
delta];
813 int next_coef, coef_num;
814 int32_t scaling_list_delta_coef;
817 coef_num =
FFMIN(64, 1 << (4 + (size_id << 1)));
819 scaling_list_dc_coef[size_id - 2][matrix_id] =
get_se_golomb(gb) + 8;
820 next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
821 sl->
sl_dc[size_id - 2][matrix_id] = next_coef;
823 for (
i = 0;
i < coef_num;
i++) {
832 next_coef = (next_coef + 256
U + scaling_list_delta_coef) % 256;
833 sl->
sl[size_id][matrix_id][
pos] = next_coef;
838 if (
sps->chroma_format_idc == 3) {
839 for (
i = 0;
i < 64;
i++) {
840 sl->
sl[3][1][
i] = sl->
sl[2][1][
i];
841 sl->
sl[3][2][
i] = sl->
sl[2][2][
i];
842 sl->
sl[3][4][
i] = sl->
sl[2][4][
i];
843 sl->
sl[3][5][
i] = sl->
sl[2][5][
i];
858 switch (
sps->bit_depth) {
885 "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
886 "chroma_format_idc is %d, depth is %d\n",
887 sps->chroma_format_idc,
sps->bit_depth);
895 sps->hshift[0] =
sps->vshift[0] = 0;
896 sps->hshift[2] =
sps->hshift[1] =
desc->log2_chroma_w;
897 sps->vshift[2] =
sps->vshift[1] =
desc->log2_chroma_h;
899 sps->pixel_shift =
sps->bit_depth > 8;
909 int log2_diff_max_min_transform_block_size;
910 int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
917 if (vps_list && !vps_list[
sps->vps_id]) {
926 sps->max_sub_layers);
942 if (
sps->chroma_format_idc > 3
U) {
947 if (
sps->chroma_format_idc == 3)
950 if (
sps->separate_colour_plane_flag)
951 sps->chroma_format_idc = 0;
956 sps->height, 0, avctx)) < 0)
969 "discarding sps conformance window, "
970 "original values are l:%u r:%u t:%u b:%u\n",
971 sps->pic_conf_win.left_offset,
972 sps->pic_conf_win.right_offset,
973 sps->pic_conf_win.top_offset,
974 sps->pic_conf_win.bottom_offset);
976 sps->pic_conf_win.left_offset =
977 sps->pic_conf_win.right_offset =
978 sps->pic_conf_win.top_offset =
979 sps->pic_conf_win.bottom_offset = 0;
981 sps->output_window =
sps->pic_conf_win;
986 if (
sps->chroma_format_idc && bit_depth_chroma !=
sps->bit_depth) {
988 "Luma bit depth (%d) is different from chroma bit depth (%d), "
989 "this is unsupported.\n",
990 sps->bit_depth, bit_depth_chroma);
993 sps->bit_depth_chroma = bit_depth_chroma;
1000 if (
sps->log2_max_poc_lsb > 16) {
1002 sps->log2_max_poc_lsb - 4);
1007 start = sublayer_ordering_info ? 0 :
sps->max_sub_layers - 1;
1008 for (
i = start;
i <
sps->max_sub_layers;
i++) {
1014 sps->temporal_layer[
i].max_dec_pic_buffering - 1
U);
1017 if (
sps->temporal_layer[
i].num_reorder_pics >
sps->temporal_layer[
i].max_dec_pic_buffering - 1) {
1019 sps->temporal_layer[
i].num_reorder_pics);
1024 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[
i].num_reorder_pics + 1;
1028 if (!sublayer_ordering_info) {
1029 for (
i = 0;
i < start;
i++) {
1030 sps->temporal_layer[
i].max_dec_pic_buffering =
sps->temporal_layer[start].max_dec_pic_buffering;
1031 sps->temporal_layer[
i].num_reorder_pics =
sps->temporal_layer[start].num_reorder_pics;
1032 sps->temporal_layer[
i].max_latency_increase =
sps->temporal_layer[start].max_latency_increase;
1040 sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
1041 sps->log2_min_tb_size;
1043 if (
sps->log2_min_cb_size < 3 ||
sps->log2_min_cb_size > 30) {
1048 if (
sps->log2_diff_max_min_coding_block_size > 30) {
1049 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);
1053 if (
sps->log2_min_tb_size >=
sps->log2_min_cb_size ||
sps->log2_min_tb_size < 2) {
1058 if (log2_diff_max_min_transform_block_size < 0 || log2_diff_max_min_transform_block_size > 30) {
1059 av_log(avctx,
AV_LOG_ERROR,
"Invalid value %d for log2_diff_max_min_transform_block_size", log2_diff_max_min_transform_block_size);
1067 if (
sps->scaling_list_enable_flag) {
1081 if (
sps->pcm_enabled_flag) {
1085 sps->pcm.log2_max_pcm_cb_size =
sps->pcm.log2_min_pcm_cb_size +
1087 if (
FFMAX(
sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma) >
sps->bit_depth) {
1089 "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1090 sps->pcm.bit_depth,
sps->pcm.bit_depth_chroma,
sps->bit_depth);
1103 for (
i = 0;
i <
sps->nb_st_rps;
i++) {
1110 if (
sps->long_term_ref_pics_present_flag) {
1114 sps->num_long_term_ref_pics_sps);
1117 for (
i = 0;
i <
sps->num_long_term_ref_pics_sps;
i++) {
1124 sps->sps_strong_intra_smoothing_enable_flag =
get_bits1(gb);
1133 if (
sps->sps_range_extension_flag) {
1134 sps->transform_skip_rotation_enabled_flag =
get_bits1(gb);
1135 sps->transform_skip_context_enabled_flag =
get_bits1(gb);
1140 sps->extended_precision_processing_flag =
get_bits1(gb);
1141 if (
sps->extended_precision_processing_flag)
1143 "extended_precision_processing_flag not yet implemented\n");
1146 sps->high_precision_offsets_enabled_flag =
get_bits1(gb);
1147 if (
sps->high_precision_offsets_enabled_flag)
1149 "high_precision_offsets_enabled_flag not yet implemented\n");
1151 sps->persistent_rice_adaptation_enabled_flag =
get_bits1(gb);
1153 sps->cabac_bypass_alignment_enabled_flag =
get_bits1(gb);
1154 if (
sps->cabac_bypass_alignment_enabled_flag)
1156 "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1159 if (apply_defdispwin) {
1160 sps->output_window.left_offset +=
sps->vui.def_disp_win.left_offset;
1161 sps->output_window.right_offset +=
sps->vui.def_disp_win.right_offset;
1162 sps->output_window.top_offset +=
sps->vui.def_disp_win.top_offset;
1163 sps->output_window.bottom_offset +=
sps->vui.def_disp_win.bottom_offset;
1166 ow = &
sps->output_window;
1177 "Displaying the whole video surface.\n");
1178 memset(ow, 0,
sizeof(*ow));
1179 memset(&
sps->pic_conf_win, 0,
sizeof(
sps->pic_conf_win));
1183 sps->log2_ctb_size =
sps->log2_min_cb_size +
1184 sps->log2_diff_max_min_coding_block_size;
1185 sps->log2_min_pu_size =
sps->log2_min_cb_size - 1;
1191 if (
sps->log2_ctb_size < 4) {
1194 "log2_ctb_size %d differs from the bounds of any known profile\n",
1195 sps->log2_ctb_size);
1200 sps->ctb_width = (
sps->width + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1201 sps->ctb_height = (
sps->height + (1 <<
sps->log2_ctb_size) - 1) >>
sps->log2_ctb_size;
1202 sps->ctb_size =
sps->ctb_width *
sps->ctb_height;
1204 sps->min_cb_width =
sps->width >>
sps->log2_min_cb_size;
1205 sps->min_cb_height =
sps->height >>
sps->log2_min_cb_size;
1206 sps->min_tb_width =
sps->width >>
sps->log2_min_tb_size;
1207 sps->min_tb_height =
sps->height >>
sps->log2_min_tb_size;
1208 sps->min_pu_width =
sps->width >>
sps->log2_min_pu_size;
1209 sps->min_pu_height =
sps->height >>
sps->log2_min_pu_size;
1210 sps->tb_mask = (1 << (
sps->log2_ctb_size -
sps->log2_min_tb_size)) - 1;
1212 sps->qp_bd_offset = 6 * (
sps->bit_depth - 8);
1214 if (av_mod_uintp2(
sps->width,
sps->log2_min_cb_size) ||
1215 av_mod_uintp2(
sps->height,
sps->log2_min_cb_size)) {
1220 if (
sps->max_transform_hierarchy_depth_inter >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1221 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_inter out of range: %d\n",
1222 sps->max_transform_hierarchy_depth_inter);
1225 if (
sps->max_transform_hierarchy_depth_intra >
sps->log2_ctb_size -
sps->log2_min_tb_size) {
1226 av_log(avctx,
AV_LOG_ERROR,
"max_transform_hierarchy_depth_intra out of range: %d\n",
1227 sps->max_transform_hierarchy_depth_intra);
1230 if (
sps->log2_max_trafo_size >
FFMIN(
sps->log2_ctb_size, 5)) {
1232 "max transform block size out of range: %d\n",
1233 sps->log2_max_trafo_size);
1251 unsigned int sps_id;
1262 if (nal_size >
sizeof(
sps->data)) {
1265 nal_size,
sizeof(
sps->data));
1266 sps->data_size =
sizeof(
sps->data);
1268 sps->data_size = nal_size;
1282 "Parsed SPS: id %d; coded wxh: %dx%d; "
1283 "cropped wxh: %dx%d; pix_fmt: %s.\n",
1284 sps_id,
sps->width,
sps->height,
1285 sps->width - (
sps->output_window.left_offset +
sps->output_window.right_offset),
1286 sps->height - (
sps->output_window.top_offset +
sps->output_window.bottom_offset),
1326 if (
pps->transform_skip_enabled_flag) {
1329 pps->cross_component_prediction_enabled_flag =
get_bits1(gb);
1330 pps->chroma_qp_offset_list_enabled_flag =
get_bits1(gb);
1331 if (
pps->chroma_qp_offset_list_enabled_flag) {
1334 if (
pps->chroma_qp_offset_list_len_minus1 > 5) {
1336 "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1339 for (
i = 0;
i <=
pps->chroma_qp_offset_list_len_minus1;
i++) {
1341 if (
pps->cb_qp_offset_list[
i]) {
1343 "cb_qp_offset_list not tested yet.\n");
1346 if (
pps->cr_qp_offset_list[
i]) {
1348 "cb_qp_offset_list not tested yet.\n");
1355 if (
pps->log2_sao_offset_scale_luma >
FFMAX(
sps->bit_depth - 10, 0)
1356 ||
pps->log2_sao_offset_scale_chroma >
FFMAX(
sps->bit_depth_chroma - 10, 0)
1367 int pic_area_in_ctbs;
1368 int i, j,
x, y, ctb_addr_rs, tile_id;
1374 if (!
pps->col_bd || !
pps->row_bd || !
pps->col_idxX)
1377 if (
pps->uniform_spacing_flag) {
1378 if (!
pps->column_width) {
1382 if (!
pps->column_width || !
pps->row_height)
1385 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
1386 pps->column_width[
i] = ((
i + 1) *
sps->ctb_width) /
pps->num_tile_columns -
1387 (
i *
sps->ctb_width) /
pps->num_tile_columns;
1390 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
1391 pps->row_height[
i] = ((
i + 1) *
sps->ctb_height) /
pps->num_tile_rows -
1392 (
i *
sps->ctb_height) /
pps->num_tile_rows;
1397 for (
i = 0;
i <
pps->num_tile_columns;
i++)
1398 pps->col_bd[
i + 1] =
pps->col_bd[
i] +
pps->column_width[
i];
1401 for (
i = 0;
i <
pps->num_tile_rows;
i++)
1402 pps->row_bd[
i + 1] =
pps->row_bd[
i] +
pps->row_height[
i];
1404 for (
i = 0, j = 0;
i <
sps->ctb_width;
i++) {
1405 if (
i >
pps->col_bd[j])
1407 pps->col_idxX[
i] = j;
1413 pic_area_in_ctbs =
sps->ctb_width *
sps->ctb_height;
1419 if (!
pps->ctb_addr_rs_to_ts || !
pps->ctb_addr_ts_to_rs ||
1420 !
pps->tile_id || !
pps->min_tb_addr_zs_tab) {
1424 for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1425 int tb_x = ctb_addr_rs %
sps->ctb_width;
1426 int tb_y = ctb_addr_rs /
sps->ctb_width;
1431 for (
i = 0;
i <
pps->num_tile_columns;
i++) {
1432 if (tb_x < pps->col_bd[
i + 1]) {
1438 for (
i = 0;
i <
pps->num_tile_rows;
i++) {
1439 if (tb_y < pps->row_bd[
i + 1]) {
1445 for (
i = 0;
i < tile_x;
i++)
1446 val +=
pps->row_height[tile_y] *
pps->column_width[
i];
1447 for (
i = 0;
i < tile_y;
i++)
1450 val += (tb_y -
pps->row_bd[tile_y]) *
pps->column_width[tile_x] +
1451 tb_x -
pps->col_bd[tile_x];
1453 pps->ctb_addr_rs_to_ts[ctb_addr_rs] =
val;
1454 pps->ctb_addr_ts_to_rs[
val] = ctb_addr_rs;
1457 for (j = 0, tile_id = 0; j <
pps->num_tile_rows; j++)
1458 for (
i = 0;
i <
pps->num_tile_columns;
i++, tile_id++)
1459 for (y =
pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1460 for (
x =
pps->col_bd[
i]; x < pps->col_bd[
i + 1];
x++)
1461 pps->tile_id[
pps->ctb_addr_rs_to_ts[y *
sps->ctb_width +
x]] = tile_id;
1464 if (!
pps->tile_pos_rs)
1467 for (j = 0; j <
pps->num_tile_rows; j++)
1468 for (
i = 0;
i <
pps->num_tile_columns;
i++)
1469 pps->tile_pos_rs[j *
pps->num_tile_columns +
i] =
1470 pps->row_bd[j] *
sps->ctb_width +
pps->col_bd[
i];
1472 log2_diff =
sps->log2_ctb_size -
sps->log2_min_tb_size;
1473 pps->min_tb_addr_zs = &
pps->min_tb_addr_zs_tab[1*(
sps->tb_mask+2)+1];
1474 for (y = 0; y <
sps->tb_mask+2; y++) {
1475 pps->min_tb_addr_zs_tab[y*(
sps->tb_mask+2)] = -1;
1476 pps->min_tb_addr_zs_tab[y] = -1;
1478 for (y = 0; y <
sps->tb_mask+1; y++) {
1479 for (
x = 0;
x <
sps->tb_mask+1;
x++) {
1480 int tb_x =
x >> log2_diff;
1481 int tb_y = y >> log2_diff;
1482 int rs =
sps->ctb_width * tb_y + tb_x;
1483 int val =
pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
1484 for (
i = 0;
i < log2_diff;
i++) {
1486 val += (m &
x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1488 pps->min_tb_addr_zs[y * (
sps->tb_mask+2) +
x] =
val;
1500 unsigned int pps_id = 0;
1502 unsigned log2_parallel_merge_level_minus2;
1520 if (nal_size >
sizeof(
pps->data)) {
1523 nal_size,
sizeof(
pps->data));
1524 pps->data_size =
sizeof(
pps->data);
1526 pps->data_size = nal_size;
1531 pps->loop_filter_across_tiles_enabled_flag = 1;
1532 pps->num_tile_columns = 1;
1533 pps->num_tile_rows = 1;
1534 pps->uniform_spacing_flag = 1;
1535 pps->disable_dbf = 0;
1536 pps->beta_offset = 0;
1538 pps->log2_max_transform_skip_block_size = 2;
1560 pps->dependent_slice_segments_enabled_flag =
get_bits1(gb);
1562 pps->num_extra_slice_header_bits =
get_bits(gb, 3);
1577 pps->diff_cu_qp_delta_depth = 0;
1578 if (
pps->cu_qp_delta_enabled_flag)
1581 if (
pps->diff_cu_qp_delta_depth < 0 ||
1582 pps->diff_cu_qp_delta_depth >
sps->log2_diff_max_min_coding_block_size) {
1584 pps->diff_cu_qp_delta_depth);
1590 if (
pps->cb_qp_offset < -12 ||
pps->cb_qp_offset > 12) {
1597 if (
pps->cr_qp_offset < -12 ||
pps->cr_qp_offset > 12) {
1603 pps->pic_slice_level_chroma_qp_offsets_present_flag =
get_bits1(gb);
1612 if (
pps->tiles_enabled_flag) {
1616 if (num_tile_columns_minus1 < 0 ||
1617 num_tile_columns_minus1 >=
sps->ctb_width) {
1619 num_tile_columns_minus1);
1623 if (num_tile_rows_minus1 < 0 ||
1624 num_tile_rows_minus1 >=
sps->ctb_height) {
1626 num_tile_rows_minus1);
1630 pps->num_tile_columns = num_tile_columns_minus1 + 1;
1631 pps->num_tile_rows = num_tile_rows_minus1 + 1;
1635 if (!
pps->column_width || !
pps->row_height) {
1641 if (!
pps->uniform_spacing_flag) {
1643 for (
i = 0;
i <
pps->num_tile_columns - 1;
i++) {
1645 sum +=
pps->column_width[
i];
1647 if (sum >=
sps->ctb_width) {
1652 pps->column_width[
pps->num_tile_columns - 1] =
sps->ctb_width - sum;
1655 for (
i = 0;
i <
pps->num_tile_rows - 1;
i++) {
1657 sum +=
pps->row_height[
i];
1659 if (sum >=
sps->ctb_height) {
1664 pps->row_height[
pps->num_tile_rows - 1] =
sps->ctb_height - sum;
1666 pps->loop_filter_across_tiles_enabled_flag =
get_bits1(gb);
1669 pps->seq_loop_filter_across_slices_enabled_flag =
get_bits1(gb);
1671 pps->deblocking_filter_control_present_flag =
get_bits1(gb);
1672 if (
pps->deblocking_filter_control_present_flag) {
1673 pps->deblocking_filter_override_enabled_flag =
get_bits1(gb);
1675 if (!
pps->disable_dbf) {
1678 if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
1684 if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1690 pps->beta_offset = 2 * beta_offset_div2;
1691 pps->tc_offset = 2 * tc_offset_div2;
1696 if (
pps->scaling_list_data_present_flag) {
1704 if (log2_parallel_merge_level_minus2 >
sps->log2_ctb_size) {
1706 log2_parallel_merge_level_minus2);
1710 pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
1712 pps->slice_header_extension_present_flag =
get_bits1(gb);
1761 int max_poc_lsb = 1 <<
sps->log2_max_poc_lsb;
1762 int prev_poc_lsb = pocTid0 % max_poc_lsb;
1763 int prev_poc_msb = pocTid0 - prev_poc_lsb;
1766 if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
1767 poc_msb = prev_poc_msb + max_poc_lsb;
1768 else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
1769 poc_msb = prev_poc_msb - max_poc_lsb;
1771 poc_msb = prev_poc_msb;
1779 return poc_msb + poc_lsb;