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,