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,
151 for (i = 0; i < 3; i++) {
152 uint32_t tmp = *state << 8;
153 *state = tmp + *(p++);
154 if (tmp == 0x100 || p == end)
159 if (p[-1] > 1 ) p += 3;
160 else if (p[-2] ) p += 2;
161 else if (p[-3]|(p[-1]-1)) p++;
168 p =
FFMIN(p, end) - 4;
289 if (r < 0 || !pic->f.type || !pic->
f.
data[0]) {
299 "get_buffer() failed (stride changed)\n");
306 "get_buffer() failed (uv stride mismatch)\n");
314 "get_buffer() failed to allocate context scratch buffers.\n");
339 assert(pic->
f.
data[0]);
343 assert(!pic->
f.
data[0]);
355 mb_array_size *
sizeof(int16_t), fail)
357 mb_array_size *
sizeof(int16_t), fail)
359 mb_array_size *
sizeof(int8_t ), fail)
363 mb_array_size *
sizeof(
uint8_t) + 2, fail)
368 (big_mb_num + s->
mb_stride) *
sizeof(uint32_t),
373 for (i = 0; i < 2; i++) {
375 2 * (b4_array_size + 4) *
sizeof(int16_t),
379 4 * mb_array_size *
sizeof(
uint8_t), fail)
384 for (i = 0; i < 2; i++) {
386 2 * (b8_array_size + 4) *
sizeof(int16_t),
390 4 * mb_array_size *
sizeof(
uint8_t), fail)
396 64 * mb_array_size *
sizeof(
DCTELEM) * 6, fail)
434 for (i = 0; i < 2; i++) {
441 for (i = 0; i < 4; i++) {
453 int yc_size = y_size + 2 * c_size;
470 2 * 64 *
sizeof(
int), fail)
476 for (i = 0; i < 12; i++) {
483 yc_size *
sizeof(int16_t) * 16, fail);
516 #define COPY(a) bak->a = src->a
517 COPY(edge_emu_buffer);
522 COPY(obmc_scratchpad);
529 COPY(me.map_generation);
550 for (i = 0; i < 12; i++) {
556 "scratch buffers.\n");
570 if (dst == src || !
s1->context_initialized)
607 (
char *) &
s1->last_picture_ptr - (
char *) &
s1->last_picture);
623 (
char *) &
s1->shape - (
char *) &
s1->time_increment_bits);
633 if (
s1->bitstream_buffer) {
634 if (
s1->bitstream_buffer_size +
638 s1->allocated_bitstream_buffer_size);
641 s1->bitstream_buffer_size);
651 "scratch buffers.\n");
656 "be allocated due to unknown size.\n");
662 (
char *) &
s1->rtp_mode - (
char *) &
s1->progressive_sequence);
664 if (!
s1->first_field) {
666 if (
s1->current_picture_ptr)
722 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
747 yc_size = y_size + 2 * c_size;
761 mv_table_size * 2 *
sizeof(int16_t), fail);
763 mv_table_size * 2 *
sizeof(int16_t), fail);
765 mv_table_size * 2 *
sizeof(int16_t), fail);
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);
783 sizeof(uint16_t), fail);
789 mb_array_size *
sizeof(
float), fail);
791 mb_array_size *
sizeof(
float), fail);
796 mb_array_size *
sizeof(
uint8_t), fail);
798 mb_array_size *
sizeof(
uint8_t), fail);
803 for (i = 0; i < 2; i++) {
805 for (j = 0; j < 2; j++) {
806 for (k = 0; k < 2; k++) {
809 mv_table_size * 2 *
sizeof(int16_t),
815 mb_array_size * 2 *
sizeof(
uint8_t), fail);
817 mv_table_size * 2 *
sizeof(int16_t), fail);
822 mb_array_size * 2 *
sizeof(
uint8_t), fail);
832 mb_array_size *
sizeof(
uint8_t), fail);
834 mb_array_size *
sizeof(
uint8_t), fail);
841 yc_size *
sizeof(int16_t), fail);
845 for (i = 0; i < yc_size; i++)
893 "decoding to AV_PIX_FMT_NONE is not supported.\n");
904 " reducing to %d\n", nb_slices, max_slices);
905 nb_slices = max_slices;
934 (
MAX_RUN + 1) * 2 *
sizeof(
int), fail);
939 64 * 32 *
sizeof(
int), fail);
941 64 * 32 *
sizeof(
int), fail);
943 64 * 32 * 2 *
sizeof(uint16_t), fail);
945 64 * 32 * 2 *
sizeof(uint16_t), fail);
953 2 * 64 *
sizeof(uint16_t), fail);
977 for (i = 1; i < nb_slices; i++) {
982 for (i = 0; i < nb_slices; i++) {
986 (s->
mb_height * (i) + nb_slices / 2) / nb_slices;
988 (s->
mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1027 for (i = 0; i < 2; i++) {
1028 for (j = 0; j < 2; j++) {
1029 for (k = 0; k < 2; k++) {
1057 for (i = 0; i < 3; i++)
1105 if (nb_slices > 1) {
1106 for (i = 1; i < nb_slices; i++) {
1111 for (i = 0; i < nb_slices; i++) {
1115 (s->
mb_height * (i) + nb_slices / 2) / nb_slices;
1117 (s->
mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1190 int last,
run,
level, start, end, i;
1197 for (last = 0; last < 2; last++) {
1206 memset(max_level, 0,
MAX_RUN + 1);
1208 memset(index_run, rl->
n,
MAX_RUN + 1);
1209 for (i = start; i < end; i++) {
1212 if (index_run[run] == rl->
n)
1214 if (level > max_level[run])
1216 if (run > max_run[level])
1220 rl->
max_level[last] = static_store[last];
1233 memcpy(rl->
index_run[last], index_run, MAX_RUN + 1);
1241 for (q = 0; q < 32; q++) {
1243 int qadd = (q - 1) | 1;
1257 }
else if (len < 0) {
1261 if (code == rl->
n) {
1267 if (code >= rl->
last) run += 192;
1329 if (ret >= 0 && ret < s->picture_range_end) {
1343 for (intra = 0; intra < 2; intra++) {
1345 for (i = 0; i < 64; i++) {
1351 for (i = 0; i < 64; i++) {
1389 "releasing zombie picture\n");
1452 av_dlog(s->
avctx,
"L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1466 "warning: first frame is no keyframe\n");
1469 "allocate dummy last picture for field based first keyframe\n");
1523 for (i = 0; i < 4; i++) {
1609 assert(i < MAX_PICTURE_COUNT);
1646 sx = av_clip(sx, 0, w - 1);
1647 sy = av_clip(sy, 0, h - 1);
1648 ex = av_clip(ex, 0, w - 1);
1649 ey = av_clip(ey, 0, h - 1);
1651 buf[sy * stride + sx] +=
color;
1660 f = ((ey - sy) << 16) / ex;
1661 for (x = 0; x <= ex; x++) {
1663 fr = (x * f) & 0xFFFF;
1664 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1665 buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1675 f = ((ex - sx) << 16) / ey;
1678 for (y = 0; y = ey; y++) {
1680 fr = (y * f) & 0xFFFF;
1681 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1682 buf[y * stride + x + 1] += (color * fr ) >> 16;
1699 sx = av_clip(sx, -100, w + 100);
1700 sy = av_clip(sy, -100, h + 100);
1701 ex = av_clip(ex, -100, w + 100);
1702 ey = av_clip(ey, -100, h + 100);
1707 if (dx * dx + dy * dy > 3 * 3) {
1710 int length =
ff_sqrt((rx * rx + ry * ry) << 8);
1716 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1717 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1719 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1755 for (x = 0; x < s->
mb_width; x++) {
1783 else if (
IS_GMC(mb_type))
1825 int h_chroma_shift, v_chroma_shift, block_height;
1829 const int mv_stride = (s->
mb_width << mv_sample_log2) +
1834 &h_chroma_shift, &v_chroma_shift);
1835 for (i = 0; i < 3; i++) {
1837 (i == 0) ? pict->
linesize[i] * height:
1838 pict->
linesize[i] * height >> v_chroma_shift);
1842 ptr = pict->
data[0];
1843 block_height = 16 >> v_chroma_shift;
1845 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1847 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1848 const int mb_index = mb_x + mb_y * s->
mb_stride;
1851 for (type = 0; type < 3; type++) {
1878 for (i = 0; i < 4; i++) {
1879 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1880 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1881 int xy = (mb_x * 2 + (i & 1) +
1882 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1883 int mx = (pict->
motion_val[direction][xy][0] >> shift) + sx;
1884 int my = (pict->
motion_val[direction][xy][1] >> shift) + sy;
1890 for (i = 0; i < 2; i++) {
1891 int sx = mb_x * 16 + 8;
1892 int sy = mb_y * 16 + 4 + 8 * i;
1893 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1894 int mx = (pict->
motion_val[direction][xy][0] >> shift);
1895 int my = (pict->
motion_val[direction][xy][1] >> shift);
1900 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1905 for (i = 0; i < 2; i++) {
1906 int sx = mb_x * 16 + 4 + 8 * i;
1907 int sy = mb_y * 16 + 8;
1908 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1909 int mx = pict->
motion_val[direction][xy][0] >> shift;
1910 int my = pict->
motion_val[direction][xy][1] >> shift;
1915 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1919 int sx = mb_x * 16 + 8;
1920 int sy = mb_y * 16 + 8;
1921 int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
1922 int mx = pict->
motion_val[direction][xy][0] >> shift + sx;
1923 int my = pict->
motion_val[direction][xy][1] >> shift + sy;
1929 uint64_t c = (pict->
qscale_table[mb_index] * 128 / 31) *
1930 0x0101010101010101ULL;
1932 for (y = 0; y < block_height; y++) {
1933 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1934 (block_height * mb_y + y) *
1936 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
1937 (block_height * mb_y + y) *
1943 int mb_type = pict->
mb_type[mb_index];
1946 #define COLOR(theta, r) \
1947 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1948 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1965 }
else if (
IS_GMC(mb_type)) {
1967 }
else if (
IS_SKIP(mb_type)) {
1978 u *= 0x0101010101010101ULL;
1979 v *= 0x0101010101010101ULL;
1980 for (y = 0; y < block_height; y++) {
1981 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1982 (block_height * mb_y + y) * pict->
linesize[1]) = u;
1983 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
1984 (block_height * mb_y + y) * pict->
linesize[2]) = v;
1989 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 0 +
1990 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
1991 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 8 +
1992 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
1995 for (y = 0; y < 16; y++)
1996 pict->
data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1999 if (
IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2000 int dm = 1 << (mv_sample_log2 - 2);
2001 for (i = 0; i < 4; i++) {
2002 int sx = mb_x * 16 + 8 * (i & 1);
2003 int sy = mb_y * 16 + 8 * (i >> 1);
2004 int xy = (mb_x * 2 + (i & 1) +
2005 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2008 if (mv[0] != mv[dm] ||
2009 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2010 for (y = 0; y < 8; y++)
2011 pict->
data[0][sx + 4 + (sy + y) * pict->
linesize[0]] ^= 0x80;
2012 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2013 *(uint64_t *)(pict->
data[0] + sx + (sy + 4) *
2014 pict->
linesize[0]) ^= 0x8080808080808080ULL;
2034 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->
quarter_sample;
2035 int my,
off, i, mvs;
2054 for (i = 0; i < mvs; i++) {
2055 my = s->
mv[dir][i][1]<<qpel_shift;
2056 my_max =
FFMAX(my_max, my);
2057 my_min =
FFMIN(my_min, my);
2060 off = (
FFMAX(-my_min, my_max) + 63) >> 6;
2107 memset(s->
ac_val[0][xy ], 0, 32 *
sizeof(int16_t));
2108 memset(s->
ac_val[0][xy + wrap], 0, 32 *
sizeof(int16_t));
2121 memset(s->
ac_val[1][xy], 0, 16 *
sizeof(int16_t));
2122 memset(s->
ac_val[2][xy], 0, 16 *
sizeof(int16_t));
2153 for(j=0; j<64; j++){
2178 uint8_t *dest_y, *dest_cb, *dest_cr;
2179 int dct_linesize, dct_offset;
2185 const int block_size = 8;
2204 dct_offset = s->
interlaced_dct ? linesize : linesize * block_size;
2208 dest_cb= s->
dest[1];
2209 dest_cr= s->
dest[2];
2280 add_dct(s, block[0], 0, dest_y , dct_linesize);
2281 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2282 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2283 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2287 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2288 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2294 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2295 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2296 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2297 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2299 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2300 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2301 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2302 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2314 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->
qscale);
2315 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->
qscale);
2316 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->
qscale);
2333 s->
dsp.
idct_put(dest_y + block_size, dct_linesize, block[1]);
2334 s->
dsp.
idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2335 s->
dsp.
idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2348 s->
dsp.
idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2349 s->
dsp.
idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2351 s->
dsp.
idct_put(dest_cb + 8, dct_linesize, block[8]);
2352 s->
dsp.
idct_put(dest_cr + 8, dct_linesize, block[9]);
2353 s->
dsp.
idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2354 s->
dsp.
idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2395 int sides = 0, edge_h;
2451 const int mb_size= 4;
2468 s->
dest[0] += s->
mb_y * linesize << mb_size;
2472 s->
dest[0] += (s->
mb_y>>1) * linesize << mb_size;
2510 int i,
level, nCoeffs;
2511 const uint16_t *quant_matrix;
2521 for(i=1;i<=nCoeffs;i++) {
2527 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2528 level = (level - 1) | 1;
2531 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2532 level = (level - 1) | 1;
2542 int i,
level, nCoeffs;
2543 const uint16_t *quant_matrix;
2548 for(i=0; i<=nCoeffs; i++) {
2554 level = (((level << 1) + 1) * qscale *
2555 ((int) (quant_matrix[j]))) >> 4;
2556 level = (level - 1) | 1;
2559 level = (((level << 1) + 1) * qscale *
2560 ((int) (quant_matrix[j]))) >> 4;
2561 level = (level - 1) | 1;
2571 int i,
level, nCoeffs;
2572 const uint16_t *quant_matrix;
2582 for(i=1;i<=nCoeffs;i++) {
2588 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2591 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2601 int i,
level, nCoeffs;
2602 const uint16_t *quant_matrix;
2613 for(i=1;i<=nCoeffs;i++) {
2619 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2622 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2634 int i,
level, nCoeffs;
2635 const uint16_t *quant_matrix;
2642 for(i=0; i<=nCoeffs; i++) {
2648 level = (((level << 1) + 1) * qscale *
2649 ((int) (quant_matrix[j]))) >> 4;
2652 level = (((level << 1) + 1) * qscale *
2653 ((int) (quant_matrix[j]))) >> 4;
2665 int i,
level, qmul, qadd;
2677 qadd = (qscale - 1) | 1;
2686 for(i=1; i<=nCoeffs; i++) {
2690 level = level * qmul - qadd;
2692 level = level * qmul + qadd;
2702 int i,
level, qmul, qadd;
2707 qadd = (qscale - 1) | 1;
2712 for(i=0; i<=nCoeffs; i++) {
2716 level = level * qmul - qadd;
2718 level = level * qmul + qadd;
2732 else if (qscale > 31)