31 16, 16, 16, 16, 17, 18, 21, 24,
32 16, 16, 16, 16, 17, 19, 22, 25,
33 16, 16, 17, 18, 20, 22, 25, 29,
34 16, 16, 18, 21, 24, 27, 31, 36,
35 17, 17, 20, 24, 30, 35, 41, 47,
36 18, 19, 22, 27, 35, 44, 54, 65,
37 21, 22, 25, 31, 41, 54, 70, 88,
38 24, 25, 29, 36, 47, 65, 88, 115
42 16, 16, 16, 16, 17, 18, 20, 24,
43 16, 16, 16, 17, 18, 20, 24, 25,
44 16, 16, 17, 18, 20, 24, 25, 28,
45 16, 17, 18, 20, 24, 25, 28, 33,
46 17, 18, 20, 24, 25, 28, 33, 41,
47 18, 20, 24, 25, 28, 33, 41, 54,
48 20, 24, 25, 28, 33, 41, 54, 71,
49 24, 25, 28, 33, 41, 54, 71, 91
73 const HEVCSPS *sps,
int is_slice_header)
90 int delta_rps, abs_delta_rps;
94 if (is_slice_header) {
98 "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
108 delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
115 if (used || use_delta_flag) {
116 if (i < rps_ridx->num_delta_pocs)
117 delta_poc = delta_rps + rps_ridx->
delta_poc[i];
119 delta_poc = delta_rps;
137 for (k = i - 1; k >= 0; k--) {
139 if (delta_poc < tmp) {
163 unsigned int prev, nb_positive_pics;
183 for (i = 0; i < nb_positive_pics; i++) {
215 for (i = 0; i < 32; i++)
235 for (i = 0; i < max_num_sub_layers - 1; i++) {
239 if (max_num_sub_layers - 1> 0)
240 for (i = max_num_sub_layers - 1; i < 8; i++)
242 for (i = 0; i < max_num_sub_layers - 1; i++) {
251 int subpic_params_present)
256 for (i = 0; i < nb_cpb; i++) {
260 if (subpic_params_present) {
272 int nal_params_present = 0, vcl_params_present = 0;
273 int subpic_params_present = 0;
276 if (common_inf_present) {
280 if (nal_params_present || vcl_params_present) {
283 if (subpic_params_present) {
293 if (subpic_params_present)
302 for (i = 0; i < max_sublayers; i++) {
304 unsigned int nb_cpb = 1;
318 if (nal_params_present)
320 if (vcl_params_present)
408 int common_inf_present = 1;
439 vui->
sar = vui_sar[sar_idx];
440 else if (sar_idx == 255) {
445 "Unknown SAR index: %u.\n", sar_idx);
495 "discarding vui default display window, "
496 "original values are l:%u r:%u t:%u b:%u\n",
539 for (matrixId = 0; matrixId < 6; matrixId++) {
541 memset(sl->
sl[0][matrixId], 16, 16);
542 sl->
sl_dc[0][matrixId] = 16;
543 sl->
sl_dc[1][matrixId] = 16;
564 uint8_t scaling_list_pred_mode_flag[4][6];
565 int32_t scaling_list_dc_coef[2][6];
566 int size_id, matrix_id, i, pos;
568 for (size_id = 0; size_id < 4; size_id++)
569 for (matrix_id = 0; matrix_id < (size_id == 3 ? 2 : 6); matrix_id++) {
570 scaling_list_pred_mode_flag[size_id][matrix_id] =
get_bits1(gb);
571 if (!scaling_list_pred_mode_flag[size_id][matrix_id]) {
577 if (matrix_id < delta) {
579 "Invalid delta in scaling list data: %d.\n", delta);
583 memcpy(sl->
sl[size_id][matrix_id],
584 sl->
sl[size_id][matrix_id - delta],
585 size_id > 0 ? 64 : 16);
587 sl->
sl_dc[size_id - 2][matrix_id] = sl->
sl_dc[size_id - 2][matrix_id -
delta];
590 int next_coef, coef_num;
591 int32_t scaling_list_delta_coef;
594 coef_num =
FFMIN(64, 1 << (4 + (size_id << 1)));
596 scaling_list_dc_coef[size_id - 2][matrix_id] =
get_se_golomb(gb) + 8;
597 next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
598 sl->
sl_dc[size_id - 2][matrix_id] = next_coef;
600 for (i = 0; i < coef_num; i++) {
609 next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
610 sl->
sl[size_id][matrix_id][pos] = next_coef;
623 unsigned int sps_id = 0;
624 int log2_diff_max_min_transform_block_size;
625 int bit_depth_chroma,
start, vui_present, sublayer_ordering_info;
700 "discarding sps conformance window, "
701 "original values are l:%u r:%u t:%u b:%u\n",
717 if (bit_depth_chroma != sps->
bit_depth) {
719 "Luma bit depth (%d) is different from chroma bit depth (%d), "
720 "this is unsupported.\n",
749 "4:2:0, 4:2:2, 4:4:4 supports are currently specified for 8, 10 and 12 bits.\n");
797 if (!sublayer_ordering_info) {
798 for (i = 0; i <
start; i++) {
843 "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
882 int sps_extension_flag[1];
883 for (i = 0; i < 1; i++)
886 if (sps_extension_flag[0]) {
887 int extended_precision_processing_flag;
888 int high_precision_offsets_enabled_flag;
889 int cabac_bypass_alignment_enabled_flag;
897 extended_precision_processing_flag =
get_bits1(gb);
898 if (extended_precision_processing_flag)
900 "extended_precision_processing_flag not yet implemented\n");
903 high_precision_offsets_enabled_flag =
get_bits1(gb);
904 if (high_precision_offsets_enabled_flag)
906 "high_precision_offsets_enabled_flag not yet implemented\n");
910 cabac_bypass_alignment_enabled_flag =
get_bits1(gb);
911 if (cabac_bypass_alignment_enabled_flag)
913 "cabac_bypass_alignment_enabled_flag not yet implemented\n");
926 "chroma samples to preserve alignment.\n",
941 "Displaying the whole video surface.\n");
991 "max transform block size out of range: %d\n",
998 "Parsed SPS: id %d; coded wxh: %dx%d; "
999 "cropped wxh: %dx%d; pix_fmt: %s.\n",
1061 "cross_component_prediction_enabled_flag is not yet implemented.\n");
1069 "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1076 "cb_qp_offset_list not tested yet.\n");
1081 "cb_qp_offset_list not tested yet.\n");
1095 int pic_area_in_ctbs;
1096 int log2_diff_ctb_min_tb_size;
1097 int i, j, x,
y, ctb_addr_rs, tile_id;
1099 unsigned int pps_id = 0;
1287 int pps_range_extensions_flag =
get_bits1(gb);
1291 "PPS extension flag is partially implemented.\n");
1355 for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1356 int tb_x = ctb_addr_rs % sps->
ctb_width;
1357 int tb_y = ctb_addr_rs / sps->
ctb_width;
1363 if (tb_x < pps->col_bd[i + 1]) {
1370 if (tb_y < pps->row_bd[i + 1]) {
1376 for (i = 0; i < tile_x; i++)
1378 for (i = 0; i < tile_y; i++)
1382 tb_x - pps->
col_bd[tile_x];
1390 for (y = pps->
row_bd[j]; y < pps->row_bd[j + 1]; y++)
1391 for (x = pps->
col_bd[i]; x < pps->col_bd[i + 1]; x++)
1406 for (y = 0; y < sps->
tb_mask+2; y++) {
1410 for (y = 0; y < sps->
tb_mask+1; y++) {
1411 for (x = 0; x < sps->
tb_mask+1; x++) {
1412 int tb_x = x >> log2_diff_ctb_min_tb_size;
1413 int tb_y = y >> log2_diff_ctb_min_tb_size;
1414 int ctb_addr_rs = sps->
ctb_width * tb_y + tb_x;
1416 (log2_diff_ctb_min_tb_size * 2);
1417 for (i = 0; i < log2_diff_ctb_min_tb_size; i++) {
1419 val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);