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];
155 if (!luma_weight_l0_flag[i]) {
162 chroma_weight_l0_flag[i] =
get_bits1(gb);
165 chroma_weight_l0_flag[i] = 0;
168 if (luma_weight_l0_flag[i]) {
173 if (chroma_weight_l0_flag[i]) {
174 for (j = 0; j < 2; j++) {
191 if (!luma_weight_l1_flag[i]) {
198 chroma_weight_l1_flag[i] =
get_bits1(gb);
201 chroma_weight_l1_flag[i] = 0;
204 if (luma_weight_l1_flag[i]) {
209 if (chroma_weight_l1_flag[i]) {
210 for (j = 0; j < 2; j++) {
231 int prev_delta_msb = 0;
232 unsigned int nb_sps = 0, nb_sh;
248 for (i = 0; i < rps->
nb_refs; i++) {
265 if (delta_poc_msb_present) {
268 if (i && i != nb_sps)
269 delta += prev_delta_msb;
272 prev_delta_msb =
delta;
287 for (i = 0; frame->
data[i]; i++) {
300 unsigned int num = 0, den = 0;
353 if (num != 0 && den != 0)
420 int slice_address_length;
430 "Invalid slice segment address: %u.\n",
473 int short_term_ref_pic_set_sps_flag, poc;
479 "Ignoring POC change between slices: %d -> %d\n", s->
poc, poc);
486 short_term_ref_pic_set_sps_flag =
get_bits1(gb);
487 if (!short_term_ref_pic_set_sps_flag) {
494 int numbits, rps_idx;
502 rps_idx = numbits > 0 ?
get_bits(gb, numbits) : 0;
603 "Invalid collocated_ref_idx: %d.\n",
618 "Invalid number of merging MVP candidates: %d.\n",
640 int deblocking_filter_override_flag = 0;
643 deblocking_filter_override_flag =
get_bits1(gb);
645 if (deblocking_filter_override_flag) {
680 int segments = offset_len >> 4;
681 int rest = (offset_len & 15);
695 for (j = 0; j < segments; j++) {
720 for (i = 0; i <
length; i++)
729 "The slice_qp %d is outside the valid range "
761 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
763 #define SET_SAO(elem, value) \
765 if (!sao_merge_up_flag && !sao_merge_left_flag) \
767 else if (sao_merge_left_flag) \
768 sao->elem = CTB(s->sao, rx-1, ry).elem; \
769 else if (sao_merge_up_flag) \
770 sao->elem = CTB(s->sao, rx, ry-1).elem; \
778 int sao_merge_left_flag = 0;
779 int sao_merge_up_flag = 0;
789 if (ry > 0 && !sao_merge_left_flag) {
795 for (c_idx = 0; c_idx < 3; c_idx++) {
814 for (i = 0; i < 4; i++)
818 for (i = 0; i < 4; i++) {
827 }
else if (c_idx != 2) {
833 for (i = 0; i < 4; i++) {
841 sao->
offset_val[c_idx][i + 1] <<= log2_sao_offset_scale;
853 if (log2_res_scale_abs_plus1 != 0) {
856 (1 - 2 * res_scale_sign_flag);
866 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
867 int log2_cb_size,
int log2_trafo_size,
868 int blk_idx,
int cbf_luma,
int *cbf_cb,
int *cbf_cr)
871 const int log2_trafo_size_c = log2_trafo_size - s->
sps->
hshift[1];
875 int trafo_size = 1 << log2_trafo_size;
881 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
885 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
887 (cbf_cb[1] || cbf_cr[1]));
899 "The cu_qp_delta %d is outside the valid range "
913 if (cu_chroma_qp_offset_flag) {
914 int cu_chroma_qp_offset_idx = 0;
918 "cu_chroma_qp_offset_idx not yet tested.\n");
952 int trafo_size_h = 1 << (log2_trafo_size_c + s->
sps->
hshift[1]);
953 int trafo_size_v = 1 << (log2_trafo_size_c + s->
sps->
vshift[1]);
964 s->
hpc.
intra_pred[log2_trafo_size_c - 2](
s, x0, y0 + (i << log2_trafo_size_c), 1);
968 log2_trafo_size_c, scan_idx_c, 1);
976 int size = 1 << log2_trafo_size_c;
980 for (i = 0; i < (size *
size); i++) {
993 s->
hpc.
intra_pred[log2_trafo_size_c - 2](
s, x0, y0 + (i << log2_trafo_size_c), 2);
997 log2_trafo_size_c, scan_idx_c, 2);
1005 int size = 1 << log2_trafo_size_c;
1009 for (i = 0; i < (size *
size); i++) {
1015 }
else if (blk_idx == 3) {
1016 int trafo_size_h = 1 << (log2_trafo_size + 1);
1017 int trafo_size_v = 1 << (log2_trafo_size + s->
sps->
vshift[1]);
1021 trafo_size_h, trafo_size_v);
1022 s->
hpc.
intra_pred[log2_trafo_size - 2](
s, xBase, yBase + (i << log2_trafo_size), 1);
1026 log2_trafo_size, scan_idx_c, 1);
1031 trafo_size_h, trafo_size_v);
1032 s->
hpc.
intra_pred[log2_trafo_size - 2](
s, xBase, yBase + (i << log2_trafo_size), 2);
1036 log2_trafo_size, scan_idx_c, 2);
1041 int trafo_size_h = 1 << (log2_trafo_size_c + s->
sps->
hshift[1]);
1042 int trafo_size_v = 1 << (log2_trafo_size_c + s->
sps->
vshift[1]);
1048 trafo_size_h, trafo_size_v);
1049 s->
hpc.
intra_pred[log2_trafo_size_c - 2](
s, x0, y0 + (1 << log2_trafo_size_c), 1);
1050 s->
hpc.
intra_pred[log2_trafo_size_c - 2](
s, x0, y0 + (1 << log2_trafo_size_c), 2);
1052 }
else if (blk_idx == 3) {
1053 int trafo_size_h = 1 << (log2_trafo_size + 1);
1054 int trafo_size_v = 1 << (log2_trafo_size + s->
sps->
vshift[1]);
1056 trafo_size_h, trafo_size_v);
1061 trafo_size_h, trafo_size_v);
1062 s->
hpc.
intra_pred[log2_trafo_size - 2](
s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1063 s->
hpc.
intra_pred[log2_trafo_size - 2](
s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1073 int cb_size = 1 << log2_cb_size;
1081 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1082 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1083 s->
is_pcm[i + j * min_pu_width] = 2;
1087 int xBase,
int yBase,
int cb_xBase,
int cb_yBase,
1088 int log2_cb_size,
int log2_trafo_size,
1089 int trafo_depth,
int blk_idx,
1090 const int *base_cbf_cb,
const int *base_cbf_cr)
1098 cbf_cb[0] = base_cbf_cb[0];
1099 cbf_cb[1] = base_cbf_cb[1];
1100 cbf_cr[0] = base_cbf_cr[0];
1101 cbf_cr[1] = base_cbf_cr[1];
1104 if (trafo_depth == 1) {
1120 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1122 trafo_depth < lc->cu.max_trafo_depth &&
1137 if (trafo_depth == 0 || cbf_cb[0]) {
1144 if (trafo_depth == 0 || cbf_cr[0]) {
1152 if (split_transform_flag) {
1153 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1154 const int x1 = x0 + trafo_size_split;
1155 const int y1 = y0 + trafo_size_split;
1157 #define SUBDIVIDE(x, y, idx) \
1159 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1160 log2_trafo_size - 1, trafo_depth + 1, idx, \
1179 cbf_cb[0] || cbf_cr[0] ||
1185 log2_cb_size, log2_trafo_size,
1186 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1192 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1193 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1194 int x_tu = (x0 + j) >> log2_min_tu_size;
1195 int y_tu = (y0 + i) >> log2_min_tu_size;
1196 s->
cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1213 int cb_size = 1 << log2_cb_size;
1265 int block_w,
int block_h,
int luma_weight,
int luma_offset)
1269 ptrdiff_t srcstride = ref->
linesize[0];
1278 x_off += mv->
x >> 2;
1279 y_off += mv->
y >> 2;
1290 edge_emu_stride, srcstride,
1294 pic_width, pic_height);
1296 srcstride = edge_emu_stride;
1301 block_h, mx, my, block_w);
1305 luma_weight, luma_offset, mx, my, block_w);
1325 AVFrame *ref0,
const Mv *mv0,
int x_off,
int y_off,
1326 int block_w,
int block_h,
AVFrame *ref1,
const Mv *mv1,
struct MvField *current_mv)
1329 ptrdiff_t src0stride = ref0->
linesize[0];
1330 ptrdiff_t src1stride = ref1->
linesize[0];
1333 int mx0 = mv0->
x & 3;
1334 int my0 = mv0->
y & 3;
1335 int mx1 = mv1->
x & 3;
1336 int my1 = mv1->
y & 3;
1339 int x_off0 = x_off + (mv0->
x >> 2);
1340 int y_off0 = y_off + (mv0->
y >> 2);
1341 int x_off1 = x_off + (mv1->
x >> 2);
1342 int y_off1 = y_off + (mv1->
y >> 2);
1356 edge_emu_stride, src0stride,
1360 pic_width, pic_height);
1362 src0stride = edge_emu_stride;
1373 edge_emu_stride, src1stride,
1377 pic_width, pic_height);
1379 src1stride = edge_emu_stride;
1383 block_h, mx0, my0, block_w);
1386 block_h, mx1, my1, block_w);
1416 ptrdiff_t dststride,
uint8_t *src0, ptrdiff_t srcstride,
int reflist,
1417 int x_off,
int y_off,
int block_w,
int block_h,
struct MvField *current_mv,
int chroma_weight,
int chroma_offset)
1422 const Mv *
mv = ¤t_mv->
mv[reflist];
1428 intptr_t mx = mv->
x & ((1 << (2 + hshift)) - 1);
1429 intptr_t my = mv->
y & ((1 << (2 + vshift)) - 1);
1430 intptr_t _mx = mx << (1 - hshift);
1431 intptr_t _my = my << (1 - vshift);
1433 x_off += mv->
x >> (2 + hshift);
1434 y_off += mv->
y >> (2 + vshift);
1445 edge_emu_stride, srcstride,
1449 pic_width, pic_height);
1452 srcstride = edge_emu_stride;
1456 block_h, _mx, _my, block_w);
1460 chroma_weight, chroma_offset, _mx, _my, block_w);
1481 int x_off,
int y_off,
int block_w,
int block_h,
struct MvField *current_mv,
int cidx)
1486 ptrdiff_t src1stride = ref0->
linesize[cidx+1];
1487 ptrdiff_t src2stride = ref1->
linesize[cidx+1];
1492 Mv *mv0 = ¤t_mv->
mv[0];
1493 Mv *mv1 = ¤t_mv->
mv[1];
1497 intptr_t mx0 = mv0->
x & ((1 << (2 + hshift)) - 1);
1498 intptr_t my0 = mv0->
y & ((1 << (2 + vshift)) - 1);
1499 intptr_t mx1 = mv1->
x & ((1 << (2 + hshift)) - 1);
1500 intptr_t my1 = mv1->
y & ((1 << (2 + vshift)) - 1);
1501 intptr_t _mx0 = mx0 << (1 - hshift);
1502 intptr_t _my0 = my0 << (1 - vshift);
1503 intptr_t _mx1 = mx1 << (1 - hshift);
1504 intptr_t _my1 = my1 << (1 - vshift);
1506 int x_off0 = x_off + (mv0->
x >> (2 + hshift));
1507 int y_off0 = y_off + (mv0->
y >> (2 + vshift));
1508 int x_off1 = x_off + (mv1->
x >> (2 + hshift));
1509 int y_off1 = y_off + (mv1->
y >> (2 + vshift));
1511 src1 += y_off0 * src1stride + (int)((
unsigned)x_off0 << s->
sps->
pixel_shift);
1512 src2 += y_off1 * src2stride + (int)((
unsigned)x_off1 << s->
sps->
pixel_shift);
1523 edge_emu_stride, src1stride,
1527 pic_width, pic_height);
1530 src1stride = edge_emu_stride;
1542 edge_emu_stride, src2stride,
1546 pic_width, pic_height);
1549 src2stride = edge_emu_stride;
1553 block_h, _mx0, _my0, block_w);
1556 src2, src2stride, lc->
tmp,
1557 block_h, _mx1, _my1, block_w);
1560 src2, src2stride, lc->
tmp,
1567 _mx1, _my1, block_w);
1573 int y =
FFMAX(0, (mv->
y >> 2) + y0 + height + 9);
1580 int nPbH,
int log2_cb_size,
int part_idx,
1592 if (inter_pred_idc !=
PRED_L1) {
1600 part_idx, merge_idx, mv, mvp_flag, 0);
1605 if (inter_pred_idc !=
PRED_L0) {
1618 part_idx, merge_idx, mv, mvp_flag, 1);
1626 int log2_cb_size,
int partIdx,
int idx)
1628 #define POS(c_idx, x, y) \
1629 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1630 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1633 struct MvField current_mv = {{{ 0 }}};
1645 int x_cb = x0 >> log2_min_cb_size;
1646 int y_cb = y0 >> log2_min_cb_size;
1662 partIdx, merge_idx, ¤t_mv);
1665 partIdx, merge_idx, ¤t_mv);
1673 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1676 ref0 = refPicList[0].
ref[current_mv.
ref_idx[0]];
1682 ref1 = refPicList[1].
ref[current_mv.
ref_idx[1]];
1695 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
1700 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1703 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1712 ¤t_mv.
mv[1], x0, y0, nPbW, nPbH,
1717 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1721 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1730 ¤t_mv.
mv[0], x0, y0, nPbW, nPbH,
1731 ref1->
frame, ¤t_mv.
mv[1], ¤t_mv);
1734 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1737 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1745 int prev_intra_luma_pred_flag)
1763 int intra_pred_mode;
1768 if ((y0 - 1) < y_ctb)
1771 if (cand_left == cand_up) {
1772 if (cand_left < 2) {
1777 candidate[0] = cand_left;
1778 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1779 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1782 candidate[0] = cand_left;
1783 candidate[1] = cand_up;
1793 if (prev_intra_luma_pred_flag) {
1794 intra_pred_mode = candidate[lc->
pu.
mpm_idx];
1796 if (candidate[0] > candidate[1])
1798 if (candidate[0] > candidate[2])
1800 if (candidate[1] > candidate[2])
1804 for (i = 0; i < 3; i++)
1805 if (intra_pred_mode >= candidate[i])
1812 for (i = 0; i < size_in_pus; i++) {
1813 memset(&s->
tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1814 intra_pred_mode, size_in_pus);
1816 for (j = 0; j < size_in_pus; j++) {
1821 return intra_pred_mode;
1825 int log2_cb_size,
int ct_depth)
1838 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1839 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1845 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1846 uint8_t prev_intra_luma_pred_flag[4];
1848 int pb_size = (1 << log2_cb_size) >> split;
1849 int side = split + 1;
1853 for (i = 0; i < side; i++)
1854 for (j = 0; j < side; j++)
1857 for (i = 0; i < side; i++) {
1858 for (j = 0; j < side; j++) {
1859 if (prev_intra_luma_pred_flag[2 * i + j])
1866 prev_intra_luma_pred_flag[2 * i + j]);
1871 for (i = 0; i < side; i++) {
1872 for (j = 0; j < side; j++) {
1874 if (chroma_mode != 4) {
1887 if (chroma_mode != 4) {
1891 mode_idx = intra_chroma_table[chroma_mode];
1898 if (chroma_mode != 4) {
1914 int pb_size = 1 << log2_cb_size;
1922 if (size_in_pus == 0)
1924 for (j = 0; j < size_in_pus; j++)
1925 memset(&s->
tab_ipm[(y_pu + j) * min_pu_width + x_pu],
INTRA_DC, size_in_pus);
1927 for (j = 0; j < size_in_pus; j++)
1928 for (k = 0; k < size_in_pus; k++)
1934 int cb_size = 1 << log2_cb_size;
1937 int length = cb_size >> log2_min_cb_size;
1939 int x_cb = x0 >> log2_min_cb_size;
1940 int y_cb = y0 >> log2_min_cb_size;
1941 int idx = log2_cb_size - 2;
1952 for (x = 0; x < 4; x++)
1964 x = y_cb * min_cb_width + x_cb;
1965 for (y = 0; y <
length; y++) {
1966 memset(&s->
skip_flag[x], skip_flag, length);
1971 x = y_cb * min_cb_width + x_cb;
1972 for (y = 0; y <
length; y++) {
1999 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2025 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2029 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2033 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2037 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2041 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2045 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2046 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2047 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2053 int rqt_root_cbf = 1;
2060 const static int cbf[2] = { 0 };
2066 log2_cb_size, 0, 0, cbf, cbf);
2079 x = y_cb * min_cb_width + x_cb;
2080 for (y = 0; y <
length; y++) {
2085 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2086 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2096 int log2_cb_size,
int cb_depth)
2099 const int cb_size = 1 << log2_cb_size;
2105 if (x0 + cb_size <= s->sps->width &&
2106 y0 + cb_size <= s->sps->height &&
2124 const int cb_size_split = cb_size >> 1;
2125 const int x1 = x0 + cb_size_split;
2126 const int y1 = y0 + cb_size_split;
2134 if (more_data && x1 < s->sps->width) {
2139 if (more_data && y1 < s->sps->height) {
2144 if (more_data && x1 < s->sps->width &&
2145 y1 < s->sps->height) {
2151 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2152 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2156 return ((x1 + cb_size_split) < s->
sps->
width ||
2164 if ((!((x0 + cb_size) %
2166 (x0 + cb_size >= s->
sps->
width)) &&
2171 return !end_of_slice_flag;
2186 int ctb_addr_in_slice = ctb_addr_rs - s->
sh.
slice_addr;
2191 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2217 if (!ctb_addr_in_slice > 0)
2219 if (ctb_addr_in_slice < s->sps->ctb_width)
2251 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2267 if (more_data < 0) {
2278 if (x_ctb + ctb_size >= s->
sps->
width &&
2302 int *ctb_row_p = input_ctb_row;
2303 int ctb_row = ctb_row_p[job];
2313 ret =
init_get_bits8(&lc->
gb,
s->data +
s->sh.offset[ctb_row - 1],
s->sh.size[ctb_row - 1]);
2320 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2321 int x_ctb = (ctb_addr_rs %
s->sps->ctb_width) <<
s->sps->log2_ctb_size;
2322 int y_ctb = (ctb_addr_rs /
s->sps->ctb_width) <<
s->sps->log2_ctb_size;
2334 hls_sao_param(
s, x_ctb >>
s->sps->log2_ctb_size, y_ctb >>
s->sps->log2_ctb_size);
2337 if (more_data < 0) {
2338 s->tab_slice_address[ctb_addr_rs] = -1;
2348 if (!more_data && (x_ctb+ctb_size) <
s->sps->width && ctb_row !=
s->sh.num_entry_point_offsets) {
2354 if ((x_ctb+ctb_size) >=
s->sps->width && (y_ctb+ctb_size) >=
s->sps->height ) {
2359 ctb_addr_rs =
s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2362 if(x_ctb >=
s->sps->width) {
2377 int startheader, cmpt = 0;
2395 for (j = 0, cmpt = 0, startheader = offset + s->
sh.
entry_point_offset[0]; j < s->skipped_bytes; j++) {
2404 for (j = 0, cmpt = 0, startheader = offset
2468 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2471 return nuh_layer_id == 0;
2583 int ctb_addr_ts,
ret;
2639 if (s->
max_ra == INT_MAX) {
2661 }
else if (!s->
ref) {
2668 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2678 "Error constructing the reference lists for the current slice.\n");
2691 if (ctb_addr_ts < 0) {
2725 #define STARTCODE_TEST \
2726 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2727 if (src[i + 2] != 3) { \
2733 #if HAVE_FAST_UNALIGNED
2734 #define FIND_FIRST_ZERO \
2735 if (i > 0 && !src[i]) \
2740 for (i = 0; i + 1 <
length; i += 9) {
2742 (
AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2743 0x8000800080008080ULL))
2750 for (i = 0; i + 1 <
length; i += 5) {
2752 (
AV_RN32A(src + i) - 0x01000101U)) &
2761 for (i = 0; i + 1 <
length; i += 2) {
2764 if (i > 0 && src[i - 1] == 0)
2770 if (i >= length - 1) {
2783 memcpy(dst, src, i);
2785 while (si + 2 < length) {
2787 if (src[si + 2] > 3) {
2788 dst[di++] = src[si++];
2789 dst[di++] = src[si++];
2790 }
else if (src[si] == 0 && src[si + 1] == 0) {
2791 if (src[si + 2] == 3) {
2812 dst[di++] = src[si++];
2815 dst[di++] = src[si++];
2827 int i, consumed,
ret = 0;
2836 while (length >= 4) {
2838 int extract_length = 0;
2843 extract_length = (extract_length << 8) | buf[i];
2847 if (extract_length > length) {
2854 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2918 for (i = 0; i < s->
nb_nals; i++) {
2926 "Error parsing NAL unit #%d.\n", i);
2941 for (i = 0; i < 16; i++)
2942 av_log(log_ctx, level,
"%02"PRIx8, md5[i]);
2971 for (i = 0; frame->
data[i]; i++) {
2979 for (j = 0; j < h; j++) {
2984 (
const uint16_t *) src, w);
2992 if (!memcmp(md5, s->
md5[i], 16)) {
3297 int i, j, num_arrays, nal_len_size;
3302 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3303 num_arrays = bytestream2_get_byte(&gb);
3310 for (i = 0; i < num_arrays; i++) {
3311 int type = bytestream2_get_byte(&gb) & 0x3f;
3312 int cnt = bytestream2_get_be16(&gb);
3314 for (j = 0; j < cnt; j++) {
3316 int nalsize = bytestream2_peek_be16(&gb) + 2;
3319 "Invalid NAL unit size in extradata.\n");
3326 "Decoding nal unit %d %d from hvcC failed\n",
3388 memset(s, 0,
sizeof(*s));
3404 #define OFFSET(x) offsetof(HEVCContext, x)
3405 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3416 {
"apply_defdispwin",
"Apply default display window from VUI",
OFFSET(apply_defdispwin),
3418 {
"strict-displaywin",
"stricly apply default display window size",
OFFSET(apply_defdispwin),
3436 .priv_class = &hevc_decoder_class,