42 const uint8_t ff_hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
87 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
88 ((height >> log2_min_cb_size) + 1);
142 uint8_t luma_weight_l0_flag[16];
143 uint8_t chroma_weight_l0_flag[16];
144 uint8_t luma_weight_l1_flag[16];
145 uint8_t chroma_weight_l1_flag[16];
146 int luma_log2_weight_denom;
149 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7)
159 if (!luma_weight_l0_flag[i]) {
166 chroma_weight_l0_flag[i] =
get_bits1(gb);
169 chroma_weight_l0_flag[i] = 0;
172 if (luma_weight_l0_flag[i]) {
177 if (chroma_weight_l0_flag[i]) {
178 for (j = 0; j < 2; j++) {
195 if (!luma_weight_l1_flag[i]) {
202 chroma_weight_l1_flag[i] =
get_bits1(gb);
205 chroma_weight_l1_flag[i] = 0;
208 if (luma_weight_l1_flag[i]) {
213 if (chroma_weight_l1_flag[i]) {
214 for (j = 0; j < 2; j++) {
235 int prev_delta_msb = 0;
236 unsigned int nb_sps = 0, nb_sh;
252 for (i = 0; i < rps->
nb_refs; i++) {
269 if (delta_poc_msb_present) {
272 if (i && i != nb_sps)
273 delta += prev_delta_msb;
276 prev_delta_msb =
delta;
285 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL)
288 unsigned int num = 0, den = 0;
302 #if CONFIG_HEVC_DXVA2_HWACCEL
337 for (i = 0; i < 3; i++) {
346 for(c_idx = 0; c_idx < c_count; c_idx++) {
369 if (num != 0 && den != 0)
436 int slice_address_length;
446 "Invalid slice segment address: %u.\n",
495 "Ignoring POC change between slices: %d -> %d\n", s->
poc, poc);
512 int numbits, rps_idx;
520 rps_idx = numbits > 0 ?
get_bits(gb, numbits) : 0;
623 "Invalid collocated_ref_idx: %d.\n",
638 "Invalid number of merging MVP candidates: %d.\n",
660 int deblocking_filter_override_flag = 0;
663 deblocking_filter_override_flag =
get_bits1(gb);
665 if (deblocking_filter_override_flag) {
707 int segments = offset_len >> 4;
708 int rest = (offset_len & 15);
710 if (offset_len < 1 || offset_len > 32) {
729 for (j = 0; j < segments; j++) {
754 for (i = 0; i <
length; i++)
763 "The slice_qp %d is outside the valid range "
797 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
799 #define SET_SAO(elem, value) \
801 if (!sao_merge_up_flag && !sao_merge_left_flag) \
803 else if (sao_merge_left_flag) \
804 sao->elem = CTB(s->sao, rx-1, ry).elem; \
805 else if (sao_merge_up_flag) \
806 sao->elem = CTB(s->sao, rx, ry-1).elem; \
814 int sao_merge_left_flag = 0;
815 int sao_merge_up_flag = 0;
825 if (ry > 0 && !sao_merge_left_flag) {
850 for (i = 0; i < 4; i++)
854 for (i = 0; i < 4; i++) {
863 }
else if (c_idx != 2) {
869 for (i = 0; i < 4; i++) {
877 sao->
offset_val[c_idx][i + 1] <<= log2_sao_offset_scale;
889 if (log2_res_scale_abs_plus1 != 0) {
892 (1 - 2 * res_scale_sign_flag);
902 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
903 int log2_cb_size,
int log2_trafo_size,
904 int blk_idx,
int cbf_luma,
int *cbf_cb,
int *cbf_cr)
907 const int log2_trafo_size_c = log2_trafo_size - s->
sps->
hshift[1];
911 int trafo_size = 1 << log2_trafo_size;
917 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
921 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
923 (cbf_cb[1] || cbf_cr[1]));
935 "The cu_qp_delta %d is outside the valid range "
949 if (cu_chroma_qp_offset_flag) {
950 int cu_chroma_qp_offset_idx = 0;
954 "cu_chroma_qp_offset_idx not yet tested.\n");
988 int trafo_size_h = 1 << (log2_trafo_size_c + s->
sps->
hshift[1]);
989 int trafo_size_v = 1 << (log2_trafo_size_c + s->
sps->
vshift[1]);
1000 s->
hpc.
intra_pred[log2_trafo_size_c - 2](
s, x0, y0 + (i << log2_trafo_size_c), 1);
1004 log2_trafo_size_c, scan_idx_c, 1);
1012 int size = 1 << log2_trafo_size_c;
1016 for (i = 0; i < (size *
size); i++) {
1029 s->
hpc.
intra_pred[log2_trafo_size_c - 2](
s, x0, y0 + (i << log2_trafo_size_c), 2);
1033 log2_trafo_size_c, scan_idx_c, 2);
1041 int size = 1 << log2_trafo_size_c;
1045 for (i = 0; i < (size *
size); i++) {
1052 int trafo_size_h = 1 << (log2_trafo_size + 1);
1053 int trafo_size_v = 1 << (log2_trafo_size + s->
sps->
vshift[1]);
1057 trafo_size_h, trafo_size_v);
1058 s->
hpc.
intra_pred[log2_trafo_size - 2](
s, xBase, yBase + (i << log2_trafo_size), 1);
1062 log2_trafo_size, scan_idx_c, 1);
1067 trafo_size_h, trafo_size_v);
1068 s->
hpc.
intra_pred[log2_trafo_size - 2](
s, xBase, yBase + (i << log2_trafo_size), 2);
1072 log2_trafo_size, scan_idx_c, 2);
1077 int trafo_size_h = 1 << (log2_trafo_size_c + s->
sps->
hshift[1]);
1078 int trafo_size_v = 1 << (log2_trafo_size_c + s->
sps->
vshift[1]);
1084 trafo_size_h, trafo_size_v);
1085 s->
hpc.
intra_pred[log2_trafo_size_c - 2](
s, x0, y0 + (1 << log2_trafo_size_c), 1);
1086 s->
hpc.
intra_pred[log2_trafo_size_c - 2](
s, x0, y0 + (1 << log2_trafo_size_c), 2);
1088 }
else if (blk_idx == 3) {
1089 int trafo_size_h = 1 << (log2_trafo_size + 1);
1090 int trafo_size_v = 1 << (log2_trafo_size + s->
sps->
vshift[1]);
1092 trafo_size_h, trafo_size_v);
1097 trafo_size_h, trafo_size_v);
1098 s->
hpc.
intra_pred[log2_trafo_size - 2](
s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1099 s->
hpc.
intra_pred[log2_trafo_size - 2](
s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1109 int cb_size = 1 << log2_cb_size;
1117 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1118 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1119 s->
is_pcm[i + j * min_pu_width] = 2;
1123 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1124 int log2_cb_size,
int log2_trafo_size,
1125 int trafo_depth,
int blk_idx,
1126 const int *base_cbf_cb,
const int *base_cbf_cr)
1134 cbf_cb[0] = base_cbf_cb[0];
1135 cbf_cb[1] = base_cbf_cb[1];
1136 cbf_cr[0] = base_cbf_cr[0];
1137 cbf_cr[1] = base_cbf_cr[1];
1140 if (trafo_depth == 1) {
1156 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1158 trafo_depth < lc->cu.max_trafo_depth &&
1173 if (trafo_depth == 0 || cbf_cb[0]) {
1180 if (trafo_depth == 0 || cbf_cr[0]) {
1188 if (split_transform_flag) {
1189 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1190 const int x1 = x0 + trafo_size_split;
1191 const int y1 = y0 + trafo_size_split;
1193 #define SUBDIVIDE(x, y, idx) \
1195 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1196 log2_trafo_size - 1, trafo_depth + 1, idx, \
1215 cbf_cb[0] || cbf_cr[0] ||
1221 log2_cb_size, log2_trafo_size,
1222 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1228 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1229 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1230 int x_tu = (x0 + j) >> log2_min_tu_size;
1231 int y_tu = (y0 + i) >> log2_min_tu_size;
1232 s->
cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1249 int cb_size = 1 << log2_cb_size;
1304 int block_w,
int block_h,
int luma_weight,
int luma_offset)
1308 ptrdiff_t srcstride = ref->
linesize[0];
1317 x_off += mv->
x >> 2;
1318 y_off += mv->
y >> 2;
1329 edge_emu_stride, srcstride,
1333 pic_width, pic_height);
1335 srcstride = edge_emu_stride;
1340 block_h, mx, my, block_w);
1344 luma_weight, luma_offset, mx, my, block_w);
1364 AVFrame *ref0,
const Mv *mv0,
int x_off,
int y_off,
1365 int block_w,
int block_h,
AVFrame *ref1,
const Mv *mv1,
struct MvField *current_mv)
1368 ptrdiff_t src0stride = ref0->
linesize[0];
1369 ptrdiff_t src1stride = ref1->
linesize[0];
1372 int mx0 = mv0->
x & 3;
1373 int my0 = mv0->
y & 3;
1374 int mx1 = mv1->
x & 3;
1375 int my1 = mv1->
y & 3;
1378 int x_off0 = x_off + (mv0->
x >> 2);
1379 int y_off0 = y_off + (mv0->
y >> 2);
1380 int x_off1 = x_off + (mv1->
x >> 2);
1381 int y_off1 = y_off + (mv1->
y >> 2);
1395 edge_emu_stride, src0stride,
1399 pic_width, pic_height);
1401 src0stride = edge_emu_stride;
1412 edge_emu_stride, src1stride,
1416 pic_width, pic_height);
1418 src1stride = edge_emu_stride;
1422 block_h, mx0, my0, block_w);
1425 block_h, mx1, my1, block_w);
1455 ptrdiff_t dststride,
uint8_t *src0, ptrdiff_t srcstride,
int reflist,
1456 int x_off,
int y_off,
int block_w,
int block_h,
struct MvField *current_mv,
int chroma_weight,
int chroma_offset)
1461 const Mv *
mv = ¤t_mv->
mv[reflist];
1467 intptr_t mx = mv->
x & ((1 << (2 + hshift)) - 1);
1468 intptr_t my = mv->
y & ((1 << (2 + vshift)) - 1);
1469 intptr_t _mx = mx << (1 - hshift);
1470 intptr_t _my = my << (1 - vshift);
1472 x_off += mv->
x >> (2 + hshift);
1473 y_off += mv->
y >> (2 + vshift);
1484 edge_emu_stride, srcstride,
1488 pic_width, pic_height);
1491 srcstride = edge_emu_stride;
1495 block_h, _mx, _my, block_w);
1499 chroma_weight, chroma_offset, _mx, _my, block_w);
1520 int x_off,
int y_off,
int block_w,
int block_h,
struct MvField *current_mv,
int cidx)
1525 ptrdiff_t src1stride = ref0->
linesize[cidx+1];
1526 ptrdiff_t src2stride = ref1->
linesize[cidx+1];
1531 Mv *mv0 = ¤t_mv->
mv[0];
1532 Mv *mv1 = ¤t_mv->
mv[1];
1536 intptr_t mx0 = mv0->
x & ((1 << (2 + hshift)) - 1);
1537 intptr_t my0 = mv0->
y & ((1 << (2 + vshift)) - 1);
1538 intptr_t mx1 = mv1->
x & ((1 << (2 + hshift)) - 1);
1539 intptr_t my1 = mv1->
y & ((1 << (2 + vshift)) - 1);
1540 intptr_t _mx0 = mx0 << (1 - hshift);
1541 intptr_t _my0 = my0 << (1 - vshift);
1542 intptr_t _mx1 = mx1 << (1 - hshift);
1543 intptr_t _my1 = my1 << (1 - vshift);
1545 int x_off0 = x_off + (mv0->
x >> (2 + hshift));
1546 int y_off0 = y_off + (mv0->
y >> (2 + vshift));
1547 int x_off1 = x_off + (mv1->
x >> (2 + hshift));
1548 int y_off1 = y_off + (mv1->
y >> (2 + vshift));
1550 src1 += y_off0 * src1stride + (int)((
unsigned)x_off0 << s->
sps->
pixel_shift);
1551 src2 += y_off1 * src2stride + (int)((
unsigned)x_off1 << s->
sps->
pixel_shift);
1562 edge_emu_stride, src1stride,
1566 pic_width, pic_height);
1569 src1stride = edge_emu_stride;
1581 edge_emu_stride, src2stride,
1585 pic_width, pic_height);
1588 src2stride = edge_emu_stride;
1592 block_h, _mx0, _my0, block_w);
1595 src2, src2stride, lc->
tmp,
1596 block_h, _mx1, _my1, block_w);
1599 src2, src2stride, lc->
tmp,
1606 _mx1, _my1, block_w);
1612 int y =
FFMAX(0, (mv->
y >> 2) + y0 + height + 9);
1619 int nPbH,
int log2_cb_size,
int part_idx,
1631 if (inter_pred_idc !=
PRED_L1) {
1639 part_idx, merge_idx, mv, mvp_flag, 0);
1644 if (inter_pred_idc !=
PRED_L0) {
1657 part_idx, merge_idx, mv, mvp_flag, 1);
1665 int log2_cb_size,
int partIdx,
int idx)
1667 #define POS(c_idx, x, y) \
1668 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1669 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1672 struct MvField current_mv = {{{ 0 }}};
1684 int x_cb = x0 >> log2_min_cb_size;
1685 int y_cb = y0 >> log2_min_cb_size;
1701 partIdx, merge_idx, ¤t_mv);
1704 partIdx, merge_idx, ¤t_mv);
1712 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1715 ref0 = refPicList[0].
ref[current_mv.
ref_idx[0]];
1721 ref1 = refPicList[1].
ref[current_mv.
ref_idx[1]];
1734 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
1740 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1743 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1753 ¤t_mv.
mv[1], x0, y0, nPbW, nPbH,
1759 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1763 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1773 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
1774 ref1->frame, ¤t_mv.
mv[1], ¤t_mv);
1778 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1781 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1790 int prev_intra_luma_pred_flag)
1808 int intra_pred_mode;
1813 if ((y0 - 1) < y_ctb)
1816 if (cand_left == cand_up) {
1817 if (cand_left < 2) {
1822 candidate[0] = cand_left;
1823 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1824 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1827 candidate[0] = cand_left;
1828 candidate[1] = cand_up;
1838 if (prev_intra_luma_pred_flag) {
1839 intra_pred_mode = candidate[lc->
pu.
mpm_idx];
1841 if (candidate[0] > candidate[1])
1843 if (candidate[0] > candidate[2])
1845 if (candidate[1] > candidate[2])
1849 for (i = 0; i < 3; i++)
1850 if (intra_pred_mode >= candidate[i])
1857 for (i = 0; i < size_in_pus; i++) {
1858 memset(&s->
tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1859 intra_pred_mode, size_in_pus);
1861 for (j = 0; j < size_in_pus; j++) {
1866 return intra_pred_mode;
1870 int log2_cb_size,
int ct_depth)
1883 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1884 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1890 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1891 uint8_t prev_intra_luma_pred_flag[4];
1893 int pb_size = (1 << log2_cb_size) >> split;
1894 int side = split + 1;
1898 for (i = 0; i < side; i++)
1899 for (j = 0; j < side; j++)
1902 for (i = 0; i < side; i++) {
1903 for (j = 0; j < side; j++) {
1904 if (prev_intra_luma_pred_flag[2 * i + j])
1911 prev_intra_luma_pred_flag[2 * i + j]);
1916 for (i = 0; i < side; i++) {
1917 for (j = 0; j < side; j++) {
1919 if (chroma_mode != 4) {
1932 if (chroma_mode != 4) {
1936 mode_idx = intra_chroma_table[chroma_mode];
1943 if (chroma_mode != 4) {
1959 int pb_size = 1 << log2_cb_size;
1967 if (size_in_pus == 0)
1969 for (j = 0; j < size_in_pus; j++)
1970 memset(&s->
tab_ipm[(y_pu + j) * min_pu_width + x_pu],
INTRA_DC, size_in_pus);
1972 for (j = 0; j < size_in_pus; j++)
1973 for (k = 0; k < size_in_pus; k++)
1979 int cb_size = 1 << log2_cb_size;
1982 int length = cb_size >> log2_min_cb_size;
1984 int x_cb = x0 >> log2_min_cb_size;
1985 int y_cb = y0 >> log2_min_cb_size;
1986 int idx = log2_cb_size - 2;
1997 for (x = 0; x < 4; x++)
2009 x = y_cb * min_cb_width + x_cb;
2010 for (y = 0; y <
length; y++) {
2011 memset(&s->
skip_flag[x], skip_flag, length);
2016 x = y_cb * min_cb_width + x_cb;
2017 for (y = 0; y <
length; y++) {
2044 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2070 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2074 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2078 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2082 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2086 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2090 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2091 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2092 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2098 int rqt_root_cbf = 1;
2105 const static int cbf[2] = { 0 };
2111 log2_cb_size, 0, 0, cbf, cbf);
2124 x = y_cb * min_cb_width + x_cb;
2125 for (y = 0; y <
length; y++) {
2130 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2131 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2141 int log2_cb_size,
int cb_depth)
2144 const int cb_size = 1 << log2_cb_size;
2149 if (x0 + cb_size <= s->sps->width &&
2150 y0 + cb_size <= s->sps->height &&
2169 const int cb_size_split = cb_size >> 1;
2170 const int x1 = x0 + cb_size_split;
2171 const int y1 = y0 + cb_size_split;
2179 if (more_data && x1 < s->sps->width) {
2184 if (more_data && y1 < s->sps->height) {
2189 if (more_data && x1 < s->sps->width &&
2190 y1 < s->sps->height) {
2196 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2197 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2201 return ((x1 + cb_size_split) < s->
sps->
width ||
2209 if ((!((x0 + cb_size) %
2211 (x0 + cb_size >= s->
sps->
width)) &&
2216 return !end_of_slice_flag;
2231 int ctb_addr_in_slice = ctb_addr_rs - s->
sh.
slice_addr;
2236 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2262 if (!ctb_addr_in_slice > 0)
2264 if (ctb_addr_in_slice < s->sps->ctb_width)
2296 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2312 if (more_data < 0) {
2323 if (x_ctb + ctb_size >= s->
sps->
width &&
2347 int *ctb_row_p = input_ctb_row;
2348 int ctb_row = ctb_row_p[job];
2358 ret =
init_get_bits8(&lc->
gb,
s->data +
s->sh.offset[ctb_row - 1],
s->sh.size[ctb_row - 1]);
2365 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2366 int x_ctb = (ctb_addr_rs %
s->sps->ctb_width) <<
s->sps->log2_ctb_size;
2367 int y_ctb = (ctb_addr_rs /
s->sps->ctb_width) <<
s->sps->log2_ctb_size;
2379 hls_sao_param(
s, x_ctb >>
s->sps->log2_ctb_size, y_ctb >>
s->sps->log2_ctb_size);
2382 if (more_data < 0) {
2383 s->tab_slice_address[ctb_addr_rs] = -1;
2395 if (!more_data && (x_ctb+ctb_size) <
s->sps->width && ctb_row !=
s->sh.num_entry_point_offsets) {
2401 if ((x_ctb+ctb_size) >=
s->sps->width && (y_ctb+ctb_size) >=
s->sps->height ) {
2406 ctb_addr_rs =
s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2409 if(x_ctb >=
s->sps->width) {
2424 int64_t startheader, cmpt = 0;
2455 for (j = 0, cmpt = 0, startheader = offset + s->
sh.
entry_point_offset[0]; j < s->skipped_bytes; j++) {
2464 for (j = 0, cmpt = 0, startheader = offset
2477 if (length < offset) {
2534 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2537 return nuh_layer_id == 0;
2650 int ctb_addr_ts,
ret;
2706 if (s->
max_ra == INT_MAX) {
2728 }
else if (!s->
ref) {
2735 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2745 "Error constructing the reference lists for the current slice.\n");
2769 if (ctb_addr_ts < 0) {
2804 #define STARTCODE_TEST \
2805 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2806 if (src[i + 2] != 3) { \
2812 #if HAVE_FAST_UNALIGNED
2813 #define FIND_FIRST_ZERO \
2814 if (i > 0 && !src[i]) \
2819 for (i = 0; i + 1 <
length; i += 9) {
2821 (
AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2822 0x8000800080008080ULL))
2829 for (i = 0; i + 1 <
length; i += 5) {
2831 (
AV_RN32A(src + i) - 0x01000101U)) &
2840 for (i = 0; i + 1 <
length; i += 2) {
2843 if (i > 0 && src[i - 1] == 0)
2849 if (i >= length - 1) {
2864 memcpy(dst, src, i);
2866 while (si + 2 < length) {
2868 if (src[si + 2] > 3) {
2869 dst[di++] = src[si++];
2870 dst[di++] = src[si++];
2871 }
else if (src[si] == 0 && src[si + 1] == 0) {
2872 if (src[si + 2] == 3) {
2893 dst[di++] = src[si++];
2896 dst[di++] = src[si++];
2910 int i, consumed,
ret = 0;
2919 while (length >= 4) {
2921 int extract_length = 0;
2926 extract_length = (extract_length << 8) | buf[i];
2930 if (extract_length > length) {
2937 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
3016 for (i = 0; i < s->
nb_nals; i++) {
3023 "Error parsing NAL unit #%d.\n", i);
3038 for (i = 0; i < 16; i++)
3039 av_log(log_ctx, level,
"%02"PRIx8, md5[i]);
3068 for (i = 0; frame->
data[i]; i++) {
3076 for (j = 0; j < h; j++) {
3081 (
const uint16_t *) src, w);
3089 if (!memcmp(md5, s->
md5[i], 16)) {
3131 "hardware accelerator failed to decode picture\n");
3217 for (i = 0; i < 3; i++) {
3407 int i, j, num_arrays, nal_len_size;
3412 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3413 num_arrays = bytestream2_get_byte(&gb);
3420 for (i = 0; i < num_arrays; i++) {
3421 int type = bytestream2_get_byte(&gb) & 0x3f;
3422 int cnt = bytestream2_get_be16(&gb);
3424 for (j = 0; j < cnt; j++) {
3426 int nalsize = bytestream2_peek_be16(&gb) + 2;
3429 "Invalid NAL unit size in extradata.\n");
3436 "Decoding nal unit %d %d from hvcC failed\n",
3499 memset(s, 0,
sizeof(*s));
3516 #define OFFSET(x) offsetof(HEVCContext, x)
3517 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3528 {
"apply_defdispwin",
"Apply default display window from VUI",
OFFSET(apply_defdispwin),
3530 {
"strict-displaywin",
"stricly apply default display window size",
OFFSET(apply_defdispwin),
3548 .priv_class = &hevc_decoder_class,