69 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
70 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
75 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
80 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
81 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
87 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
92 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
93 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
94 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
99 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
100 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
101 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
102 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
105 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
111 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
113 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
114 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
115 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
116 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
117 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
118 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
134 #if CONFIG_H264_DXVA2_HWACCEL
137 #if CONFIG_H264_VAAPI_HWACCEL
140 #if CONFIG_H264_VDA_HWACCEL
157 for (i = 0; i < 3; i++) {
158 uint32_t tmp = *state << 8;
159 *state = tmp + *(p++);
160 if (tmp == 0x100 || p == end)
165 if (p[-1] > 1 ) p += 3;
166 else if (p[-2] ) p += 2;
167 else if (p[-3]|(p[-1]-1)) p++;
174 p =
FFMIN(p, end) - 4;
295 if (r < 0 || !pic->f.type || !pic->
f.
data[0]) {
305 "get_buffer() failed (stride changed)\n");
312 "get_buffer() failed (uv stride mismatch)\n");
320 "get_buffer() failed to allocate context scratch buffers.\n");
345 assert(pic->
f.
data[0]);
349 assert(!pic->
f.
data[0]);
361 mb_array_size *
sizeof(int16_t), fail)
363 mb_array_size *
sizeof(int16_t), fail)
365 mb_array_size *
sizeof(int8_t ), fail)
369 mb_array_size *
sizeof(
uint8_t) + 2, fail)
374 (big_mb_num + s->
mb_stride) *
sizeof(uint32_t),
379 for (i = 0; i < 2; i++) {
381 2 * (b4_array_size + 4) *
sizeof(int16_t),
385 4 * mb_array_size *
sizeof(
uint8_t), fail)
390 for (i = 0; i < 2; i++) {
392 2 * (b8_array_size + 4) *
sizeof(int16_t),
396 4 * mb_array_size *
sizeof(
uint8_t), fail)
402 64 * mb_array_size *
sizeof(
DCTELEM) * 6, fail)
440 for (i = 0; i < 2; i++) {
447 for (i = 0; i < 4; i++) {
459 int yc_size = y_size + 2 * c_size;
476 2 * 64 *
sizeof(
int), fail)
482 for (i = 0; i < 12; i++) {
489 yc_size *
sizeof(int16_t) * 16, fail);
522 #define COPY(a) bak->a = src->a
523 COPY(edge_emu_buffer);
528 COPY(obmc_scratchpad);
535 COPY(me.map_generation);
556 for (i = 0; i < 12; i++) {
562 "scratch buffers.\n");
576 if (dst == src || !
s1->context_initialized)
613 (
char *) &
s1->last_picture_ptr - (
char *) &
s1->last_picture);
629 (
char *) &
s1->shape - (
char *) &
s1->time_increment_bits);
639 if (
s1->bitstream_buffer) {
640 if (
s1->bitstream_buffer_size +
644 s1->allocated_bitstream_buffer_size);
647 s1->bitstream_buffer_size);
657 "scratch buffers.\n");
662 "be allocated due to unknown size.\n");
668 (
char *) &
s1->rtp_mode - (
char *) &
s1->progressive_sequence);
670 if (!
s1->first_field) {
672 if (
s1->current_picture_ptr)
728 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
753 yc_size = y_size + 2 * c_size;
767 mv_table_size * 2 *
sizeof(int16_t), fail);
769 mv_table_size * 2 *
sizeof(int16_t), fail);
771 mv_table_size * 2 *
sizeof(int16_t), fail);
773 mv_table_size * 2 *
sizeof(int16_t), fail);
775 mv_table_size * 2 *
sizeof(int16_t), fail);
777 mv_table_size * 2 *
sizeof(int16_t), fail);
789 sizeof(uint16_t), fail);
795 mb_array_size *
sizeof(
float), fail);
797 mb_array_size *
sizeof(
float), fail);
802 mb_array_size *
sizeof(
uint8_t), fail);
804 mb_array_size *
sizeof(
uint8_t), fail);
809 for (i = 0; i < 2; i++) {
811 for (j = 0; j < 2; j++) {
812 for (k = 0; k < 2; k++) {
815 mv_table_size * 2 *
sizeof(int16_t),
821 mb_array_size * 2 *
sizeof(
uint8_t), fail);
823 mv_table_size * 2 *
sizeof(int16_t), fail);
828 mb_array_size * 2 *
sizeof(
uint8_t), fail);
838 mb_array_size *
sizeof(
uint8_t), fail);
840 mb_array_size *
sizeof(
uint8_t), fail);
847 yc_size *
sizeof(int16_t), fail);
851 for (i = 0; i < yc_size; i++)
899 "decoding to AV_PIX_FMT_NONE is not supported.\n");
910 " reducing to %d\n", nb_slices, max_slices);
911 nb_slices = max_slices;
940 (
MAX_RUN + 1) * 2 *
sizeof(
int), fail);
945 64 * 32 *
sizeof(
int), fail);
947 64 * 32 *
sizeof(
int), fail);
949 64 * 32 * 2 *
sizeof(uint16_t), fail);
951 64 * 32 * 2 *
sizeof(uint16_t), fail);
959 2 * 64 *
sizeof(uint16_t), fail);
983 for (i = 1; i < nb_slices; i++) {
988 for (i = 0; i < nb_slices; i++) {
992 (s->
mb_height * (i) + nb_slices / 2) / nb_slices;
994 (s->
mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1033 for (i = 0; i < 2; i++) {
1034 for (j = 0; j < 2; j++) {
1035 for (k = 0; k < 2; k++) {
1063 for (i = 0; i < 3; i++)
1111 if (nb_slices > 1) {
1112 for (i = 1; i < nb_slices; i++) {
1117 for (i = 0; i < nb_slices; i++) {
1121 (s->
mb_height * (i) + nb_slices / 2) / nb_slices;
1123 (s->
mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1196 int last,
run,
level, start, end, i;
1203 for (last = 0; last < 2; last++) {
1212 memset(max_level, 0,
MAX_RUN + 1);
1214 memset(index_run, rl->
n,
MAX_RUN + 1);
1215 for (i = start; i < end; i++) {
1218 if (index_run[run] == rl->
n)
1220 if (level > max_level[run])
1222 if (run > max_run[level])
1226 rl->
max_level[last] = static_store[last];
1239 memcpy(rl->
index_run[last], index_run, MAX_RUN + 1);
1247 for (q = 0; q < 32; q++) {
1249 int qadd = (q - 1) | 1;
1263 }
else if (len < 0) {
1267 if (code == rl->
n) {
1273 if (code >= rl->
last) run += 192;
1335 if (ret >= 0 && ret < s->picture_range_end) {
1349 for (intra = 0; intra < 2; intra++) {
1351 for (i = 0; i < 64; i++) {
1357 for (i = 0; i < 64; i++) {
1395 "releasing zombie picture\n");
1458 av_dlog(s->
avctx,
"L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1472 "warning: first frame is no keyframe\n");
1475 "allocate dummy last picture for field based first keyframe\n");
1535 "Non-reference picture received and no reference available\n");
1541 for (i = 0; i < 4; i++) {
1627 assert(i < MAX_PICTURE_COUNT);
1664 sx = av_clip(sx, 0, w - 1);
1665 sy = av_clip(sy, 0, h - 1);
1666 ex = av_clip(ex, 0, w - 1);
1667 ey = av_clip(ey, 0, h - 1);
1669 buf[sy * stride + sx] +=
color;
1678 f = ((ey - sy) << 16) / ex;
1679 for (x = 0; x <= ex; x++) {
1681 fr = (x * f) & 0xFFFF;
1682 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1683 buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1693 f = ((ex - sx) << 16) / ey;
1696 for (y = 0; y = ey; y++) {
1698 fr = (y * f) & 0xFFFF;
1699 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1700 buf[y * stride + x + 1] += (color * fr ) >> 16;
1717 sx = av_clip(sx, -100, w + 100);
1718 sy = av_clip(sy, -100, h + 100);
1719 ex = av_clip(ex, -100, w + 100);
1720 ey = av_clip(ey, -100, h + 100);
1725 if (dx * dx + dy * dy > 3 * 3) {
1728 int length =
ff_sqrt((rx * rx + ry * ry) << 8);
1734 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1735 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1737 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1773 for (x = 0; x < s->
mb_width; x++) {
1801 else if (
IS_GMC(mb_type))
1843 int h_chroma_shift, v_chroma_shift, block_height;
1847 const int mv_stride = (s->
mb_width << mv_sample_log2) +
1852 &h_chroma_shift, &v_chroma_shift);
1853 for (i = 0; i < 3; i++) {
1855 (i == 0) ? pict->
linesize[i] * height:
1856 pict->
linesize[i] * height >> v_chroma_shift);
1860 ptr = pict->
data[0];
1861 block_height = 16 >> v_chroma_shift;
1863 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1865 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1866 const int mb_index = mb_x + mb_y * s->
mb_stride;
1869 for (type = 0; type < 3; type++) {
1896 for (i = 0; i < 4; i++) {
1897 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1898 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1899 int xy = (mb_x * 2 + (i & 1) +
1900 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1901 int mx = (pict->
motion_val[direction][xy][0] >> shift) + sx;
1902 int my = (pict->
motion_val[direction][xy][1] >> shift) + sy;
1908 for (i = 0; i < 2; i++) {
1909 int sx = mb_x * 16 + 8;
1910 int sy = mb_y * 16 + 4 + 8 * i;
1911 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1912 int mx = (pict->
motion_val[direction][xy][0] >> shift);
1913 int my = (pict->
motion_val[direction][xy][1] >> shift);
1918 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1923 for (i = 0; i < 2; i++) {
1924 int sx = mb_x * 16 + 4 + 8 * i;
1925 int sy = mb_y * 16 + 8;
1926 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1927 int mx = pict->
motion_val[direction][xy][0] >> shift;
1928 int my = pict->
motion_val[direction][xy][1] >> shift;
1933 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1937 int sx = mb_x * 16 + 8;
1938 int sy = mb_y * 16 + 8;
1939 int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
1940 int mx = pict->
motion_val[direction][xy][0] >> shift + sx;
1941 int my = pict->
motion_val[direction][xy][1] >> shift + sy;
1947 uint64_t c = (pict->
qscale_table[mb_index] * 128 / 31) *
1948 0x0101010101010101ULL;
1950 for (y = 0; y < block_height; y++) {
1951 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1952 (block_height * mb_y + y) *
1954 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
1955 (block_height * mb_y + y) *
1961 int mb_type = pict->
mb_type[mb_index];
1964 #define COLOR(theta, r) \
1965 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1966 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1983 }
else if (
IS_GMC(mb_type)) {
1985 }
else if (
IS_SKIP(mb_type)) {
1996 u *= 0x0101010101010101ULL;
1997 v *= 0x0101010101010101ULL;
1998 for (y = 0; y < block_height; y++) {
1999 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
2000 (block_height * mb_y + y) * pict->
linesize[1]) = u;
2001 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
2002 (block_height * mb_y + y) * pict->
linesize[2]) = v;
2007 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 0 +
2008 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
2009 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 8 +
2010 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
2013 for (y = 0; y < 16; y++)
2014 pict->
data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2017 if (
IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2018 int dm = 1 << (mv_sample_log2 - 2);
2019 for (i = 0; i < 4; i++) {
2020 int sx = mb_x * 16 + 8 * (i & 1);
2021 int sy = mb_y * 16 + 8 * (i >> 1);
2022 int xy = (mb_x * 2 + (i & 1) +
2023 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2026 if (mv[0] != mv[dm] ||
2027 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2028 for (y = 0; y < 8; y++)
2029 pict->
data[0][sx + 4 + (sy + y) * pict->
linesize[0]] ^= 0x80;
2030 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2031 *(uint64_t *)(pict->
data[0] + sx + (sy + 4) *
2032 pict->
linesize[0]) ^= 0x8080808080808080ULL;
2052 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->
quarter_sample;
2053 int my,
off, i, mvs;
2072 for (i = 0; i < mvs; i++) {
2073 my = s->
mv[dir][i][1]<<qpel_shift;
2074 my_max =
FFMAX(my_max, my);
2075 my_min =
FFMIN(my_min, my);
2078 off = (
FFMAX(-my_min, my_max) + 63) >> 6;
2125 memset(s->
ac_val[0][xy ], 0, 32 *
sizeof(int16_t));
2126 memset(s->
ac_val[0][xy + wrap], 0, 32 *
sizeof(int16_t));
2139 memset(s->
ac_val[1][xy], 0, 16 *
sizeof(int16_t));
2140 memset(s->
ac_val[2][xy], 0, 16 *
sizeof(int16_t));
2171 for(j=0; j<64; j++){
2196 uint8_t *dest_y, *dest_cb, *dest_cr;
2197 int dct_linesize, dct_offset;
2203 const int block_size = 8;
2222 dct_offset = s->
interlaced_dct ? linesize : linesize * block_size;
2226 dest_cb= s->
dest[1];
2227 dest_cr= s->
dest[2];
2298 add_dct(s, block[0], 0, dest_y , dct_linesize);
2299 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2300 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2301 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2305 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2306 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2312 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2313 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2314 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2315 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2317 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2318 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2319 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2320 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2332 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->
qscale);
2333 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->
qscale);
2334 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->
qscale);
2351 s->
dsp.
idct_put(dest_y + block_size, dct_linesize, block[1]);
2352 s->
dsp.
idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2353 s->
dsp.
idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2366 s->
dsp.
idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2367 s->
dsp.
idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2369 s->
dsp.
idct_put(dest_cb + 8, dct_linesize, block[8]);
2370 s->
dsp.
idct_put(dest_cr + 8, dct_linesize, block[9]);
2371 s->
dsp.
idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2372 s->
dsp.
idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2413 int sides = 0, edge_h;
2469 const int mb_size= 4;
2486 s->
dest[0] += s->
mb_y * linesize << mb_size;
2490 s->
dest[0] += (s->
mb_y>>1) * linesize << mb_size;
2528 int i,
level, nCoeffs;
2529 const uint16_t *quant_matrix;
2539 for(i=1;i<=nCoeffs;i++) {
2545 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2546 level = (level - 1) | 1;
2549 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2550 level = (level - 1) | 1;
2560 int i,
level, nCoeffs;
2561 const uint16_t *quant_matrix;
2566 for(i=0; i<=nCoeffs; i++) {
2572 level = (((level << 1) + 1) * qscale *
2573 ((int) (quant_matrix[j]))) >> 4;
2574 level = (level - 1) | 1;
2577 level = (((level << 1) + 1) * qscale *
2578 ((int) (quant_matrix[j]))) >> 4;
2579 level = (level - 1) | 1;
2589 int i,
level, nCoeffs;
2590 const uint16_t *quant_matrix;
2600 for(i=1;i<=nCoeffs;i++) {
2606 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2609 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2619 int i,
level, nCoeffs;
2620 const uint16_t *quant_matrix;
2631 for(i=1;i<=nCoeffs;i++) {
2637 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2640 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2652 int i,
level, nCoeffs;
2653 const uint16_t *quant_matrix;
2660 for(i=0; i<=nCoeffs; i++) {
2666 level = (((level << 1) + 1) * qscale *
2667 ((int) (quant_matrix[j]))) >> 4;
2670 level = (((level << 1) + 1) * qscale *
2671 ((int) (quant_matrix[j]))) >> 4;
2683 int i,
level, qmul, qadd;
2695 qadd = (qscale - 1) | 1;
2704 for(i=1; i<=nCoeffs; i++) {
2708 level = level * qmul - qadd;
2710 level = level * qmul + qadd;
2720 int i,
level, qmul, qadd;
2725 qadd = (qscale - 1) | 1;
2730 for(i=0; i<=nCoeffs; i++) {
2734 level = level * qmul - qadd;
2736 level = level * qmul + qadd;
2750 else if (qscale > 31)