28 #define UNCHECKED_BITSTREAM_READER 1
54 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
55 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
56 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
57 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
62 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
63 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
64 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10,
65 10,10,10,11,11,11,11,11,11,12,12,12,12,12,12,13,13,13, 13, 13, 13,
90 static const int8_t top[12] = {
93 static const int8_t left[12] = {
99 for (i = 0; i < 4; i++) {
103 "top block unavailable for requested intra4x4 mode %d at %d %d\n",
113 static const int mask[4] = { 0x8000, 0x2000, 0x80, 0x20 };
114 for (i = 0; i < 4; i++)
119 "left block unavailable for requested intra4x4 mode %d at %d %d\n",
143 "out of range intra chroma pred mode at %d %d\n",
152 "top block unavailable for requested intra mode at %d %d\n",
168 "left block unavailable for requested intra mode at %d %d\n",
178 int *dst_length,
int *consumed,
int length)
191 #define STARTCODE_TEST \
192 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
193 if (src[i + 2] != 3) { \
199 #if HAVE_FAST_UNALIGNED
200 #define FIND_FIRST_ZERO \
201 if (i > 0 && !src[i]) \
206 for (i = 0; i + 1 < length; i += 9) {
208 (
AV_RN64A(src + i) - 0x0100010001000101ULL)) &
209 0x8000800080008080ULL))
216 for (i = 0; i + 1 < length; i += 5) {
218 (
AV_RN32A(src + i) - 0x01000101U)) &
227 for (i = 0; i + 1 < length; i += 2) {
230 if (i > 0 && src[i - 1] == 0)
252 memcpy(dst, src, length);
259 while (si + 2 < length) {
261 if (src[si + 2] > 3) {
262 dst[di++] = src[si++];
263 dst[di++] = src[si++];
264 }
else if (src[si] == 0 && src[si + 1] == 0) {
265 if (src[si + 2] == 3) {
274 dst[di++] = src[si++];
277 dst[di++] = src[si++];
300 for (r = 1; r < 9; r++) {
309 int height,
int y_offset,
int list)
312 int filter_height_up = (raw_my & 3) ? 2 : 0;
313 int filter_height_down = (raw_my & 3) ? 3 : 0;
314 int full_my = (raw_my >> 2) + y_offset;
315 int top = full_my - filter_height_up;
316 int bottom = full_my + filter_height_down +
height;
318 return FFMAX(abs(top), bottom);
322 int height,
int y_offset,
int list0,
323 int list1,
int *nrefs)
340 if (refs[0][ref_n] < 0)
342 refs[0][ref_n] =
FFMAX(refs[0][ref_n], my);
353 if (refs[1][ref_n] < 0)
355 refs[1][ref_n] =
FFMAX(refs[1][ref_n], my);
368 const int mb_xy = h->
mb_xy;
371 int nrefs[2] = { 0 };
374 memset(refs, -1,
sizeof(refs));
394 for (i = 0; i < 4; i++) {
397 int y_offset = (i & 2) << 2;
401 IS_DIR(sub_mb_type, 0, 0),
402 IS_DIR(sub_mb_type, 0, 1),
406 IS_DIR(sub_mb_type, 0, 0),
407 IS_DIR(sub_mb_type, 0, 1),
410 IS_DIR(sub_mb_type, 0, 0),
411 IS_DIR(sub_mb_type, 0, 1),
415 IS_DIR(sub_mb_type, 0, 0),
416 IS_DIR(sub_mb_type, 0, 1),
419 IS_DIR(sub_mb_type, 0, 0),
420 IS_DIR(sub_mb_type, 0, 1),
425 for (j = 0; j < 4; j++) {
426 int sub_y_offset = y_offset + 2 * (j & 2);
428 IS_DIR(sub_mb_type, 0, 0),
429 IS_DIR(sub_mb_type, 0, 1),
436 for (list = h->
list_count - 1; list >= 0; list--)
437 for (ref = 0; ref < 48 && nrefs[list]; ref++) {
438 int row = refs[list][ref];
443 int pic_height = 16 * s->
mb_height >> ref_field_picture;
450 FFMIN((row >> 1) - !(row & 1),
454 FFMIN((row >> 1), pic_height - 1),
458 FFMIN(row * 2 + ref_field,
463 FFMIN(row, pic_height - 1),
467 FFMIN(row, pic_height - 1),
479 int src_x_offset,
int src_y_offset,
482 int pixel_shift,
int chroma_idc)
485 const int mx = h->
mv_cache[list][
scan8[n]][0] + src_x_offset * 8;
487 const int luma_xy = (mx & 3) + ((my & 3) << 2);
494 const int full_mx = mx >> 2;
495 const int full_my = my >> 2;
496 const int pic_width = 16 * s->
mb_width;
505 if (full_mx < 0 - extra_width ||
506 full_my < 0 - extra_height ||
507 full_mx + 16 > pic_width + extra_width ||
508 full_my + 16 > pic_height + extra_height) {
512 16 + 5, 16 + 5 , full_mx - 2,
513 full_my - 2, pic_width, pic_height);
525 if (chroma_idc == 3 ) {
532 full_mx - 2, full_my - 2,
533 pic_width, pic_height);
546 full_mx - 2, full_my - 2,
547 pic_width, pic_height);
556 ysh = 3 - (chroma_idc == 2 );
560 emu |= (my >> 3) < 0 || (my >> 3) + 8 >= (pic_height >> 1);
563 src_cb = pic->
f.
data[1] + ((mx >> 3) << pixel_shift) +
565 src_cr = pic->
f.
data[2] + ((mx >> 3) << pixel_shift) +
570 9, 8 * chroma_idc + 1, (mx >> 3), (my >> ysh),
571 pic_width >> 1, pic_height >> (chroma_idc == 1 ));
575 height >> (chroma_idc == 1 ),
576 mx & 7, (my << (chroma_idc == 2 )) & 7);
580 9, 8 * chroma_idc + 1, (mx >> 3), (my >> ysh),
581 pic_width >> 1, pic_height >> (chroma_idc == 1 ));
584 chroma_op(dest_cr, src_cr, h->
mb_uvlinesize, height >> (chroma_idc == 1 ),
585 mx & 7, (my << (chroma_idc == 2 )) & 7);
592 int x_offset,
int y_offset,
597 int list0,
int list1,
598 int pixel_shift,
int chroma_idc)
604 dest_y += (2 * x_offset << pixel_shift) + 2 * y_offset * h->
mb_linesize;
605 if (chroma_idc == 3 ) {
606 dest_cb += (2 * x_offset << pixel_shift) + 2 * y_offset * h->
mb_linesize;
607 dest_cr += (2 * x_offset << pixel_shift) + 2 * y_offset * h->
mb_linesize;
608 }
else if (chroma_idc == 2 ) {
609 dest_cb += (x_offset << pixel_shift) + 2 * y_offset * h->
mb_uvlinesize;
610 dest_cr += (x_offset << pixel_shift) + 2 * y_offset * h->
mb_uvlinesize;
612 dest_cb += (x_offset << pixel_shift) + y_offset * h->
mb_uvlinesize;
613 dest_cr += (x_offset << pixel_shift) + y_offset * h->
mb_uvlinesize;
615 x_offset += 8 * s->
mb_x;
621 dest_y, dest_cb, dest_cr, x_offset, y_offset,
622 qpix_op, chroma_op, pixel_shift, chroma_idc);
625 chroma_op = chroma_avg;
631 dest_y, dest_cb, dest_cr, x_offset, y_offset,
632 qpix_op, chroma_op, pixel_shift, chroma_idc);
640 int x_offset,
int y_offset,
647 int list0,
int list1,
648 int pixel_shift,
int chroma_idc)
653 dest_y += (2 * x_offset << pixel_shift) + 2 * y_offset * h->
mb_linesize;
654 if (chroma_idc == 3 ) {
656 chroma_weight_avg = luma_weight_avg;
657 chroma_weight_op = luma_weight_op;
658 dest_cb += (2 * x_offset << pixel_shift) + 2 * y_offset * h->
mb_linesize;
659 dest_cr += (2 * x_offset << pixel_shift) + 2 * y_offset * h->
mb_linesize;
660 }
else if (chroma_idc == 2 ) {
662 dest_cb += (x_offset << pixel_shift) + 2 * y_offset * h->
mb_uvlinesize;
663 dest_cr += (x_offset << pixel_shift) + 2 * y_offset * h->
mb_uvlinesize;
665 chroma_height = height >> 1;
666 dest_cb += (x_offset << pixel_shift) + y_offset * h->
mb_uvlinesize;
667 dest_cr += (x_offset << pixel_shift) + y_offset * h->
mb_uvlinesize;
669 x_offset += 8 * s->
mb_x;
672 if (list0 && list1) {
682 dest_y, dest_cb, dest_cr,
683 x_offset, y_offset, qpix_put, chroma_put,
684 pixel_shift, chroma_idc);
686 tmp_y, tmp_cb, tmp_cr,
687 x_offset, y_offset, qpix_put, chroma_put,
688 pixel_shift, chroma_idc);
692 int weight1 = 64 - weight0;
694 height, 5, weight0, weight1, 0);
696 chroma_height, 5, weight0, weight1, 0);
698 chroma_height, 5, weight0, weight1, 0);
700 luma_weight_avg(dest_y, tmp_y, h->
mb_linesize, height,
706 chroma_weight_avg(dest_cb, tmp_cb, h->
mb_uvlinesize, chroma_height,
712 chroma_weight_avg(dest_cr, tmp_cr, h->
mb_uvlinesize, chroma_height,
720 int list = list1 ? 1 : 0;
723 mc_dir_part(h, ref, n, square, height, delta, list,
724 dest_y, dest_cb, dest_cr, x_offset, y_offset,
725 qpix_put, chroma_put, pixel_shift, chroma_idc);
745 int pixel_shift,
int chroma_idc)
755 int off = (mx << pixel_shift) +
759 if (chroma_idc == 3 ) {
763 off= (((mx>>1)+64)<<pixel_shift) + ((my>>1) + (s->
mb_x&7))*s->
uvlinesize;
811 for (i = 0; i < 6; i++) {
813 for (j = 0; j < i; j++)
822 for (q = 0; q < max_qp + 1; q++) {
825 for (x = 0; x < 64; x++)
837 for (i = 0; i < 6; i++) {
839 for (j = 0; j < i; j++)
848 for (q = 0; q < max_qp + 1; q++) {
851 for (x = 0; x < 16; x++)
866 for (i = 0; i < 6; i++)
867 for (x = 0; x < 16; x++)
870 for (i = 0; i < 6; i++)
871 for (x = 0; x < 64; x++)
884 row_mb_num * 8 *
sizeof(
uint8_t), fail)
886 big_mb_num * 48 *
sizeof(
uint8_t), fail)
890 big_mb_num *
sizeof(uint16_t), fail)
892 big_mb_num *
sizeof(
uint8_t), fail)
894 16 * row_mb_num *
sizeof(
uint8_t), fail);
896 16 * row_mb_num *
sizeof(
uint8_t), fail);
898 4 * big_mb_num *
sizeof(
uint8_t), fail);
900 big_mb_num *
sizeof(
uint8_t), fail)
907 big_mb_num *
sizeof(uint32_t), fail);
909 big_mb_num *
sizeof(uint32_t), fail);
913 const int b_xy = 4 * x + 4 * y * h->
b_stride;
976 int parse_extradata);
1010 if (!buf || size <= 0)
1014 int i, cnt, nalsize;
1015 const unsigned char *p = buf;
1027 cnt = *(p + 5) & 0x1f;
1029 for (i = 0; i < cnt; i++) {
1031 if(nalsize > size - (p-buf))
1035 "Decoding sps %d from avcC failed\n", i);
1042 for (i = 0; i < cnt; i++) {
1044 if(nalsize > size - (p-buf))
1048 "Decoding pps %d from avcC failed\n", i);
1125 #define IN_RANGE(a, b, size) (((a) >= (b)) && ((a) < ((b) + (size))))
1133 for (i = 0; i < count; i++) {
1134 assert((
IN_RANGE(from[i], old_base,
sizeof(*old_base)) ||
1146 for (i = 0; i < count; i++) {
1147 if (to[i] && !from[i])
1149 else if (from[i] && !to[i])
1153 memcpy(to[i], from[i], size);
1171 #define copy_fields(to, from, start_field, end_field) \
1172 memcpy(&to->start_field, &from->start_field, \
1173 (char *)&to->end_field - (char *)&to->start_field)
1241 memcpy(&h->
s + 1, &h1->s + 1,
1246 if (
s1->context_initialized) {
1255 for (i = 0; i < 2; i++) {
1285 copy_fields(h, h1, dequant4_buffer, dequant4_coeff);
1287 for (i = 0; i < 6; i++)
1289 (h1->dequant4_coeff[i] - h1->dequant4_buffer[0]);
1291 for (i = 0; i < 6; i++)
1293 (h1->dequant8_coeff[i] - h1->dequant8_buffer[0]);
1349 for (i = 0; i < 16; i++) {
1353 for (i = 0; i < 16; i++) {
1406 int i, pics, out_of_order, out_idx;
1508 for (i = 0; 1; i++) {
1520 out_of_order =
FFMAX(out_of_order, 1);
1586 int linesize,
int uvlinesize,
1597 src_cb -= uvlinesize;
1598 src_cr -= uvlinesize;
1604 AV_COPY128(top_border, src_y + 15 * linesize);
1606 AV_COPY128(top_border + 16, src_y + 15 * linesize + 16);
1610 AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
1611 AV_COPY128(top_border + 48, src_cb + 15 * uvlinesize + 16);
1612 AV_COPY128(top_border + 64, src_cr + 15 * uvlinesize);
1613 AV_COPY128(top_border + 80, src_cr + 15 * uvlinesize + 16);
1615 AV_COPY128(top_border + 16, src_cb + 15 * uvlinesize);
1616 AV_COPY128(top_border + 32, src_cr + 15 * uvlinesize);
1618 }
else if (chroma422) {
1620 AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
1621 AV_COPY128(top_border + 48, src_cr + 15 * uvlinesize);
1623 AV_COPY64(top_border + 16, src_cb + 15 * uvlinesize);
1624 AV_COPY64(top_border + 24, src_cr + 15 * uvlinesize);
1628 AV_COPY128(top_border + 32, src_cb + 7 * uvlinesize);
1629 AV_COPY128(top_border + 48, src_cr + 7 * uvlinesize);
1631 AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
1632 AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
1646 AV_COPY128(top_border, src_y + 16 * linesize);
1648 AV_COPY128(top_border + 16, src_y + 16 * linesize + 16);
1653 AV_COPY128(top_border + 32, src_cb + 16 * linesize);
1654 AV_COPY128(top_border + 48, src_cb + 16 * linesize + 16);
1655 AV_COPY128(top_border + 64, src_cr + 16 * linesize);
1656 AV_COPY128(top_border + 80, src_cr + 16 * linesize + 16);
1658 AV_COPY128(top_border + 16, src_cb + 16 * linesize);
1659 AV_COPY128(top_border + 32, src_cr + 16 * linesize);
1661 }
else if (chroma422) {
1663 AV_COPY128(top_border + 32, src_cb + 16 * uvlinesize);
1664 AV_COPY128(top_border + 48, src_cr + 16 * uvlinesize);
1666 AV_COPY64(top_border + 16, src_cb + 16 * uvlinesize);
1667 AV_COPY64(top_border + 24, src_cr + 16 * uvlinesize);
1671 AV_COPY128(top_border + 32, src_cb + 8 * uvlinesize);
1672 AV_COPY128(top_border + 48, src_cr + 8 * uvlinesize);
1674 AV_COPY64(top_border + 16, src_cb + 8 * uvlinesize);
1675 AV_COPY64(top_border + 24, src_cr + 8 * uvlinesize);
1683 int linesize,
int uvlinesize,
1684 int xchg,
int chroma444,
1685 int simple,
int pixel_shift)
1688 int deblock_topleft;
1707 deblock_topleft = (s->
mb_x > 0);
1711 src_y -= linesize + 1 + pixel_shift;
1712 src_cb -= uvlinesize + 1 + pixel_shift;
1713 src_cr -= uvlinesize + 1 + pixel_shift;
1718 #define XCHG(a, b, xchg) \
1719 if (pixel_shift) { \
1721 AV_SWAP64(b + 0, a + 0); \
1722 AV_SWAP64(b + 8, a + 8); \
1732 if (deblock_topleft) {
1733 XCHG(top_border_m1 + (8 << pixel_shift),
1734 src_y - (7 << pixel_shift), 1);
1736 XCHG(top_border + (0 << pixel_shift), src_y + (1 << pixel_shift), xchg);
1737 XCHG(top_border + (8 << pixel_shift), src_y + (9 << pixel_shift), 1);
1740 src_y + (17 << pixel_shift), 1);
1745 if (deblock_topleft) {
1746 XCHG(top_border_m1 + (24 << pixel_shift), src_cb - (7 << pixel_shift), 1);
1747 XCHG(top_border_m1 + (40 << pixel_shift), src_cr - (7 << pixel_shift), 1);
1749 XCHG(top_border + (16 << pixel_shift), src_cb + (1 << pixel_shift), xchg);
1750 XCHG(top_border + (24 << pixel_shift), src_cb + (9 << pixel_shift), 1);
1751 XCHG(top_border + (32 << pixel_shift), src_cr + (1 << pixel_shift), xchg);
1752 XCHG(top_border + (40 << pixel_shift), src_cr + (9 << pixel_shift), 1);
1754 XCHG(h->
top_borders[top_idx][s->
mb_x + 1] + (16 << pixel_shift), src_cb + (17 << pixel_shift), 1);
1755 XCHG(h->
top_borders[top_idx][s->
mb_x + 1] + (32 << pixel_shift), src_cr + (17 << pixel_shift), 1);
1759 if (deblock_topleft) {
1760 XCHG(top_border_m1 + (16 << pixel_shift), src_cb - (7 << pixel_shift), 1);
1761 XCHG(top_border_m1 + (24 << pixel_shift), src_cr - (7 << pixel_shift), 1);
1763 XCHG(top_border + (16 << pixel_shift), src_cb + 1 + pixel_shift, 1);
1764 XCHG(top_border + (24 << pixel_shift), src_cr + 1 + pixel_shift, 1);
1773 if (high_bit_depth) {
1782 if (high_bit_depth) {
1789 int mb_type,
int is_h264,
1791 int transform_bypass,
1802 block_offset += 16 * p;
1806 if (transform_bypass) {
1813 for (i = 0; i < 16; i += 4) {
1814 uint8_t *
const ptr = dest_y + block_offset[i];
1817 h->
hpc.
pred8x8l_add[dir](ptr, h->
mb + (i * 16 + p * 256 << pixel_shift), linesize);
1823 if (nnz == 1 &&
dctcoef_get(h->
mb, pixel_shift, i * 16 + p * 256))
1824 idct_dc_add(ptr, h->
mb + (i * 16 + p * 256 << pixel_shift), linesize);
1826 idct_add(ptr, h->
mb + (i * 16 + p * 256 << pixel_shift), linesize);
1831 if (transform_bypass) {
1838 for (i = 0; i < 16; i++) {
1839 uint8_t *
const ptr = dest_y + block_offset[i];
1843 h->
hpc.
pred4x4_add[dir](ptr, h->
mb + (i * 16 + p * 256 << pixel_shift), linesize);
1851 if (!topright_avail) {
1853 tr_high = ((uint16_t *)ptr)[3 - linesize / 2] * 0x0001000100010001ULL;
1854 topright = (
uint8_t *)&tr_high;
1856 tr = ptr[3 - linesize] * 0x01010101u;
1860 topright = ptr + (4 << pixel_shift) - linesize;
1864 h->
hpc.
pred4x4[dir](ptr, topright, linesize);
1868 if (nnz == 1 &&
dctcoef_get(h->
mb, pixel_shift, i * 16 + p * 256))
1869 idct_dc_add(ptr, h->
mb + (i * 16 + p * 256 << pixel_shift), linesize);
1871 idct_add(ptr, h->
mb + (i * 16 + p * 256 << pixel_shift), linesize);
1872 }
else if (CONFIG_SVQ3_DECODER)
1883 if (!transform_bypass)
1888 static const uint8_t dc_mapping[16] = {
1889 0 * 16, 1 * 16, 4 * 16, 5 * 16,
1890 2 * 16, 3 * 16, 6 * 16, 7 * 16,
1891 8 * 16, 9 * 16, 12 * 16, 13 * 16,
1892 10 * 16, 11 * 16, 14 * 16, 15 * 16 };
1893 for (i = 0; i < 16; i++)
1895 pixel_shift, dc_mapping[i],
1900 }
else if (CONFIG_SVQ3_DECODER)
1907 int is_h264,
int simple,
1908 int transform_bypass,
1917 block_offset += 16 * p;
1921 if (transform_bypass) {
1926 h->
mb + (p * 256 << pixel_shift),
1929 for (i = 0; i < 16; i++)
1933 h->
mb + (i * 16 + p * 256 << pixel_shift),
1938 h->
mb + (p * 256 << pixel_shift),
1942 }
else if (h->
cbp & 15) {
1943 if (transform_bypass) {
1944 const int di =
IS_8x8DCT(mb_type) ? 4 : 1;
1947 for (i = 0; i < 16; i += di)
1950 h->
mb + (i * 16 + p * 256 << pixel_shift),
1955 h->
mb + (p * 256 << pixel_shift),
1960 h->
mb + (p * 256 << pixel_shift),
1965 }
else if (CONFIG_SVQ3_DECODER) {
1966 for (i = 0; i < 16; i++)
1969 uint8_t *
const ptr = dest_y + block_offset[i];
1992 const int mb_xy = h->
mb_xy;
1998 hl_decode_mb_444_complex(h);
2000 hl_decode_mb_444_simple_8(h);
2001 }
else if (is_complex) {
2002 hl_decode_mb_complex(h);
2004 hl_decode_mb_simple_16(h);
2006 hl_decode_mb_simple_8(h);
2013 int luma_def, chroma_def;
2023 for (list = 0; list < 2; list++) {
2026 for (i = 0; i < h->
ref_count[list]; i++) {
2027 int luma_weight_flag, chroma_weight_flag;
2030 if (luma_weight_flag) {
2045 if (chroma_weight_flag) {
2047 for (j = 0; j < 2; j++) {
2058 for (j = 0; j < 2; j++) {
2080 int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;
2082 for (i = 0; i < 2; i++) {
2114 for (ref0 = ref_start; ref0 < ref_count0; ref0++) {
2116 for (ref1 = ref_start; ref1 < ref_count1; ref1++) {
2120 int td = av_clip(poc1 - poc0, -128, 127);
2122 int tb = av_clip(cur_poc - poc0, -128, 127);
2123 int tx = (16384 + (
FFABS(td) >> 1)) / td;
2124 int dist_scale_factor = (tb * tx + 32) >> 8;
2125 if (dist_scale_factor >= -64 && dist_scale_factor <= 128)
2126 w = 64 - dist_scale_factor;
2216 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
2227 expected_delta_per_poc_cycle = 0;
2232 if (abs_frame_num > 0) {
2236 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
2237 for (i = 0; i <= frame_num_in_poc_cycle; i++)
2245 field_poc[0] = expectedpoc + h->
delta_poc[0];
2275 for (i = 0; i < 16; i++) {
2276 #define T(x) (x >> 2) | ((x << 2) & 0xF)
2281 for (i = 0; i < 64; i++) {
2282 #define T(x) (x >> 3) | ((x & 7) << 3)
2317 if (CONFIG_H264_VDPAU_DECODER &&
2335 "hardware accelerator failed to decode picture\n");
2338 if (CONFIG_H264_VDPAU_DECODER &&
2381 "Failed to allocate scratch buffers\n");
2438 "Reenabling low delay requires a codec flush.\n");
2448 "Different bit depth between chroma and luma", 1);
2458 "VDPAU decoding does not support video colorspace.\n");
2616 "Could not allocate memory for h264\n");
2664 unsigned int first_mb_in_slice;
2665 unsigned int pps_id;
2666 int num_ref_idx_active_override_flag, ret;
2667 unsigned int slice_type, tmp, i, j;
2668 int default_ref_list_done = 0;
2669 int last_pic_structure, last_pic_droppable;
2671 int needs_reinit = 0;
2685 if (first_mb_in_slice == 0) {
2702 if (slice_type > 9) {
2704 "slice type too large (%d) at %d %d\n",
2708 if (slice_type > 4) {
2717 default_ref_list_done = 1;
2732 "non-existing PPS %u referenced\n",
2740 "non-existing SPS %u referenced\n",
2827 "h264_slice_header_init() failed\n");
2835 "Cannot (re-)initialize context during parallel decoding.\n");
2845 "h264_slice_header_init() failed\n");
2882 "Changing field mode (%d -> %d) between slices is not allowed\n",
2889 "unset current_picture_ptr on %d. slice\n",
2900 if (unwrap_prev_frame_num > h->
frame_num)
2901 unwrap_prev_frame_num -= max_frame_num;
2905 if (unwrap_prev_frame_num < 0)
2906 unwrap_prev_frame_num += max_frame_num;
2932 if (!last_pic_droppable && last_pic_structure !=
PICT_FRAME) {
2942 if (!last_pic_droppable && last_pic_structure !=
PICT_FRAME) {
2953 "Invalid field mode combination %d/%d\n",
2958 }
else if (last_pic_droppable != s->
droppable) {
2960 "Cannot combine reference and non-reference fields in the same frame\n");
3065 first_mb_in_slice >= s->
mb_num) {
3115 num_ref_idx_active_override_flag =
get_bits1(&s->
gb);
3117 if (num_ref_idx_active_override_flag) {
3141 if (!default_ref_list_done)
3170 for (i = 0; i < 2; i++) {
3233 "deblocking_filter_idc %u out of range\n", tmp);
3246 "deblocking filter parameters %d %d out of range\n",
3271 "Cannot parallelize deblocking type 1, decoding such frames in sequential order\n");
3276 "Deblocking switched inside frame.\n");
3300 for (j = 0; j < 2; j++) {
3303 for (i = 0; i < 16; i++) {
3323 for (i = 0; i < 16; i++)
3324 ref2frm[i + 2] = 4 * id_list[i] +
3327 ref2frm[18 + 1] = -1;
3328 for (i = 16; i < 48; i++)
3329 ref2frm[i + 4] = 4 * id_list[(i - 16) >> 1] +
3342 "slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
3384 int mb_type,
int top_xy,
3387 int left_type[LEFT_MBS],
3388 int mb_xy,
int list)
3395 const int b_xy = h->
mb2b_xy[top_xy] + 3 * b_stride;
3396 const int b8_xy = 4 * top_xy + 2;
3399 ref_cache[0 - 1 * 8] =
3401 ref_cache[2 - 1 * 8] =
3411 const int b8_xy = 4 * left_xy[
LTOP] + 1;
3419 ref_cache[-1 + 16] =
3428 ref_cache[-1 + 16] =
3446 uint32_t ref01 = (
pack16to32(ref2frm[list][ref[0]], ref2frm[list][ref[1]]) & 0x00FF00FF) * 0x0101;
3447 uint32_t ref23 = (
pack16to32(ref2frm[list][ref[2]], ref2frm[list][ref[3]]) & 0x00FF00FF) * 0x0101;
3448 AV_WN32A(&ref_cache[0 * 8], ref01);
3449 AV_WN32A(&ref_cache[1 * 8], ref01);
3450 AV_WN32A(&ref_cache[2 * 8], ref23);
3451 AV_WN32A(&ref_cache[3 * 8], ref23);
3456 AV_COPY128(mv_dst + 8 * 0, mv_src + 0 * b_stride);
3457 AV_COPY128(mv_dst + 8 * 1, mv_src + 1 * b_stride);
3458 AV_COPY128(mv_dst + 8 * 2, mv_src + 2 * b_stride);
3459 AV_COPY128(mv_dst + 8 * 3, mv_src + 3 * b_stride);
3470 const int mb_xy = h->
mb_xy;
3481 left_xy[
LBOT] = left_xy[
LTOP] = mb_xy - 1;
3486 if (left_mb_field_flag != curr_mb_field_flag)
3489 if (curr_mb_field_flag)
3492 if (left_mb_field_flag != curr_mb_field_flag)
3506 if (qp <= qp_thresh &&
3507 (left_xy[
LTOP] < 0 ||
3513 if ((left_xy[
LTOP] < 0 ||
3528 left_type[
LTOP] = left_type[
LBOT] = 0;
3533 left_type[
LTOP] = left_type[
LBOT] = 0;
3543 top_type, left_type, mb_xy, 0);
3546 top_type, left_type, mb_xy, 1);
3550 AV_COPY32(&nnz_cache[4 + 8 * 1], &nnz[0]);
3551 AV_COPY32(&nnz_cache[4 + 8 * 2], &nnz[4]);
3552 AV_COPY32(&nnz_cache[4 + 8 * 3], &nnz[8]);
3553 AV_COPY32(&nnz_cache[4 + 8 * 4], &nnz[12]);
3558 AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[3 * 4]);
3561 if (left_type[
LTOP]) {
3563 nnz_cache[3 + 8 * 1] = nnz[3 + 0 * 4];
3564 nnz_cache[3 + 8 * 2] = nnz[3 + 1 * 4];
3565 nnz_cache[3 + 8 * 3] = nnz[3 + 2 * 4];
3566 nnz_cache[3 + 8 * 4] = nnz[3 + 3 * 4];
3573 nnz_cache[4 + 8 * 0] =
3574 nnz_cache[5 + 8 * 0] = (h->
cbp_table[top_xy] & 0x4000) >> 12;
3575 nnz_cache[6 + 8 * 0] =
3576 nnz_cache[7 + 8 * 0] = (h->
cbp_table[top_xy] & 0x8000) >> 12;
3579 nnz_cache[3 + 8 * 1] =
3580 nnz_cache[3 + 8 * 2] = (h->
cbp_table[left_xy[
LTOP]] & 0x2000) >> 12;
3583 nnz_cache[3 + 8 * 3] =
3584 nnz_cache[3 + 8 * 4] = (h->
cbp_table[left_xy[
LBOT]] & 0x8000) >> 12;
3588 nnz_cache[
scan8[0]] =
3589 nnz_cache[scan8[1]] =
3590 nnz_cache[scan8[2]] =
3591 nnz_cache[scan8[3]] = (h->
cbp & 0x1000) >> 12;
3593 nnz_cache[scan8[0 + 4]] =
3594 nnz_cache[scan8[1 + 4]] =
3595 nnz_cache[scan8[2 + 4]] =
3596 nnz_cache[scan8[3 + 4]] = (h->
cbp & 0x2000) >> 12;
3598 nnz_cache[scan8[0 + 8]] =
3599 nnz_cache[scan8[1 + 8]] =
3600 nnz_cache[scan8[2 + 8]] =
3601 nnz_cache[scan8[3 + 8]] = (h->
cbp & 0x4000) >> 12;
3603 nnz_cache[scan8[0 + 12]] =
3604 nnz_cache[scan8[1 + 12]] =
3605 nnz_cache[scan8[2 + 12]] =
3606 nnz_cache[scan8[3 + 12]] = (h->
cbp & 0x8000) >> 12;
3616 uint8_t *dest_y, *dest_cb, *dest_cr;
3617 int linesize, uvlinesize, mb_x, mb_y;
3624 for (mb_x = start_x; mb_x < end_x; mb_x++)
3625 for (mb_y = end_mb_y -
FRAME_MBAFF; mb_y <= end_mb_y; mb_y++) {
3639 ((mb_x << pixel_shift) + mb_y * s->
linesize) * 16;
3641 (mb_x << pixel_shift) * (8 <<
CHROMA444) +
3644 (mb_x << pixel_shift) * (8 <<
CHROMA444) +
3669 linesize, uvlinesize);
3672 dest_cr, linesize, uvlinesize);
3706 if ((top + height) >= pic_height)
3707 height += deblock_border;
3708 top -= deblock_border;
3714 height =
FFMIN(height, pic_height - top);
3715 if (top < h->emu_edge_height) {
3735 int lf_x_start = s->
mb_x;
3779 if (s->
mb_x >= lf_x_start)
3787 "error while decoding MB %d %d, bytestream (%td)\n",
3797 s->
mb_x = lf_x_start = 0;
3812 if (s->
mb_x > lf_x_start)
3836 "error while decoding MB %d %d\n", s->
mb_x, s->
mb_y);
3844 s->
mb_x = lf_x_start = 0;
3880 if (s->
mb_x > lf_x_start)
3911 if (context_count == 1) {
3914 for (i = 1; i < context_count; i++) {
3922 NULL, context_count,
sizeof(
void *));
3930 for (i = 1; i < context_count; i++)
3938 int parse_extradata)
3947 int nals_needed = 0;
3950 int first_slice = 0;
3965 if (buf_size > 8 &&
AV_RB32(buf) == 1 &&
AV_RB32(buf+5) > (
unsigned)buf_size) {
3967 }
else if(buf_size > 3 &&
AV_RB32(buf) > 1 &&
AV_RB32(buf) <= (
unsigned)buf_size)
3971 for (; pass <= 1; pass++) {
3974 next_avc = h->
is_avc ? 0 : buf_size;
3984 if (buf_index >= next_avc) {
3989 nalsize = (nalsize << 8) | buf[buf_index++];
3990 if (nalsize <= 0 || nalsize > buf_size - buf_index) {
3992 "AVC: nal size %d\n", nalsize);
3995 next_avc = buf_index + nalsize;
3998 for (; buf_index + 3 < next_avc; buf_index++)
4000 if (buf[buf_index] == 0 &&
4001 buf[buf_index + 1] == 0 &&
4002 buf[buf_index + 2] == 1)
4005 if (buf_index + 3 >= buf_size) {
4006 buf_index = buf_size;
4011 if (buf_index >= next_avc)
4018 &consumed, next_avc - buf_index);
4019 if (ptr ==
NULL || dst_length < 0) {
4023 i = buf_index + consumed;
4025 buf[i] == 0x00 && buf[i + 1] == 0x00 &&
4026 buf[i + 2] == 0x01 && buf[i + 3] == 0xE0)
4030 while(dst_length > 0 && ptr[dst_length - 1] == 0)
4032 bit_length = !dst_length ? 0
4039 if (h->
is_avc && (nalsize != consumed) && nalsize)
4041 "AVC: Consumed only %d bytes instead of %d\n",
4044 buf_index += consumed;
4055 nals_needed = nal_index;
4062 nals_needed = nal_index;
4085 if (parse_extradata) {
4104 "Invalid mix of idr and non-idr slices\n");
4152 if (CONFIG_H264_VDPAU_DECODER &&
4167 &buf[buf_index - consumed],
4170 }
else if (CONFIG_H264_VDPAU_DECODER &&
4172 static const uint8_t start_code[] = {
4175 sizeof(start_code));
4224 "SPS decoding failure, trying again with the complete NAL\n");
4226 av_assert0(next_avc - buf_index + consumed == nalsize);
4227 if ((next_avc - buf_index + consumed - 1) >= INT_MAX/8)
4230 8*(next_avc - buf_index + consumed - 1));
4260 else if (err == 1) {
4293 if (pos + 10 > buf_size)
4303 int buf_size = avpkt->
size;
4315 if (buf_size == 0) {
4343 if(h->
is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC && (buf[5]&0x1F) && buf[8]==0x67){
4344 int cnt= buf[5]&0x1f;
4348 if(nalsize > buf_size - (p-buf) || p[2]!=0x67)
4357 if(nalsize > buf_size - (p-buf) || p[2]!=0x68)
4377 buf_size >= 4 && !memcmp(
"Q264", buf, 4))
4399 assert(pict->
data[0] || !*got_frame);
4489 #if CONFIG_H264_VDPAU_DECODER
4490 AVCodec ff_h264_vdpau_decoder = {
4491 .
name =
"h264_vdpau",
4500 .long_name =
NULL_IF_CONFIG_SMALL(
"H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"),