65 { 0, 1, 2, 3, 16, 17, 18, 19, },
66 { 4, 5, 6, 7, 20, 21, 22, 23, },
67 { 8, 9, 10, 11, 24, 25, 26, 27, },
68 { 12, 13, 14, 15, 28, 29, 30, 31, },
69 { 32, 33, 34, 35, 48, 49, 50, 51, },
70 { 36, 37, 38, 39, 52, 53, 54, 55, },
71 { 40, 41, 42, 43, 56, 57, 58, 59, },
72 { 44, 45, 46, 47, 60, 61, 62, 63, },
144 { 0, 2, 5, 9, 14, 20, 27, 35, },
145 { 1, 4, 8, 13, 19, 26, 34, 42, },
146 { 3, 7, 12, 18, 25, 33, 41, 48, },
147 { 6, 11, 17, 24, 32, 40, 47, 53, },
148 { 10, 16, 23, 31, 39, 46, 52, 57, },
149 { 15, 22, 30, 38, 45, 51, 56, 60, },
150 { 21, 29, 37, 44, 50, 55, 59, 62, },
151 { 28, 36, 43, 49, 54, 58, 61, 63, },
194 int pic_size = width *
height;
195 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
196 ((height >> log2_min_cb_size) + 1);
251 uint8_t luma_weight_l0_flag[16];
252 uint8_t chroma_weight_l0_flag[16];
253 uint8_t luma_weight_l1_flag[16];
254 uint8_t chroma_weight_l1_flag[16];
264 if (!luma_weight_l0_flag[i]) {
271 chroma_weight_l0_flag[i] =
get_bits1(gb);
274 chroma_weight_l0_flag[i] = 0;
277 if (luma_weight_l0_flag[i]) {
282 if (chroma_weight_l0_flag[i]) {
283 for (j = 0; j < 2; j++) {
300 if (!luma_weight_l1_flag[i]) {
307 chroma_weight_l1_flag[i] =
get_bits1(gb);
310 chroma_weight_l1_flag[i] = 0;
313 if (luma_weight_l1_flag[i]) {
318 if (chroma_weight_l1_flag[i]) {
319 for (j = 0; j < 2; j++) {
340 int prev_delta_msb = 0;
341 unsigned int nb_sps = 0, nb_sh;
357 for (i = 0; i < rps->
nb_refs; i++) {
374 if (delta_poc_msb_present) {
377 if (i && i != nb_sps)
378 delta += prev_delta_msb;
381 prev_delta_msb =
delta;
391 unsigned int num = 0, den = 0;
445 if (num != 0 && den != 0)
503 int slice_address_length;
513 "Invalid slice segment address: %u.\n",
554 int short_term_ref_pic_set_sps_flag, poc;
560 "Ignoring POC change between slices: %d -> %d\n", s->
poc, poc);
567 short_term_ref_pic_set_sps_flag =
get_bits1(gb);
568 if (!short_term_ref_pic_set_sps_flag) {
575 int numbits, rps_idx;
583 rps_idx = numbits > 0 ?
get_bits(gb, numbits) : 0;
684 "Invalid collocated_ref_idx: %d.\n",
699 "Invalid number of merging MVP candidates: %d.\n",
716 int deblocking_filter_override_flag = 0;
719 deblocking_filter_override_flag =
get_bits1(gb);
721 if (deblocking_filter_override_flag) {
764 for (i = 0; i < length; i++)
773 "The slice_qp %d is outside the valid range "
798 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
800 #define SET_SAO(elem, value) \
802 if (!sao_merge_up_flag && !sao_merge_left_flag) \
804 else if (sao_merge_left_flag) \
805 sao->elem = CTB(s->sao, rx-1, ry).elem; \
806 else if (sao_merge_up_flag) \
807 sao->elem = CTB(s->sao, rx, ry-1).elem; \
815 int sao_merge_left_flag = 0;
816 int sao_merge_up_flag = 0;
827 if (ry > 0 && !sao_merge_left_flag) {
833 for (c_idx = 0; c_idx < 3; c_idx++) {
849 for (i = 0; i < 4; i++)
853 for (i = 0; i < 4; i++) {
862 }
else if (c_idx != 2) {
868 for (i = 0; i < 4; i++) {
884 int log2_trafo_size,
enum ScanType scan_idx,
887 #define GET_COORD(offset, n) \
889 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
890 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
893 int transform_skip_flag = 0;
895 int last_significant_coeff_x, last_significant_coeff_y;
899 int greater1_ctx = 1;
902 int x_cg_last_sig, y_cg_last_sig;
904 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
914 int trafo_size = 1 << log2_trafo_size;
915 int i, qp, shift, add,
scale, scale_m;
916 const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
922 static const int qp_c[] = {
923 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
927 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
928 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
929 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
933 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
934 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
935 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
955 qp = qp_c[qp_i - 30];
961 add = 1 << (shift - 1);
962 scale = level_scale[rem6[qp]] << (div6[qp]);
971 if (log2_trafo_size != 5)
972 matrix_id = 3 * matrix_id + c_idx;
974 scale_matrix = sl->
sl[log2_trafo_size - 2][matrix_id];
975 if (log2_trafo_size >= 4)
976 dc_scale = sl->
sl_dc[log2_trafo_size - 4][matrix_id];
982 log2_trafo_size == 2) {
986 last_significant_coeff_x =
988 last_significant_coeff_y =
991 if (last_significant_coeff_x > 3) {
993 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
994 (2 + (last_significant_coeff_x & 1)) +
998 if (last_significant_coeff_y > 3) {
1000 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1001 (2 + (last_significant_coeff_y & 1)) +
1006 FFSWAP(
int, last_significant_coeff_x, last_significant_coeff_y);
1008 x_cg_last_sig = last_significant_coeff_x >> 2;
1009 y_cg_last_sig = last_significant_coeff_y >> 2;
1013 int last_x_c = last_significant_coeff_x & 3;
1014 int last_y_c = last_significant_coeff_y & 3;
1019 if (trafo_size == 4) {
1022 }
else if (trafo_size == 8) {
1026 }
else if (trafo_size == 16) {
1042 num_coeff =
horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1049 num_coeff =
horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1053 num_last_subset = (num_coeff - 1) >> 4;
1055 for (i = num_last_subset; i >= 0; i--) {
1057 int x_cg, y_cg, x_c, y_c;
1058 int implicit_non_zero_coeff = 0;
1059 int64_t trans_coeff_level;
1061 int offset = i << 4;
1063 uint8_t significant_coeff_flag_idx[16];
1064 uint8_t nb_significant_coeff_flag = 0;
1066 x_cg = scan_x_cg[i];
1067 y_cg = scan_y_cg[i];
1069 if (i < num_last_subset && i > 0) {
1071 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1072 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1073 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1074 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1076 significant_coeff_group_flag[x_cg][y_cg] =
1078 implicit_non_zero_coeff = 1;
1080 significant_coeff_group_flag[x_cg][y_cg] =
1081 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1082 (x_cg == 0 && y_cg == 0));
1085 last_scan_pos = num_coeff - offset - 1;
1087 if (i == num_last_subset) {
1088 n_end = last_scan_pos - 1;
1089 significant_coeff_flag_idx[0] = last_scan_pos;
1090 nb_significant_coeff_flag = 1;
1095 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1096 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1097 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1098 prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1100 for (n = n_end; n >= 0; n--) {
1103 if (significant_coeff_group_flag[x_cg][y_cg] &&
1104 (n > 0 || implicit_non_zero_coeff == 0)) {
1109 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1110 nb_significant_coeff_flag++;
1111 implicit_non_zero_coeff = 0;
1114 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1115 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1116 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1117 nb_significant_coeff_flag++;
1122 n_end = nb_significant_coeff_flag;
1125 int first_nz_pos_in_cg = 16;
1126 int last_nz_pos_in_cg = -1;
1127 int c_rice_param = 0;
1128 int first_greater1_coeff_idx = -1;
1129 uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1130 uint16_t coeff_sign_flag;
1132 int sign_hidden = 0;
1135 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1137 if (!(i == num_last_subset) && greater1_ctx == 0)
1140 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1142 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1143 int n_idx = significant_coeff_flag_idx[m];
1144 int inc = (ctx_set << 2) + greater1_ctx;
1145 coeff_abs_level_greater1_flag[n_idx] =
1147 if (coeff_abs_level_greater1_flag[n_idx]) {
1149 }
else if (greater1_ctx > 0 && greater1_ctx < 3) {
1153 if (coeff_abs_level_greater1_flag[n_idx] &&
1154 first_greater1_coeff_idx == -1)
1155 first_greater1_coeff_idx = n_idx;
1157 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1158 sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1161 if (first_greater1_coeff_idx != -1) {
1167 coeff_sign_flag =
ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1170 for (m = 0; m < n_end; m++) {
1171 n = significant_coeff_flag_idx[m];
1173 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1174 if (trans_coeff_level == ((m < 8) ?
1175 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1178 trans_coeff_level += last_coeff_abs_level_remaining;
1179 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1180 c_rice_param =
FFMIN(c_rice_param + 1, 4);
1183 sum_abs += trans_coeff_level;
1184 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1185 trans_coeff_level = -trans_coeff_level;
1187 if (coeff_sign_flag >> 15)
1188 trans_coeff_level = -trans_coeff_level;
1189 coeff_sign_flag <<= 1;
1192 if (y_c || x_c || log2_trafo_size < 4) {
1194 switch (log2_trafo_size) {
1195 case 3: pos = (y_c << 3) + x_c;
break;
1196 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1);
break;
1197 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2);
break;
1198 default: pos = (y_c << 2) + x_c;
1200 scale_m = scale_matrix[pos];
1205 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1206 if(trans_coeff_level < 0) {
1207 if((~trans_coeff_level) & 0xFffffffffff8000)
1208 trans_coeff_level = -32768;
1210 if (trans_coeff_level & 0xffffffffffff8000)
1211 trans_coeff_level = 32767;
1214 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1222 if (transform_skip_flag)
1225 log2_trafo_size == 2)
1233 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1234 int log2_cb_size,
int log2_trafo_size,
1235 int trafo_depth,
int blk_idx)
1240 int trafo_size = 1 << log2_trafo_size;
1244 if (log2_trafo_size > 2) {
1245 trafo_size = trafo_size << (s->
sps->
hshift[1] - 1);
1249 }
else if (blk_idx == 3) {
1250 trafo_size = trafo_size << s->
sps->
hshift[1];
1252 trafo_size, trafo_size);
1274 "The cu_qp_delta %d is outside the valid range "
1305 if (log2_trafo_size > 2) {
1310 }
else if (blk_idx == 3) {
1322 int cb_size = 1 << log2_cb_size;
1330 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1331 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1332 s->
is_pcm[i + j * min_pu_width] = 2;
1336 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1337 int log2_cb_size,
int log2_trafo_size,
1338 int trafo_depth,
int blk_idx)
1344 if (trafo_depth > 0 && log2_trafo_size == 2) {
1355 if (trafo_depth == 1)
1368 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1370 trafo_depth < lc->cu.max_trafo_depth &&
1379 if (log2_trafo_size > 2) {
1380 if (trafo_depth == 0 ||
1386 if (trafo_depth == 0 ||
1393 if (split_transform_flag) {
1394 int x1 = x0 + ((1 << log2_trafo_size) >> 1);
1395 int y1 = y0 + ((1 << log2_trafo_size) >> 1);
1398 log2_cb_size, log2_trafo_size - 1,
1399 trafo_depth + 1, 0);
1403 log2_cb_size, log2_trafo_size - 1,
1404 trafo_depth + 1, 1);
1408 log2_cb_size, log2_trafo_size - 1,
1409 trafo_depth + 1, 2);
1413 log2_cb_size, log2_trafo_size - 1,
1414 trafo_depth + 1, 3);
1429 log2_cb_size, log2_trafo_size, trafo_depth,
1436 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1437 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1438 int x_tu = (x0 + j) >> log2_min_tu_size;
1439 int y_tu = (y0 + i) >> log2_min_tu_size;
1440 s->
cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1460 int cb_size = 1 << log2_cb_size;
1500 case 0: lc->
pu.
mvd.
x = 0;
break;
1506 case 0: lc->
pu.
mvd.
y = 0;
break;
1525 int block_w,
int block_h)
1529 ptrdiff_t srcstride = ref->
linesize[0];
1538 x_off += mv->
x >> 2;
1539 y_off += mv->
y >> 2;
1542 if (x_off < extra_left || y_off < extra_top ||
1546 int offset = extra_top * srcstride + (extra_left << s->
sps->
pixel_shift);
1547 int buf_offset = extra_top *
1551 edge_emu_stride, srcstride,
1554 x_off - extra_left, y_off - extra_top,
1555 pic_width, pic_height);
1557 srcstride = edge_emu_stride;
1579 int x_off,
int y_off,
int block_w,
int block_h)
1584 ptrdiff_t src1stride = ref->
linesize[1];
1585 ptrdiff_t src2stride = ref->
linesize[2];
1586 int pic_width = s->
sps->
width >> 1;
1592 x_off += mv->
x >> 3;
1593 y_off += mv->
y >> 3;
1609 edge_emu_stride, src1stride,
1613 pic_width, pic_height);
1616 src1stride = edge_emu_stride;
1618 block_w, block_h, mx, my, lc->
mc_buffer);
1621 edge_emu_stride, src2stride,
1625 pic_width, pic_height);
1627 src2stride = edge_emu_stride;
1630 block_w, block_h, mx, my,
1634 block_w, block_h, mx, my,
1637 block_w, block_h, mx, my,
1645 int y = (mv->
y >> 2) + y0 + height + 9;
1651 int log2_cb_size,
int partIdx)
1653 #define POS(c_idx, x, y) \
1654 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1655 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1658 struct MvField current_mv = {{{ 0 }}};
1673 int x_cb = x0 >> log2_min_cb_size;
1674 int y_cb = y0 >> log2_min_cb_size;
1689 log2_cb_size, partIdx,
1690 merge_idx, ¤t_mv);
1696 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1706 partIdx, merge_idx, ¤t_mv);
1712 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1719 if (inter_pred_idc !=
PRED_L1) {
1722 current_mv.
ref_idx[0] = ref_idx[0];
1728 partIdx, merge_idx, ¤t_mv,
1734 if (inter_pred_idc !=
PRED_L0) {
1737 current_mv.
ref_idx[1] = ref_idx[1];
1750 partIdx, merge_idx, ¤t_mv,
1761 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1766 ref0 = refPicList[0].
ref[current_mv.
ref_idx[0]];
1772 ref1 = refPicList[1].
ref[current_mv.
ref_idx[1]];
1783 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH);
1791 tmpstride, nPbW, nPbH);
1796 ¤t_mv.
mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1804 nPbW / 2, nPbH / 2);
1809 nPbW / 2, nPbH / 2);
1822 ¤t_mv.
mv[1], x0, y0, nPbW, nPbH);
1836 ¤t_mv.
mv[1], x0/2, y0/2, nPbW/2, nPbH/2);
1843 dst1, s->
frame->
linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1847 dst2, s->
frame->
linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1864 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH);
1866 ¤t_mv.
mv[1], x0, y0, nPbW, nPbH);
1876 tmp, tmp2, tmpstride, nPbW, nPbH);
1879 tmp, tmp2, tmpstride, nPbW, nPbH);
1883 ¤t_mv.
mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1885 ¤t_mv.
mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1895 tmpstride, nPbW / 2, nPbH / 2);
1902 tmpstride, nPbW / 2, nPbH / 2);
1914 int prev_intra_luma_pred_flag)
1932 int intra_pred_mode;
1937 if ((y0 - 1) < y_ctb)
1940 if (cand_left == cand_up) {
1941 if (cand_left < 2) {
1946 candidate[0] = cand_left;
1947 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1948 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1951 candidate[0] = cand_left;
1952 candidate[1] = cand_up;
1962 if (prev_intra_luma_pred_flag) {
1963 intra_pred_mode = candidate[lc->
pu.
mpm_idx];
1965 if (candidate[0] > candidate[1])
1967 if (candidate[0] > candidate[2])
1969 if (candidate[1] > candidate[2])
1973 for (i = 0; i < 3; i++)
1974 if (intra_pred_mode >= candidate[i])
1981 for (i = 0; i < size_in_pus; i++) {
1982 memset(&s->
tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1983 intra_pred_mode, size_in_pus);
1985 for (j = 0; j < size_in_pus; j++) {
1986 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].
is_intra = 1;
1987 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].
pred_flag[0] = 0;
1988 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].
pred_flag[1] = 0;
1989 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].
ref_idx[0] = 0;
1990 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].
ref_idx[1] = 0;
1991 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].
mv[0].x = 0;
1992 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].
mv[0].y = 0;
1993 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].
mv[1].x = 0;
1994 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].
mv[1].y = 0;
1998 return intra_pred_mode;
2002 int log2_cb_size,
int ct_depth)
2009 for (y = 0; y < length; y++)
2018 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2019 uint8_t prev_intra_luma_pred_flag[4];
2021 int pb_size = (1 << log2_cb_size) >> split;
2022 int side = split + 1;
2026 for (i = 0; i < side; i++)
2027 for (j = 0; j < side; j++)
2030 for (i = 0; i < side; i++) {
2031 for (j = 0; j < side; j++) {
2032 if (prev_intra_luma_pred_flag[2 * i + j])
2039 prev_intra_luma_pred_flag[2 * i + j]);
2044 if (chroma_mode != 4) {
2059 int pb_size = 1 << log2_cb_size;
2067 if (size_in_pus == 0)
2069 for (j = 0; j < size_in_pus; j++) {
2070 memset(&s->
tab_ipm[(y_pu + j) * min_pu_width + x_pu],
INTRA_DC, size_in_pus);
2071 for (k = 0; k < size_in_pus; k++)
2078 int cb_size = 1 << log2_cb_size;
2081 int length = cb_size >> log2_min_cb_size;
2083 int x_cb = x0 >> log2_min_cb_size;
2084 int y_cb = y0 >> log2_min_cb_size;
2096 for (x = 0; x < 4; x++)
2109 x = y_cb * min_cb_width + x_cb;
2110 for (y = 0; y < length; y++) {
2111 memset(&s->
skip_flag[x], skip_flag, length);
2138 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2186 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2202 log2_cb_size, 0, 0);
2217 x = y_cb * min_cb_width + x_cb;
2218 for (y = 0; y < length; y++) {
2229 int log2_cb_size,
int cb_depth)
2232 const int cb_size = 1 << log2_cb_size;
2235 if (x0 + cb_size <= s->sps->width &&
2236 y0 + cb_size <= s->sps->height &&
2251 const int cb_size_split = cb_size >> 1;
2252 const int x1 = x0 + cb_size_split;
2253 const int y1 = y0 + cb_size_split;
2258 #define SUBDIVIDE(x, y) \
2260 if (x < s->sps->width && y < s->sps->height) { \
2261 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2286 int ctb_addr_in_slice = ctb_addr_rs - s->
sh.
slice_addr;
2288 int tile_left_boundary, tile_up_boundary;
2289 int slice_left_boundary, slice_up_boundary;
2294 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2311 tile_left_boundary = x_ctb > 0 &&
2313 slice_left_boundary = x_ctb > 0 &&
2315 tile_up_boundary = y_ctb > 0 &&
2317 slice_up_boundary = y_ctb > 0 &&
2320 tile_left_boundary =
2321 tile_up_boundary = 1;
2322 slice_left_boundary = ctb_addr_in_slice > 0;
2323 slice_up_boundary = ctb_addr_in_slice >= s->
sps->
ctb_width;
2327 lc->
ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && tile_left_boundary);
2342 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2367 if (x_ctb + ctb_size >= s->
sps->
width &&
2394 "nal_unit_type: %d, nuh_layer_id: %dtemporal_id: %d\n",
2397 return nuh_layer_id == 0;
2405 for (c_idx = 0; c_idx < 3; c_idx++) {
2413 int len = min_pu_size >> hshift;
2416 for (n = 0; n < (min_pu_size >> vshift); n++) {
2417 memcpy(dst, src, len);
2514 int ctb_addr_ts, ret;
2570 if (s->
max_ra == INT_MAX) {
2592 }
else if (!s->
ref) {
2599 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2609 "Error constructing the reference lists for the current slice.\n");
2623 if (ctb_addr_ts < 0) {
2656 #define STARTCODE_TEST \
2657 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2658 if (src[i + 2] != 3) { \
2664 #if HAVE_FAST_UNALIGNED
2665 #define FIND_FIRST_ZERO \
2666 if (i > 0 && !src[i]) \
2671 for (i = 0; i + 1 < length; i += 9) {
2673 (
AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2674 0x8000800080008080ULL))
2681 for (i = 0; i + 1 < length; i += 5) {
2683 (
AV_RN32A(src + i) - 0x01000101U)) &
2692 for (i = 0; i + 1 < length; i += 2) {
2695 if (i > 0 && src[i - 1] == 0)
2701 if (i >= length - 1) {
2714 memcpy(dst, src, i);
2716 while (si + 2 < length) {
2718 if (src[si + 2] > 3) {
2719 dst[di++] = src[si++];
2720 dst[di++] = src[si++];
2721 }
else if (src[si] == 0 && src[si + 1] == 0) {
2722 if (src[si + 2] == 3) {
2732 dst[di++] = src[si++];
2735 dst[di++] = src[si++];
2747 int i, consumed, ret = 0;
2755 while (length >= 4) {
2757 int extract_length = 0;
2762 extract_length = (extract_length << 8) | buf[i];
2766 if (extract_length > length) {
2777 if (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2784 extract_length = length;
2821 for (i = 0; i < s->
nb_nals; i++) {
2825 "Error parsing NAL unit #%d.\n", i);
2840 for (i = 0; i < 16; i++)
2841 av_log(log_ctx, level,
"%02"PRIx8, md5[i]);
2870 for (i = 0; frame->
data[i]; i++) {
2878 for (j = 0; j < h; j++) {
2883 (
const uint16_t*)src, w);
2891 if (!memcmp(md5, s->
md5[i], 16)) {
3140 int i, j, num_arrays, nal_len_size;
3145 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3146 num_arrays = bytestream2_get_byte(&gb);
3153 for (i = 0; i < num_arrays; i++) {
3154 int type = bytestream2_get_byte(&gb) & 0x3f;
3155 int cnt = bytestream2_get_be16(&gb);
3157 for (j = 0; j < cnt; j++) {
3159 int nalsize = bytestream2_peek_be16(&gb) + 2;
3162 "Invalid NAL unit size in extradata.\n");
3169 "Decoding nal unit %d %d from hvcC failed\n",
3218 memset(s, 0,
sizeof(*s));
3234 #define OFFSET(x) offsetof(HEVCContext, x)
3235 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3245 {
"apply_defdispwin",
"Apply default display window from VUI",
OFFSET(apply_defdispwin),
3263 .priv_class = &hevc_decoder_class,
#define EDGE_EMU_BUFFER_STRIDE
static const uint8_t horiz_scan2x2_x[4]
int frame_packing_arrangement_type
unsigned int log2_min_cb_size
int sei_frame_packing_present
frame packing arrangement variables
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static const int16_t coeffs[28]
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
int ff_hevc_merge_idx_decode(HEVCContext *s)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define SAMPLE_CBF(tab, x, y)
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
int ff_hevc_frame_nb_refs(HEVCContext *s)
Get the number of candidate references for the current frame.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
static void restore_tqb_pixels(HEVCContext *s)
void(* put_hevc_epel[2][2])(int16_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride, int width, int height, int mx, int my, int16_t *mcbuffer)
void(* put_pcm)(uint8_t *dst, ptrdiff_t stride, int size, GetBitContext *gb, int pcm_bit_depth)
static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
Views are alternated temporally.
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
int ff_hevc_merge_flag_decode(HEVCContext *s)
int ff_hevc_sao_band_position_decode(HEVCContext *s)
int coded_width
Bitstream width / height, may be different from width/height e.g.
uint8_t edge_emu_buffer[(MAX_PB_SIZE+7)*EDGE_EMU_BUFFER_STRIDE *2]
static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref, const Mv *mv, int y0, int height)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
int ff_hevc_decode_nal_sps(HEVCContext *s)
Views are next to each other, but when upscaling apply a checkerboard pattern.
#define AV_LOG_WARNING
Something somehow does not look correct.
int content_interpretation_type
int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
int16_t x
horizontal component of motion vector
static int hevc_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
static int set_sps(HEVCContext *s, const HEVCSPS *sps)
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
uint8_t intra_split_flag
IntraSplitFlag.
int rem_intra_luma_pred_mode
enum AVColorRange color_range
MPEG vs JPEG YUV range.
void(* put_hevc_qpel[4][4])(int16_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride, int width, int height, int16_t *mcbuffer)
void ff_hevc_luma_mv_merge_mode(HEVCContext *s, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int part_idx, int merge_idx, MvField *mv)
int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
uint8_t weighted_bipred_flag
void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
int ff_hevc_decode_short_term_rps(HEVCContext *s, ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
#define DECLARE_ALIGNED(n, t, v)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
void(* put_unweighted_pred)(uint8_t *dst, ptrdiff_t dststride, int16_t *src, ptrdiff_t srcstride, int width, int height)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static void intra_prediction_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
uint8_t seq_loop_filter_across_slices_enabled_flag
uint8_t cabac_init_present_flag
void ff_hevc_hls_filter(HEVCContext *s, int x, int y)
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everythnig contained in src to dst and reset src.
int ff_hevc_frame_rps(HEVCContext *s)
Construct the reference picture sets for the current frame.
#define FF_ARRAY_ELEMS(a)
int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
int * ctb_addr_ts_to_rs
CtbAddrTSToRS.
int num_ref_idx_l0_default_active
num_ref_idx_l0_default_active_minus1 + 1
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
struct HEVCFrame * ref[MAX_REFS]
ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT]
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
static const uint8_t rem6[QP_MAX_NUM+1]
int ff_hevc_sao_type_idx_decode(HEVCContext *s)
uint16_t seq_decode
Sequence counters for decoded and output frames, so that old frames are output first after a POC rese...
#define SAMPLE(tab, x, y)
Value of the luma sample at position (x, y) in the 2D array tab.
enum NALUnitType first_nal_type
Macro definitions for various function/variable attributes.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
uint8_t entropy_coding_sync_enabled_flag
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static const uint8_t div6[QP_MAX_NUM+1]
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
static int hls_slice_data(HEVCContext *s)
const uint8_t ff_hevc_qpel_extra_before[4]
static void hls_sao_param(HEVCContext *s, int rx, int ry)
AVBufferPool * rpl_tab_pool
candidate references for the current frame
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
int ff_hevc_last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx, int log2_size)
unsigned int log2_max_trafo_size
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
struct AVMD5 * av_md5_alloc(void)
int ff_hevc_mpm_idx_decode(HEVCContext *s)
int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int ctx_set)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
static int set_side_data(HEVCContext *s)
uint8_t ctb_up_right_flag
uint8_t vps_timing_info_present_flag
int ff_hevc_abs_mvd_greater0_flag_decode(HEVCContext *s)
static int hls_slice_header(HEVCContext *s)
#define FF_PROFILE_HEVC_MAIN
int num_ref_idx_l1_default_active
num_ref_idx_l1_default_active_minus1 + 1
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
unsigned int log2_min_pcm_cb_size
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
static int hls_transform_unit(HEVCContext *s, int x0, int y0, int xBase, int yBase, int cb_xBase, int cb_yBase, int log2_cb_size, int log2_trafo_size, int trafo_depth, int blk_idx)
static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride, AVFrame *ref, const Mv *mv, int x_off, int y_off, int block_w, int block_h)
8.5.3.2.2.1 Luma sample interpolation process
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
uint8_t scaling_list_data_present_flag
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
int ff_hevc_decode_nal_sei(HEVCContext *s)
void(* put_weighted_pred_avg)(uint8_t *dst, ptrdiff_t dststride, int16_t *src1, int16_t *src2, ptrdiff_t srcstride, int width, int height)
#define EPEL_EXTRA_BEFORE
uint8_t loop_filter_disable_flag
int ff_hevc_mvd_decode(HEVCContext *s)
static void print_md5(void *log_ctx, int level, uint8_t md5[16])
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
uint8_t cu_transquant_bypass_flag
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
#define FF_PROFILE_HEVC_MAIN_10
static av_unused const uint8_t * skip_bytes(CABACContext *c, int n)
Skip n bytes and reset the decoder.
uint8_t transquant_bypass_enable_flag
int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
int temporal_id
temporal_id_plus1 - 1
#define SET_SAO(elem, value)
static void hevc_decode_flush(AVCodecContext *avctx)
static int hls_transform_tree(HEVCContext *s, int x0, int y0, int xBase, int yBase, int cb_xBase, int cb_yBase, int log2_cb_size, int log2_trafo_size, int trafo_depth, int blk_idx)
int slice_idx
number of the slice being currently decoded
uint8_t intra_pred_mode[4]
uint16_t depth_minus1
number of bits in the component minus 1
void av_md5_update(AVMD5 *ctx, const uint8_t *src, const int len)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int has_b_frames
Size of the frame reordering buffer in the decoder.
int flags
Additional information about the frame packing.
static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
uint8_t slice_initialized
1 if the independent slice segment header was successfully parsed
static int extract_rbsp(const uint8_t *src, int length, HEVCNAL *nal)
unsigned int log2_max_poc_lsb
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
void(* transform_add[4])(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
AVBufferRef * vps_list[MAX_VPS_COUNT]
static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2, ptrdiff_t dststride, AVFrame *ref, const Mv *mv, int x_off, int y_off, int block_w, int block_h)
8.5.3.2.2.2 Chroma sample interpolation process
#define CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
AVBufferRef * rpl_tab_buf
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int vui_timing_info_present_flag
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
Clip a signed integer value into the amin-amax range.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb)
Compute POC of the current frame and return it.
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
unsigned int log2_ctb_size
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
void(* weighted_pred)(uint8_t denom, int16_t wlxFlag, int16_t olxFlag, uint8_t *dst, ptrdiff_t dststride, int16_t *src, ptrdiff_t srcstride, int width, int height)
void ff_init_cabac_states(void)
void(* transquant_bypass[4])(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
static int verify_md5(HEVCContext *s, AVFrame *frame)
static const AVClass hevc_decoder_class
uint8_t max_trafo_depth
MaxTrafoDepth.
uint16_t sequence
A sequence counter, so that old frames are output first after a POC reset.
static char * split(char *message, char delim)
uint8_t tiles_enabled_flag
int ff_hevc_decode_nal_vps(HEVCContext *s)
int eo_class[3]
sao_eo_class
the normal 2^n-1 "JPEG" YUV ranges
uint32_t vps_num_units_in_tick
static av_cold int hevc_init_context(AVCodecContext *avctx)
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
int ff_hevc_mvd_sign_flag_decode(HEVCContext *s)
common internal API header
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
the normal 219*2^(n-8) "MPEG" YUV ranges
uint8_t lists_modification_present_flag
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
AVBufferRef * tab_mvf_buf
int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int base_level, int rc_rice_param)
uint8_t type_idx[3]
sao_type_idx
const uint8_t ff_hevc_qpel_extra[4]
int ff_hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
const uint8_t ff_hevc_qpel_extra_after[4]
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
int max_transform_hierarchy_depth_inter
void(* weighted_pred_avg)(uint8_t denom, int16_t wl0Flag, int16_t wl1Flag, int16_t ol0Flag, int16_t ol1Flag, uint8_t *dst, ptrdiff_t dststride, int16_t *src1, int16_t *src2, ptrdiff_t srcstride, int width, int height)
int16_t mc_buffer[(64+7)*64]
static const AVOption options[]
int offset_abs[3][4]
sao_offset_abs
int width
picture width / height.
int ff_hevc_output_frame(HEVCContext *s, AVFrame *frame, int flush)
Find next frame in output order and put a reference to it in frame.
static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size)
#define FF_PROFILE_UNKNOWN
static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size, int prev_intra_luma_pred_flag)
8.4.1
int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
AVBufferRef * sps_list[MAX_SPS_COUNT]
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
uint8_t cu_qp_delta_enabled_flag
uint8_t used_by_curr_pic_lt_sps_flag[32]
static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
Context Adaptive Binary Arithmetic Coder inline functions.
void ff_hevc_set_neighbour_available(HEVCContext *s, int x0, int y0, int nPbW, int nPbH)
uint8_t sign_data_hiding_flag
uint8_t output_flag_present_flag
const uint8_t ff_hevc_diag_scan4x4_y[16]
int offset_val[3][5]
SaoOffsetVal.
static int hevc_frame_start(HEVCContext *s)
AVBufferRef * pps_list[MAX_PPS_COUNT]
if(ac->has_optimized_func)
uint8_t pic_slice_level_chroma_qp_offsets_present_flag
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
int colour_description_present_flag
static const int8_t mv[256][2]
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
static void hls_prediction_unit(HEVCContext *s, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int partIdx)
enum AVPixelFormat pix_fmt
void ff_hevc_dsp_init(HEVCDSPContext *hevcdsp, int bit_depth)
enum AVStereo3DType type
How views are packed within the video.
#define AV_LOG_INFO
Standard information.
static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
static void pic_arrays_free(HEVCContext *s)
NOTE: Each function hls_foo correspond to the function foo in the specification (HLS stands for High ...
uint8_t transform_skip_enabled_flag
static av_cold int hevc_decode_init(AVCodecContext *avctx)
int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c, int log2_trafo_size, int scan_idx, int prev_sig)
uint8_t is_nalff
this flag is != 0 if bitstream is encapsulated as a format defined in 14496-15
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
unsigned int log2_min_pu_size
int ff_hevc_decode_nal_pps(HEVCContext *s)
int ff_hevc_abs_mvd_greater1_flag_decode(HEVCContext *s)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
unsigned int sps_id
seq_parameter_set_id
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
main external API structure.
static void close(AVCodecParserContext *s)
static int hevc_decode_extradata(HEVCContext *s)
enum PredMode pred_mode
PredMode.
void(* transform_skip)(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
int num_extra_slice_header_bits
uint8_t * data
The data buffer.
int16_t y
vertical component of motion vector
void ff_hevc_clear_refs(HEVCContext *s)
Mark all frames in DPB as unused for reference.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
uint8_t num_long_term_ref_pics_sps
void av_md5_init(AVMD5 *ctx)
static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb, int ctb_addr_ts)
void(* transform_4x4_luma_add)(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
uint32_t vui_num_units_in_tick
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
uint8_t deblocking_filter_control_present_flag
static unsigned int get_bits1(GetBitContext *s)
void ff_hevc_pred_init(HEVCPredContext *hpc, int bit_depth)
uint8_t * checksum_buf
used on BE to byteswap the lines for checksumming
uint8_t sps_temporal_mvp_enabled_flag
Describe the class of an AVClass context structure.
static void skip_bits(GetBitContext *s, int n)
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0, int log2_cb_size, int ct_depth)
enum AVColorSpace colorspace
YUV colorspace type.
static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
void(* intra_pred)(struct HEVCContext *s, int x0, int y0, int log2_size, int c_idx)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
int ff_hevc_sao_eo_class_decode(HEVCContext *s)
static const uint8_t diag_scan2x2_inv[2][2]
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
unsigned int log2_min_tb_size
enum PartMode part_mode
PartMode.
uint16_t lt_ref_pic_poc_lsb_sps[32]
int ff_hevc_slice_rpl(HEVCContext *s)
Construct the reference picture list(s) for the current slice.
static int hls_nal_unit(HEVCContext *s)
static const uint8_t horiz_scan4x4_x[16]
enum NALUnitType nal_unit_type
void av_md5_final(AVMD5 *ctx, uint8_t *dst)
int allocate_progress
Whether to allocate progress for frame threading.
uint8_t scaling_list_enable_flag
static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
static const uint8_t horiz_scan4x4_y[16]
int tc_offset
tc_offset_div2 * 2
uint8_t transfer_characteristic
uint8_t flags
A combination of HEVC_FRAME_FLAG_*.
Views are on top of each other.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
static const uint16_t scale[4]
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
uint8_t intra_pred_mode_c
static int hls_coding_quadtree(HEVCContext *s, int x0, int y0, int log2_cb_size, int cb_depth)
int eos
current packet contains an EOS/EOB NAL
struct HEVCSPS::@23 temporal_layer[MAX_SUB_LAYERS]
void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0, int log2_trafo_size, int slice_or_tiles_up_boundary, int slice_or_tiles_left_boundary)
Views are next to each other.
const uint8_t ff_hevc_diag_scan8x8_x[64]
int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
int max_transform_hierarchy_depth_intra
coded frame dimension in various units
int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
static void hls_residual_coding(HEVCContext *s, int x0, int y0, int log2_trafo_size, enum ScanType scan_idx, int c_idx)
common internal and external API header
uint8_t slice_or_tiles_up_boundary
AVBufferPool * av_buffer_pool_init(int size, AVBufferRef *(*alloc)(int size))
Allocate and initialize a buffer pool.
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
uint8_t weighted_pred_flag
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
int32_t * tab_slice_address
static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output, AVPacket *avpkt)
unsigned int * column_width
ColumnWidth.
static const uint8_t diag_scan2x2_x[4]
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
uint8_t * filter_slice_edges
uint8_t slice_header_extension_present_flag
static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
int ff_hevc_coeff_sign_flag(HEVCContext *s, uint8_t nb)
int nal_length_size
Number of bytes used for nal length (1, 2 or 4)
void ff_hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int part_idx, int merge_idx, MvField *mv, int mvp_lx_flag, int LX)
AVBufferPool * tab_mvf_pool
static av_cold int init(AVCodecParserContext *s)
int video_full_range_flag
int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
#define GET_COORD(offset, n)
static const uint8_t horiz_scan8x8_inv[8][8]
int ff_hevc_pred_mode_decode(HEVCContext *s)
struct AVCodecInternal * internal
Private context used for internal data.
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
const uint8_t ff_hevc_diag_scan4x4_x[16]
int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
void ff_hevc_set_qPy(HEVCContext *s, int xC, int yC, int xBase, int yBase, int log2_cb_size)
static const uint8_t diag_scan4x4_inv[4][4]
uint8_t slice_or_tiles_left_boundary
int ff_hevc_last_significant_coeff_suffix_decode(HEVCContext *s, int last_significant_coeff_prefix)
uint8_t long_term_ref_pics_present_flag
static void * av_mallocz_array(size_t nmemb, size_t size)
int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)
static const uint8_t scan_1x1[1]
int ff_hevc_last_significant_coeff_x_prefix_decode(HEVCContext *s, int c_idx, int log2_size)
int diff_cu_qp_delta_depth
int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
int ff_hevc_pcm_flag_decode(HEVCContext *s)
const uint8_t ff_hevc_diag_scan8x8_y[64]
uint8_t context_initialized
int video_signal_type_present_flag
#define FFSWAP(type, a, b)
uint8_t deblocking_filter_override_enabled_flag
int beta_offset
beta_offset_div2 * 2
static const uint8_t horiz_scan2x2_y[4]
static const uint8_t diag_scan2x2_y[4]
int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
static av_cold int hevc_decode_free(AVCodecContext *avctx)
This structure stores compressed data.
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
void(* emulated_edge_mc)(uint8_t *buf, const uint8_t *src, ptrdiff_t buf_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
static const uint8_t diag_scan8x8_inv[8][8]
uint8_t separate_colour_plane_flag
output (i.e. cropped) values
static const AVProfile profiles[]
static void intra_prediction_unit_default_value(HEVCContext *s, int x0, int y0, int log2_cb_size)
#define SAMPLE_CTB(tab, x, y)
uint8_t dependent_slice_segments_enabled_flag
int offset_sign[3][4]
sao_offset_sign