Go to the documentation of this file.
37 switch (
sps->bit_depth) {
58 "The following bit-depths are currently specified: 8, 10, 12 bits, "
59 "chroma_format_idc is %d, depth is %d\n",
60 r->sps_chroma_format_idc,
sps->bit_depth);
68 sps->hshift[0] =
sps->vshift[0] = 0;
69 sps->hshift[2] =
sps->hshift[1] =
desc->log2_chroma_w;
70 sps->vshift[2] =
sps->vshift[1] =
desc->log2_chroma_h;
72 sps->pixel_shift =
sps->bit_depth > 8;
81 sps->bit_depth =
r->sps_bitdepth_minus8 + 8;
82 sps->qp_bd_offset = 6 * (
sps->bit_depth - 8);
83 sps->log2_transform_range =
84 r->sps_extended_precision_flag ?
FFMAX(15,
FFMIN(20,
sps->bit_depth + 6)) : 15;
91 const int num_qp_tables =
r->sps_same_qp_table_for_chroma_flag ?
92 1 : (
r->sps_joint_cbcr_enabled_flag ? 3 : 2);
94 for (
int i = 0;
i < num_qp_tables;
i++) {
95 int num_points_in_qp_table;
98 int off =
sps->qp_bd_offset;
100 num_points_in_qp_table =
r->sps_num_points_in_qp_table_minus1[
i] + 1;
102 qp_out[0] = qp_in[0] =
r->sps_qp_table_start_minus26[
i] + 26;
103 for (
int j = 0; j < num_points_in_qp_table; j++ ) {
104 delta_qp_in[j] =
r->sps_delta_qp_in_val_minus1[
i][j] + 1;
105 qp_in[j+1] = qp_in[j] + delta_qp_in[j];
106 qp_out[j+1] = qp_out[j] + (
r->sps_delta_qp_in_val_minus1[
i][j] ^
r->sps_delta_qp_diff_val[
i][j]);
108 sps->chroma_qp_table[
i][qp_in[0] + off] = qp_out[0];
109 for (
int k = qp_in[0] - 1 + off; k >= 0; k--)
110 sps->chroma_qp_table[
i][k] =
av_clip(
sps->chroma_qp_table[
i][k+1]-1, -off, 63);
112 for (
int j = 0; j < num_points_in_qp_table; j++) {
113 int sh = delta_qp_in[j] >> 1;
114 for (
int k = qp_in[j] + 1 + off, m = 1; k <= qp_in[j+1] + off; k++, m++) {
115 sps->chroma_qp_table[
i][k] =
sps->chroma_qp_table[
i][qp_in[j] + off] +
116 ((qp_out[j+1] - qp_out[j]) * m + sh) / delta_qp_in[j];
119 for (
int k = qp_in[num_points_in_qp_table] + 1 + off; k <= 63 + off; k++)
120 sps->chroma_qp_table[
i][k] =
av_clip(
sps->chroma_qp_table[
i][k-1] + 1, -
sps->qp_bd_offset, 63);
122 if (
r->sps_same_qp_table_for_chroma_flag) {
123 memcpy(&
sps->chroma_qp_table[1], &
sps->chroma_qp_table[0],
sizeof(
sps->chroma_qp_table[0]));
124 memcpy(&
sps->chroma_qp_table[2], &
sps->chroma_qp_table[0],
sizeof(
sps->chroma_qp_table[0]));
132 sps->max_pic_order_cnt_lsb = 1 << (
sps->r->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);
139 sps->max_num_merge_cand = 6 -
r->sps_six_minus_max_num_merge_cand;
140 sps->max_num_ibc_merge_cand = 6 -
r->sps_six_minus_max_num_ibc_merge_cand;
142 if (
sps->r->sps_gpm_enabled_flag) {
143 sps->max_num_gpm_merge_cand = 2;
144 if (
sps->max_num_merge_cand >= 3)
145 sps->max_num_gpm_merge_cand =
sps->max_num_merge_cand -
r->sps_max_num_merge_cand_minus_max_num_gpm_cand;
148 sps->log2_parallel_merge_level =
r->sps_log2_parallel_merge_level_minus2 + 2;
155 sps->ctb_log2_size_y =
r->sps_log2_ctu_size_minus5 + 5;
156 sps->ctb_size_y = 1 <<
sps->ctb_log2_size_y;
157 sps->min_cb_log2_size_y =
r->sps_log2_min_luma_coding_block_size_minus2 + 2;
158 sps->min_cb_size_y = 1 <<
sps->min_cb_log2_size_y;
159 sps->max_tb_size_y = 1 << (
r->sps_max_luma_transform_size_64_flag ? 6 : 5);
160 sps->max_ts_size = 1 << (
r->sps_log2_transform_skip_max_size_minus2 + 2);
167 if (
r->sps_ladf_enabled_flag) {
168 sps->num_ladf_intervals =
r->sps_num_ladf_intervals_minus2 + 2;
169 sps->ladf_interval_lower_bound[0] = 0;
170 for (
int i = 0;
i <
sps->num_ladf_intervals - 1;
i++) {
171 sps->ladf_interval_lower_bound[
i + 1] =
172 sps->ladf_interval_lower_bound[
i] +
r->sps_ladf_delta_threshold_minus1[
i] + 1;
189 if (
r->sps_chroma_format_idc != 0)
228 if (old_sps && old_sps->
r == rsps)
243 pps->chroma_qp_offset[
CB - 1] =
pps->r->pps_cb_qp_offset;
244 pps->chroma_qp_offset[
CR - 1] =
pps->r->pps_cr_qp_offset;
245 pps->chroma_qp_offset[
JCBCR - 1]=
pps->r->pps_joint_cbcr_qp_offset_value;
246 for (
int i = 0;
i < 6;
i++) {
247 pps->chroma_qp_offset_list[
i][
CB - 1] =
pps->r->pps_cb_qp_offset_list[
i];
248 pps->chroma_qp_offset_list[
i][
CR - 1] =
pps->r->pps_cr_qp_offset_list[
i];
249 pps->chroma_qp_offset_list[
i][
JCBCR - 1]=
pps->r->pps_joint_cbcr_qp_offset_list[
i];
257 pps->width =
r->pps_pic_width_in_luma_samples;
258 pps->height =
r->pps_pic_height_in_luma_samples;
262 pps->ctb_count =
pps->ctb_width *
pps->ctb_height;
264 pps->min_cb_width =
pps->width >>
sps->min_cb_log2_size_y;
265 pps->min_cb_height =
pps->height >>
sps->min_cb_log2_size_y;
286 if (!
pps->col_bd || !
pps->row_bd || !
pps->ctb_to_col_bd || !
pps->ctb_to_row_bd)
289 for (
int i = 0, j = 0;
i <
r->num_tile_columns;
i++) {
291 j +=
r->col_width_val[
i];
292 for (
int k =
pps->col_bd[
i]; k < j; k++)
293 pps->ctb_to_col_bd[k] =
pps->col_bd[
i];
295 pps->col_bd[
r->num_tile_columns] =
pps->ctb_to_col_bd[
pps->ctb_width] =
pps->ctb_width;
297 for (
int i = 0, j = 0;
i <
r->num_tile_rows;
i++) {
299 j +=
r->row_height_val[
i];
300 for (
int k =
pps->row_bd[
i]; k < j; k++)
301 pps->ctb_to_row_bd[k] =
pps->row_bd[
i];
303 pps->row_bd[
r->num_tile_rows] =
pps->ctb_to_row_bd[
pps->ctb_height] =
pps->ctb_height;
311 if (
r->pps_tile_idx_delta_present_flag) {
312 tile_idx +=
r->pps_tile_idx_delta_val[
i];
314 tile_idx +=
r->pps_slice_width_in_tiles_minus1[
i] + 1;
315 if (tile_idx %
r->num_tile_columns == 0)
316 tile_idx += (
r->pps_slice_height_in_tiles_minus1[
i]) *
r->num_tile_columns;
323 *tile_x = tile_idx %
pps->r->num_tile_columns;
324 *tile_y = tile_idx /
pps->r->num_tile_columns;
327 static void ctu_xy(
int *rx,
int *ry,
const int tile_x,
const int tile_y,
const VVCPPS *
pps)
329 *rx =
pps->col_bd[tile_x];
330 *ry =
pps->row_bd[tile_y];
335 return pps->ctb_width * ry + rx;
339 const int w,
const int h)
342 for (
int y = 0; y <
h; y++) {
343 for (
int x = 0; x <
w; x++) {
344 pps->ctb_addr_in_slice[*off] =
ctu_rs(rx + x, ry + y,
pps);
353 for (
int j = 0; j <
pps->r->num_tile_rows; j++) {
354 for (
int i = 0;
i <
pps->r->num_tile_columns;
i++) {
356 pps->col_bd[
i],
pps->row_bd[j],
357 pps->r->col_width_val[
i],
pps->r->row_height_val[j]);
362 static void subpic_tiles(
int *tile_x,
int *tile_y,
int *tile_x_end,
int *tile_y_end,
365 const int rx =
sps->r->sps_subpic_ctu_top_left_x[
i];
366 const int ry =
sps->r->sps_subpic_ctu_top_left_y[
i];
368 *tile_x = *tile_y = 0;
370 while (
pps->col_bd[*tile_x] != rx)
373 while (
pps->row_bd[*tile_y] != ry)
376 *tile_x_end = (*tile_x);
377 *tile_y_end = (*tile_y);
379 while (
pps->col_bd[*tile_x_end] < rx +
sps->r->sps_subpic_width_minus1[
i] + 1)
382 while (
pps->row_bd[*tile_y_end] < ry +
sps->r->sps_subpic_height_minus1[
i] + 1)
389 pps->col_bd[tx],
pps->row_bd[ty],
390 pps->r->col_width_val[tx],
sps->r->sps_subpic_height_minus1[
i] + 1);
395 for (
int ty = tile_y; ty < y_end; ty++) {
396 for (
int tx = tile_x; tx < x_end; tx++) {
398 pps->col_bd[tx],
pps->row_bd[ty],
399 pps->r->col_width_val[tx],
pps->r->row_height_val[ty]);
406 int tx, ty, x_end, y_end;
408 pps->slice_start_offset[
i] = *off;
409 pps->num_ctus_in_slice[
i] = 0;
412 if (ty + 1 == y_end &&
sps->r->sps_subpic_height_minus1[
i] + 1 <
pps->r->row_height_val[ty])
420 if (!
sps->r->sps_subpic_info_present_flag) {
423 for (
int i = 0;
i <
pps->r->pps_num_slices_in_pic_minus1 + 1;
i++)
431 int rx, ry, ctu_y_end, tile_x, tile_y;
435 ctu_y_end = ry +
r->row_height_val[tile_y];
436 while (ry < ctu_y_end) {
437 pps->slice_start_offset[
i] = *off;
439 r->col_width_val[tile_x],
r->slice_height_in_ctus[
i]);
440 ry +=
r->slice_height_in_ctus[
i++];
449 int rx, ry, tile_x, tile_y;
452 pps->slice_start_offset[
i] = *off;
453 pps->num_ctus_in_slice[
i] = 0;
454 for (
int ty = tile_y; ty <= tile_y +
r->pps_slice_height_in_tiles_minus1[
i]; ty++) {
455 for (
int tx = tile_x; tx <= tile_x +
r->pps_slice_width_in_tiles_minus1[
i]; tx++) {
458 r->col_width_val[tx],
r->row_height_val[ty]);
466 int tile_idx = 0, off = 0;
468 if (
r->pps_single_slice_per_subpic_flag) {
473 for (
int i = 0;
i <
r->pps_num_slices_in_pic_minus1 + 1;
i++) {
474 if (!
r->pps_slice_width_in_tiles_minus1[
i] &&
475 !
r->pps_slice_height_in_tiles_minus1[
i]) {
489 for (
int tile_y = 0; tile_y <
r->num_tile_rows; tile_y++) {
490 for (
int tile_x = 0; tile_x <
r->num_tile_columns; tile_x++) {
492 pps_add_ctus(
pps, &off, rx, ry,
r->col_width_val[tile_x],
r->row_height_val[tile_y]);
500 if (!
pps->ctb_addr_in_slice)
503 if (
pps->r->pps_rect_slice_flag)
515 if (
r->pps_ref_wraparound_enabled_flag)
516 pps->ref_wraparound_offset = (
pps->width /
sps->min_cb_size_y) -
r->pps_pic_width_minus_wraparound_offset;
529 pps->subpic_x[
i] = 0;
530 pps->subpic_y[
i] = 0;
531 pps->subpic_width[
i] =
pps->width;
532 pps->subpic_height[
i] =
pps->height;
600 if (old_pps && old_pps->
r == rpps)
623 rpps = h266->
pps[
ph->ph_pic_parameter_set_id];
642 #define WEIGHT_TABLE(x) \
643 w->nb_weights[L##x] = r->num_weights_l##x; \
644 for (int i = 0; i < w->nb_weights[L##x]; i++) { \
645 w->weight_flag[L##x][LUMA][i] = r->luma_weight_l##x##_flag[i]; \
646 w->weight_flag[L##x][CHROMA][i] = r->chroma_weight_l##x##_flag[i]; \
647 w->weight[L##x][LUMA][i] = denom[LUMA] + r->delta_luma_weight_l##x[i]; \
648 w->offset[L##x][LUMA][i] = r->luma_offset_l##x[i]; \
649 for (int j = CB; j <= CR; j++) { \
650 w->weight[L##x][j][i] = denom[CHROMA] + r->delta_chroma_weight_l##x[i][j - 1]; \
651 w->offset[L##x][j][i] = 128 + r->delta_chroma_offset_l##x[i][j - 1]; \
652 w->offset[L##x][j][i] -= (128 * w->weight[L##x][j][i]) >> w->log2_denom[CHROMA]; \
653 w->offset[L##x][j][i] = av_clip_intp2(w->offset[L##x][j][i], 7); \
661 w->log2_denom[
LUMA] =
r->luma_log2_weight_denom;
662 w->log2_denom[
CHROMA] =
w->log2_denom[
LUMA] +
r->delta_chroma_log2_weight_denom;
672 const int max_poc_lsb = 1 << (
sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);
673 const int prev_poc_lsb = poc_tid0 % max_poc_lsb;
674 const int prev_poc_msb = poc_tid0 - prev_poc_lsb;
675 const int poc_lsb =
ph->ph_pic_order_cnt_lsb;
678 if (
ph->ph_poc_msb_cycle_present_flag) {
679 poc_msb =
ph->ph_poc_msb_cycle_val * max_poc_lsb;
680 }
else if (is_clvss) {
683 if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
684 poc_msb = prev_poc_msb + max_poc_lsb;
685 else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
686 poc_msb = prev_poc_msb - max_poc_lsb;
688 poc_msb = prev_poc_msb;
691 return poc_msb + poc_lsb;
695 uint16_t *pivot1, uint16_t *pivot2, uint16_t *
scale_coeff,
const int idx,
const int max)
697 const int lut_sample =
709 const int off = 1 << (
shift - 1);
724 memset(cw, 0,
sizeof(cw));
732 input_pivot[
i] =
i * org_cw;
736 inv_scale_coeff[
i] = 0;
739 inv_scale_coeff[
i] = org_cw * (1 << 11) / cw[
i];
746 const int idx_y =
sample / org_cw;
760 while (i <= lmcs->max_bin_idx &&
sample >= lmcs->
pivot[
i + 1])
764 inv_scale_coeff,
i,
max);
777 if (
sps->sps_affine_enabled_flag)
778 return 5 -
sps->sps_five_minus_max_num_subblock_merge_cand;
779 return sps->sps_sbtmvp_enabled_flag &&
ph->ph_temporal_mvp_enabled_flag;
788 if (
pps->pps_wp_info_in_ph_flag)
795 const int poc_tid0,
const int is_clvss)
821 rpps = h266->
pps[
ph->ph_pic_parameter_set_id];
832 if (
ph->ph_explicit_scaling_list_enabled_flag)
835 if (
ph->ph_lmcs_enabled_flag) {
850 s->no_output_before_recovery_flag = 1;
852 s->no_output_before_recovery_flag =
s->last_eos;
857 if (
s->no_output_before_recovery_flag) {
859 s->gdr_recovery_point_poc =
ph->poc +
ph->r->ph_recovery_poc_cnt;
906 const uint8_t *
abs,
const uint8_t *sign,
const int size)
913 const uint8_t *mapped_abs,
const uint8_t *sign)
916 int c = mapped_abs[
i];
918 c = (1 - 2 * sign[
i]) * (1 << (
c - 1));
925 if (!
aps->alf_luma_filter_signal_flag)
929 const int ref =
aps->alf_luma_coeff_delta_idx[
i];
930 const uint8_t *
abs =
aps->alf_luma_coeff_abs[
ref];
931 const uint8_t *sign =
aps->alf_luma_coeff_sign[
ref];
941 if (!
aps->alf_chroma_filter_signal_flag)
946 const uint8_t *
abs =
aps->alf_chroma_coeff_abs[
i];
947 const uint8_t *sign =
aps->alf_chroma_coeff_sign[
i];
958 {
aps->alf_cc_cb_mapped_coeff_abs,
aps->alf_cc_cr_mapped_coeff_abs };
960 {
aps->alf_cc_cb_coeff_sign,
aps->alf_cc_cr_coeff_sign };
961 const int signaled[] = {
aps->alf_cc_cb_filter_signal_flag,
aps->alf_cc_cr_filter_signal_flag};
966 for (
int idx = 0; idx < 2; idx++) {
1007 for (
int id = 0;
id <
SL_MAX_ID;
id++) {
1009 const int log2_size =
av_log2(matrix_size);
1010 const int list_size = matrix_size * matrix_size;
1012 const uint8_t *
pred;
1017 if (!
aps->scaling_list_copy_mode_flag[
id]) {
1023 for (
int i = 0;
i < list_size;
i++) {
1028 next_coef +=
aps->scaling_list_delta_coef[
id][
i];
1036 if (!
aps->scaling_list_copy_mode_flag[
id] && !
aps->scaling_list_pred_mode_flag[
id]) {
1038 }
else if (!
aps->scaling_list_pred_id_delta[
id]) {
1041 const int ref_id =
id -
aps->scaling_list_pred_id_delta[
id];
1052 if (!
aps->scaling_list_copy_mode_flag[
id] && !
aps->scaling_list_pred_mode_flag[
id])
1054 else if (!
aps->scaling_list_pred_id_delta[
id])
1058 for (
int i = 0;
i < list_size;
i++) {
1061 const int off = y * matrix_size + x;
1088 switch (
aps->aps_params_type) {
1116 if (!alf_aps_chroma)
1140 if (
pps->r->pps_rect_slice_flag) {
1141 int pic_level_slice_idx = slice_address;
1143 pic_level_slice_idx +=
pps->r->num_slices_in_subpic[j];
1147 int tile_x = slice_address %
pps->r->num_tile_columns;
1148 int tile_y = slice_address /
pps->r->num_tile_columns;
1149 const int slice_start_ctb =
pps->row_bd[tile_y] *
pps->ctb_width +
pps->col_bd[tile_x] *
pps->r->row_height_val[tile_y];
1155 tile_x = tile_idx %
pps->r->num_tile_columns;
1156 tile_y = tile_idx /
pps->r->num_tile_columns;
1164 const int init_qp =
pps->pps_init_qp_minus26 + 26;
1166 if (!
pps->pps_qp_delta_info_in_ph_flag)
1176 if (!
pps->pps_wp_info_in_ph_flag &&
1177 ((
pps->pps_weighted_pred_flag &&
IS_P(rsh)) ||
1178 (
pps->pps_weighted_bipred_flag &&
IS_B(rsh))))
1186 if (!
r->sh_deblocking_filter_disabled_flag) {
1198 const int min_cb_log2_size_y =
sps->sps_log2_min_luma_coding_block_size_minus2 + 2;
1199 int min_qt_log2_size_y[2];
1202 min_qt_log2_size_y[
LUMA] = (min_cb_log2_size_y +
ph->ph_log2_diff_min_qt_min_cb_intra_slice_luma);
1203 min_qt_log2_size_y[
CHROMA] = (min_cb_log2_size_y +
ph->ph_log2_diff_min_qt_min_cb_intra_slice_chroma);
1205 sh->
max_bt_size[
LUMA] = 1 << (min_qt_log2_size_y[
LUMA] +
ph->ph_log2_diff_max_bt_min_qt_intra_slice_luma);
1208 sh->
max_tt_size[
LUMA] = 1 << (min_qt_log2_size_y[
LUMA] +
ph->ph_log2_diff_max_tt_min_qt_intra_slice_luma);
1218 min_qt_log2_size_y[
i] = (min_cb_log2_size_y +
ph->ph_log2_diff_min_qt_min_cb_inter_slice);
1219 sh->
max_bt_size[
i] = 1 << (min_qt_log2_size_y[
i] +
ph->ph_log2_diff_max_bt_min_qt_inter_slice);
1220 sh->
max_tt_size[
i] = 1 << (min_qt_log2_size_y[
i] +
ph->ph_log2_diff_max_tt_min_qt_inter_slice);
1234 if (
sps->sps_entry_point_offsets_present_flag) {
1240 if (
pps->ctb_to_row_bd[ctb_addr_y] !=
pps->ctb_to_row_bd[pre_ctb_addr_y] ||
1241 pps->ctb_to_col_bd[ctb_addr_x] !=
pps->ctb_to_col_bd[pre_ctb_addr_x] ||
1242 (ctb_addr_y != pre_ctb_addr_y &&
sps->sps_entropy_coding_sync_enabled_flag)) {
1273 if (!fps->
sps || !fps->
pps)
#define MIN_TU_LOG2
MinTbLog2SizeY.
static int ph_derive(VVCPH *ph, const H266RawSPS *sps, const H266RawPPS *pps, const int poc_tid0, const int is_clvss)
uint16_t sps_subpic_height_minus1[VVC_MAX_SLICES]
static int pps_bd(VVCPPS *pps)
static int aps_decode_scaling(const VVCScalingList **scaling, const H266RawAPS *aps)
static void pps_subpic(VVCPPS *pps, const VVCSPS *sps)
uint8_t cu_qp_delta_subdiv
CuQpDeltaSubdiv.
void * content_ref
If content is reference counted, a RefStruct reference backing content.
uint32_t num_ctus_in_curr_slice
NumCtusInCurrSlice.
static int ctu_rs(const int rx, const int ry, const VVCPPS *pps)
static const VVCSPS * sps_alloc(const H266RawSPS *rsps, void *log_ctx)
static int decode_frame_ps(VVCFrameParamSets *fps, const VVCParamSets *ps, const CodedBitstreamH266Context *h266, const int poc_tid0, const int is_clvss)
static void ctu_xy(int *rx, int *ry, const int tile_x, const int tile_y, const VVCPPS *pps)
static void sh_qp_y(VVCSH *sh, const H266RawPPS *pps, const H266RawPictureHeader *ph)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
#define LMCS_MAX_BIT_DEPTH
uint32_t entry_point_start_ctu[VVC_MAX_ENTRY_POINTS]
entry point start in ctu_addr
const H266RawPPS * r
RefStruct reference.
static void pps_subpic_slice(VVCPPS *pps, const VVCSPS *sps, const int i, int *off)
static void sh_partition_constraints(VVCSH *sh, const H266RawSPS *sps, const H266RawPictureHeader *ph)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
uint8_t cu_chroma_qp_offset_subdiv
CuChromaQpOffsetSubdiv.
static void subpic_tiles(int *tile_x, int *tile_y, int *tile_x_end, int *tile_y_end, const VVCSPS *sps, const VVCPPS *pps, const int i)
static void * ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))
A wrapper around ff_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
static int sps_map_pixel_format(VVCSPS *sps, void *log_ctx)
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
uint16_t sps_subpic_ctu_top_left_y[VVC_MAX_SLICES]
static void pps_subpic_less_than_one_tile_slice(VVCPPS *pps, const VVCSPS *sps, const int i, const int tx, const int ty, int *off)
uint8_t lmcs_delta_abs_crs
uint8_t sps_ccalf_enabled_flag
static void pps_ref_wraparound_offset(VVCPPS *pps, const VVCSPS *sps)
static void pps_multi_tiles_slice(VVCPPS *pps, const int tile_idx, const int i, int *off)
#define AV_PIX_FMT_YUV420P10
const H266RawSliceHeader * r
RefStruct reference.
int ff_vvc_decode_aps(VVCParamSets *ps, const CodedBitstreamUnit *unit)
RefStruct is an API for creating reference-counted objects with minimal overhead.
uint8_t pps_seq_parameter_set_id
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
static void sps_partition_constraints(VVCSPS *sps)
uint8_t num_chroma_filters
Coded bitstream unit structure.
uint16_t chroma_scale_coeff[LMCS_MAX_BIN_SIZE]
H266RawPPS * pps[VVC_MAX_PPS_COUNT]
RefStruct references.
static void pps_chroma_qp_offset(VVCPPS *pps)
const VVCSPS * sps
RefStruct reference.
static void alf_coeff(int16_t *coeff, const uint8_t *abs, const uint8_t *sign, const int size)
uint16_t sps_subpic_width_minus1[VVC_MAX_SLICES]
const VVCPPS * pps_list[VVC_MAX_PPS_COUNT]
RefStruct reference.
static void scaling_derive(VVCScalingList *sl, const H266RawAPS *aps)
int16_t cc_coeff[2][ALF_NUM_FILTERS_CC][ALF_NUM_COEFF_CC]
static int ph_compute_poc(const H266RawPictureHeader *ph, const H266RawSPS *sps, const int poc_tid0, const int is_clvss)
const VVCScalingList * sl
RefStruct reference.
static void sps_free(FFRefStructOpaque opaque, void *obj)
static const VVCPPS * pps_alloc(const H266RawPPS *rpps, const VVCSPS *sps)
uint8_t chroma_clip_idx[ALF_NUM_FILTERS_CHROMA][ALF_NUM_COEFF_CHROMA]
#define AV_PIX_FMT_YUV444P10
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint16_t lmcs_delta_abs_cw[16]
#define FF_ARRAY_ELEMS(a)
static void pps_no_rect_slice(VVCPPS *pps)
static int pps_one_tile_slices(VVCPPS *pps, const int tile_idx, int i, int *off)
uint8_t sps_seq_parameter_set_id
#define AV_CEIL_RSHIFT(a, b)
static int derive_matrix_size(const int id)
static void sh_inter(VVCSH *sh, const H266RawSPS *sps, const H266RawPPS *pps)
const uint8_t ff_vvc_diag_scan_y[5][5][16 *16]
static av_always_inline uint16_t lmcs_derive_lut_sample(uint16_t sample, uint16_t *pivot1, uint16_t *pivot2, uint16_t *scale_coeff, const int idx, const int max)
#define ALF_NUM_COEFF_CHROMA
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static void pps_width_height(VVCPPS *pps, const VVCSPS *sps)
union VVCLMCS::@226 inv_lut
const VVCSPS * sps_list[VVC_MAX_SPS_COUNT]
RefStruct reference.
int ff_vvc_decode_frame_ps(VVCFrameParamSets *fps, struct VVCContext *s)
#define AV_PIX_FMT_GRAY10
static int lmcs_derive_lut(VVCLMCS *lmcs, const H266RawAPS *rlmcs, const H266RawSPS *sps)
static void alf_derive(VVCALF *alf, const H266RawAPS *aps)
static int FUNC() aps(CodedBitstreamContext *ctx, RWContext *rw, H266RawAPS *current, int prefix)
#define GDR_SET_RECOVERED(s)
int ff_vvc_decode_sh(VVCSH *sh, const VVCFrameParamSets *fps, const CodedBitstreamUnit *unit)
static int pps_derive(VVCPPS *pps, const VVCSPS *sps)
static void pred_weight_table(PredWeightTable *w, const H266RawPredWeightTable *r)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
uint8_t pps_pic_parameter_set_id
const VVCALF * alf_list[VVC_MAX_ALF_COUNT]
RefStruct reference.
void ff_vvc_frame_ps_free(VVCFrameParamSets *fps)
static int pps_slice_map(VVCPPS *pps, const VVCSPS *sps)
uint8_t lmcs_delta_sign_cw_flag[16]
static int sh_alf_aps(const VVCSH *sh, const VVCFrameParamSets *fps)
uint8_t max_tt_size[2]
MaxTtSizeY, MaxTtSizeC.
static int decode_ps(VVCParamSets *ps, const CodedBitstreamH266Context *h266, void *log_ctx)
static void sps_ladf(VVCSPS *sps)
#define SL_MAX_MATRIX_SIZE
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
const VVCScalingList * scaling_list[VVC_MAX_SL_COUNT]
RefStruct reference.
#define AV_PIX_FMT_YUV422P10
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
const uint8_t ff_vvc_scaling_pred_8[8 *8]
static int aps_decode_alf(const VVCALF **alf, const H266RawAPS *aps)
const H266RawPictureHeader * r
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
int16_t luma_coeff[ALF_NUM_FILTERS_LUMA][ALF_NUM_COEFF_LUMA]
void ff_vvc_ps_uninit(VVCParamSets *ps)
const VVCPPS * pps
RefStruct reference.
static void decode_recovery_poc(VVCContext *s, const VVCPH *ph)
uint8_t max_mtt_depth[2]
MaxMttDepthY, MaxMttDepthC.
uint16_t sps_subpic_ctu_top_left_x[VVC_MAX_SLICES]
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
static int shift(int a, int b)
static void alf_luma(VVCALF *alf, const H266RawAPS *aps)
union VVCLMCS::@226 fwd_lut
static void sh_slice_address(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
H266RawPictureHeader * ph
#define ALF_NUM_COEFF_LUMA
#define AV_PIX_FMT_YUV422P12
static int decode_sps(VVCParamSets *ps, const H266RawSPS *rsps, void *log_ctx)
static int sh_derive(VVCSH *sh, const VVCFrameParamSets *fps)
#define AV_PIX_FMT_YUV444P12
static int decode_ph(VVCFrameParamSets *fps, const H266RawPictureHeader *rph, void *rph_ref, const int poc_tid0, const int is_clvss)
static int pps_add_ctus(VVCPPS *pps, int *off, const int rx, const int ry, const int w, const int h)
static int is_luma_list(const int id)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
const uint32_t * ctb_addr_in_curr_slice
CtbAddrInCurrSlice.
uint8_t scaling_matrix_dc_rec[SL_MAX_ID - SL_START_16x16]
ScalingMatrixDcRec[refId − 14].
#define ALF_NUM_FILTERS_LUMA
static int decode_pps(VVCParamSets *ps, const H266RawPPS *rpps)
const uint8_t ff_vvc_diag_scan_x[5][5][16 *16]
static int sps_derive(VVCSPS *sps, void *log_ctx)
uint16_t pivot[LMCS_MAX_BIN_SIZE+1]
#define i(width, name, range_min, range_max)
static void tile_xy(int *tile_x, int *tile_y, const int tile_idx, const VVCPPS *pps)
H266RawSPS * sps[VVC_MAX_SPS_COUNT]
RefStruct references.
void * rref
RefStruct reference, backing ph above.
uint16_t u16[LMCS_MAX_LUT_SIZE]
for high bit-depth
static void alf_cc(VVCALF *alf, const H266RawAPS *aps)
#define GDR_IS_RECOVERED(s)
void * av_calloc(size_t nmemb, size_t size)
uint8_t lmcs_delta_sign_crs_flag
static void alf_chroma(VVCALF *alf, const H266RawAPS *aps)
static int sps_bit_depth(VVCSPS *sps, void *log_ctx)
static const float pred[4]
const uint8_t ff_vvc_scaling_pred_16[8 *8]
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
#define LMCS_MAX_BIN_SIZE
@ VVC_MAX_POINTS_IN_QP_TABLE
#define AV_PIX_FMT_YUV420P12
static void sh_deblock_offsets(VVCSH *sh)
static void sps_poc(VVCSPS *sps)
static void decode_recovery_flag(VVCContext *s)
static void alf_coeff_cc(int16_t *coeff, const uint8_t *mapped_abs, const uint8_t *sign)
const VVCALF * alf_list[VVC_MAX_ALF_COUNT]
RefStruct reference.
static void sh_entry_points(VVCSH *sh, const H266RawSPS *sps, const VVCPPS *pps)
int8_t slice_qp_y
SliceQpY.
uint16_t sps_num_subpics_minus1
static int ref[MAX_W *MAX_W]
static int FUNC() scaling_list(CodedBitstreamContext *ctx, RWContext *rw, H264RawScalingList *current, int size_of_scaling_list)
static int next_tile_idx(int tile_idx, const int i, const H266RawPPS *r)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static void sps_inter(VVCSPS *sps)
static void pps_free(FFRefStructOpaque opaque, void *obj)
uint8_t u8[LMCS_MAX_LUT_SIZE]
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
uint8_t luma_clip_idx[ALF_NUM_FILTERS_LUMA][ALF_NUM_COEFF_LUMA]
static int sps_chroma_qp_table(VVCSPS *sps)
uint8_t max_bt_size[2]
MaxBtSizeY, MaxBtSizeC.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static void pps_single_slice_picture(VVCPPS *pps, int *off)
const H266RawSPS * r
RefStruct reference.
uint8_t num_cc_filters[2]
alf_cc_cb_filters_signalled_minus1 + 1, alf_cc_cr_filters_signalled_minus1 + 1
void * ph_ref
RefStruct reference backing ph above.
static const double coeff[2][5]
uint8_t min_qt_size[2]
MinQtSizeY, MinQtSizeC.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static void pps_subpic_one_or_more_tiles_slice(VVCPPS *pps, const int tile_x, const int tile_y, const int x_end, const int y_end, const int i, int *off)
const int ff_vvc_scaling_list0[8 *8]
#define AV_PIX_FMT_GRAY12
static av_always_inline int scale_coeff(const TransformBlock *tb, int coeff, const int scale, const int scale_m, const int log2_transform_range)
static void pps_single_slice_per_subpic(VVCPPS *pps, const VVCSPS *sps, int *off)
static int ph_max_num_subblock_merge_cand(const H266RawSPS *sps, const H266RawPictureHeader *ph)
int16_t chroma_coeff[ALF_NUM_FILTERS_CHROMA][ALF_NUM_COEFF_CHROMA]
uint8_t sps_subpic_treated_as_pic_flag[VVC_MAX_SLICES]
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
static void pps_rect_slice(VVCPPS *pps, const VVCSPS *sps)
const H266RawAPS * lmcs_list[VVC_MAX_LMCS_COUNT]
RefStruct reference.
uint8_t scaling_matrix_rec[SL_MAX_ID][SL_MAX_MATRIX_SIZE *SL_MAX_MATRIX_SIZE]
ScalingMatrixRec.