71 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
72 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
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,
83 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
84 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
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,
95 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
96 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
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,
107 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
108 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
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,
119 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
120 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
153 for (i = 0; i < 3; i++) {
154 uint32_t tmp = *state << 8;
155 *state = tmp + *(p++);
156 if (tmp == 0x100 || p == end)
161 if (p[-1] > 1 ) p += 3;
162 else if (p[-2] ) p += 2;
163 else if (p[-3]|(p[-1]-1)) p++;
170 p =
FFMIN(p, end) - 4;
266 if (r < 0 || !pic->
f.type || !pic->
f.
data[0]) {
276 "get_buffer() failed (stride changed)\n");
283 "get_buffer() failed (uv stride mismatch)\n");
308 assert(pic->
f.
data[0]);
312 assert(!pic->
f.
data[0]);
324 mb_array_size *
sizeof(int16_t), fail)
326 mb_array_size *
sizeof(int16_t), fail)
328 mb_array_size *
sizeof(int8_t ), fail)
332 mb_array_size *
sizeof(uint8_t) + 2, fail)
334 (big_mb_num + s->
mb_stride) *
sizeof(uint8_t),
337 (big_mb_num + s->
mb_stride) *
sizeof(uint32_t),
342 for (i = 0; i < 2; i++) {
344 2 * (b4_array_size + 4) *
sizeof(int16_t),
348 4 * mb_array_size *
sizeof(uint8_t), fail)
353 for (i = 0; i < 2; i++) {
355 2 * (b8_array_size + 4) *
sizeof(int16_t),
359 4 * mb_array_size *
sizeof(uint8_t), fail)
365 64 * mb_array_size *
sizeof(
DCTELEM) * 6, fail)
401 for (i = 0; i < 2; i++) {
407 for (i = 0; i < 4; i++) {
419 int yc_size = y_size + 2 * c_size;
425 (s->
width + 64) * 2 * 21 * 2, fail);
430 (s->
width + 64) * 4 * 16 * 2 *
sizeof(uint8_t), fail)
442 2 * 64 *
sizeof(
int), fail)
448 for (i = 0; i < 12; i++) {
455 yc_size *
sizeof(int16_t) * 16, fail);
488 #define COPY(a) bak->a = src->a
489 COPY(edge_emu_buffer);
494 COPY(obmc_scratchpad);
501 COPY(me.map_generation);
522 for (i = 0; i < 12; i++) {
534 if (dst == src || !
s1->context_initialized)
562 (
char *) &
s1->last_picture_ptr - (
char *) &
s1->last_picture);
574 (
char *) &
s1->shape - (
char *) &
s1->time_increment_bits);
584 if (
s1->bitstream_buffer) {
585 if (
s1->bitstream_buffer_size +
589 s1->allocated_bitstream_buffer_size);
592 s1->bitstream_buffer_size);
599 (
char *) &
s1->rtp_mode - (
char *) &
s1->progressive_sequence);
601 if (!
s1->first_field) {
603 if (
s1->current_picture_ptr)
660 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
675 "decoding to PIX_FMT_NONE is not supported.\n");
686 " reducing to %d\n", nb_slices, max_slices);
687 nb_slices = max_slices;
727 yc_size = y_size + 2 * c_size;
748 mv_table_size * 2 *
sizeof(int16_t), fail);
750 mv_table_size * 2 *
sizeof(int16_t), fail);
752 mv_table_size * 2 *
sizeof(int16_t), fail);
754 mv_table_size * 2 *
sizeof(int16_t), fail);
756 mv_table_size * 2 *
sizeof(int16_t), fail);
758 mv_table_size * 2 *
sizeof(int16_t), fail);
775 (
MAX_RUN + 1) * 2 *
sizeof(
int), fail);
781 sizeof(uint16_t), fail);
787 64 * 32 *
sizeof(
int), fail);
789 64 * 32 *
sizeof(
int), fail);
791 64 * 32 * 2 *
sizeof(uint16_t), fail);
793 64 * 32 * 2 *
sizeof(uint16_t), fail);
801 2 * 64 *
sizeof(uint16_t), fail);
815 mb_array_size *
sizeof(uint8_t), fail);
820 for (i = 0; i < 2; i++) {
822 for (j = 0; j < 2; j++) {
823 for (k = 0; k < 2; k++) {
826 mv_table_size * 2 *
sizeof(int16_t),
832 mb_array_size * 2 *
sizeof(uint8_t),
835 mv_table_size * 2 *
sizeof(int16_t),
841 mb_array_size * 2 *
sizeof(uint8_t),
852 mb_array_size *
sizeof(uint8_t), fail);
854 mb_array_size *
sizeof(uint8_t), fail);
861 yc_size *
sizeof(int16_t), fail);
865 for (i = 0; i < yc_size; i++)
894 for (i = 1; i < nb_slices; i++) {
899 for (i = 0; i < nb_slices; i++) {
903 (s->
mb_height * (i) + nb_slices / 2) / nb_slices;
905 (s->
mb_height * (i + 1) + nb_slices / 2) / nb_slices;
953 for (i = 0; i < 2; i++) {
954 for (j = 0; j < 2; j++) {
955 for (k = 0; k < 2; k++) {
1001 for (i = 0; i < 3; i++)
1012 uint8_t index_run[
MAX_RUN + 1];
1013 int last,
run,
level, start, end, i;
1020 for (last = 0; last < 2; last++) {
1029 memset(max_level, 0,
MAX_RUN + 1);
1031 memset(index_run, rl->
n,
MAX_RUN + 1);
1032 for (i = start; i < end; i++) {
1035 if (index_run[run] == rl->
n)
1037 if (level > max_level[run])
1039 if (run > max_run[level])
1043 rl->
max_level[last] = static_store[last];
1056 memcpy(rl->
index_run[last], index_run, MAX_RUN + 1);
1064 for (q = 0; q < 32; q++) {
1066 int qadd = (q - 1) | 1;
1080 }
else if (len < 0) {
1084 if (code == rl->
n) {
1090 if (code >= rl->
last) run += 192;
1142 for (intra = 0; intra < 2; intra++) {
1144 for (i = 0; i < 64; i++) {
1150 for (i = 0; i < 64; i++) {
1191 "releasing zombie picture\n");
1264 "warning: first frame is no keyframe\n");
1267 "allocate dummy last picture for field based first keyframe\n");
1312 for (i = 0; i < 4; i++) {
1397 assert(i < MAX_PICTURE_COUNT);
1429 static void draw_line(uint8_t *buf,
int sx,
int sy,
int ex,
int ey,
1434 sx = av_clip(sx, 0, w - 1);
1435 sy = av_clip(sy, 0, h - 1);
1436 ex = av_clip(ex, 0, w - 1);
1437 ey = av_clip(ey, 0, h - 1);
1439 buf[sy * stride + sx] +=
color;
1448 f = ((ey - sy) << 16) / ex;
1449 for (x = 0; x = ex; x++) {
1451 fr = (x *
f) & 0xFFFF;
1452 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1453 buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1463 f = ((ex - sx) << 16) / ey;
1466 for (y = 0; y = ey; y++) {
1468 fr = (y *
f) & 0xFFFF;
1469 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1470 buf[y * stride + x + 1] += (color * fr ) >> 16;
1487 sx = av_clip(sx, -100, w + 100);
1488 sy = av_clip(sy, -100, h + 100);
1489 ex = av_clip(ex, -100, w + 100);
1490 ey = av_clip(ey, -100, h + 100);
1495 if (dx * dx + dy * dy > 3 * 3) {
1498 int length =
ff_sqrt((rx * rx + ry * ry) << 8);
1504 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1505 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1507 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1543 for (x = 0; x < s->
mb_width; x++) {
1571 else if (
IS_GMC(mb_type))
1614 int h_chroma_shift, v_chroma_shift, block_height;
1618 const int mv_stride = (s->
mb_width << mv_sample_log2) +
1623 &h_chroma_shift, &v_chroma_shift);
1624 for (i = 0; i < 3; i++) {
1626 (i == 0) ? pict->
linesize[i] * height:
1627 pict->
linesize[i] * height >> v_chroma_shift);
1631 ptr = pict->
data[0];
1632 block_height = 16 >> v_chroma_shift;
1634 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1636 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1637 const int mb_index = mb_x + mb_y * s->
mb_stride;
1640 for (type = 0; type < 3; type++) {
1667 for (i = 0; i < 4; i++) {
1668 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1669 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1670 int xy = (mb_x * 2 + (i & 1) +
1671 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1672 int mx = (pict->
motion_val[direction][xy][0] >> shift) + sx;
1673 int my = (pict->
motion_val[direction][xy][1] >> shift) + sy;
1679 for (i = 0; i < 2; i++) {
1680 int sx = mb_x * 16 + 8;
1681 int sy = mb_y * 16 + 4 + 8 * i;
1682 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1683 int mx = (pict->
motion_val[direction][xy][0] >> shift);
1684 int my = (pict->
motion_val[direction][xy][1] >> shift);
1689 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1694 for (i = 0; i < 2; i++) {
1695 int sx = mb_x * 16 + 4 + 8 * i;
1696 int sy = mb_y * 16 + 8;
1697 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1698 int mx = pict->
motion_val[direction][xy][0] >> shift;
1699 int my = pict->
motion_val[direction][xy][1] >> shift;
1704 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1708 int sx = mb_x * 16 + 8;
1709 int sy = mb_y * 16 + 8;
1710 int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
1711 int mx = pict->
motion_val[direction][xy][0] >> shift + sx;
1712 int my = pict->
motion_val[direction][xy][1] >> shift + sy;
1718 uint64_t c = (pict->
qscale_table[mb_index] * 128 / 31) *
1719 0x0101010101010101ULL;
1721 for (y = 0; y < block_height; y++) {
1722 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1723 (block_height * mb_y + y) *
1725 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
1726 (block_height * mb_y + y) *
1732 int mb_type = pict->
mb_type[mb_index];
1735 #define COLOR(theta, r) \
1736 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1737 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1754 }
else if (
IS_GMC(mb_type)) {
1756 }
else if (
IS_SKIP(mb_type)) {
1767 u *= 0x0101010101010101ULL;
1768 v *= 0x0101010101010101ULL;
1769 for (y = 0; y < block_height; y++) {
1770 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1771 (block_height * mb_y + y) * pict->
linesize[1]) = u;
1772 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
1773 (block_height * mb_y + y) * pict->
linesize[2]) = v;
1778 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 0 +
1779 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
1780 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 8 +
1781 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
1784 for (y = 0; y < 16; y++)
1785 pict->
data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1788 if (
IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1789 int dm = 1 << (mv_sample_log2 - 2);
1790 for (i = 0; i < 4; i++) {
1791 int sx = mb_x * 16 + 8 * (i & 1);
1792 int sy = mb_y * 16 + 8 * (i >> 1);
1793 int xy = (mb_x * 2 + (i & 1) +
1794 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1797 if (mv[0] != mv[dm] ||
1798 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1799 for (y = 0; y < 8; y++)
1800 pict->
data[0][sx + 4 + (sy + y) * pict->
linesize[0]] ^= 0x80;
1801 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1802 *(uint64_t *)(pict->
data[0] + sx + (sy + 4) *
1803 pict->
linesize[0]) ^= 0x8080808080808080ULL;
1819 uint8_t *dest, uint8_t *src,
1820 int field_based,
int field_select,
1821 int src_x,
int src_y,
1823 int h_edge_pos,
int v_edge_pos,
1825 int motion_x,
int motion_y)
1828 const int op_index =
FFMIN(lowres, 2);
1829 const int s_mask = (2 <<
lowres) - 1;
1838 sx = motion_x & s_mask;
1839 sy = motion_y & s_mask;
1840 src_x += motion_x >> lowres + 1;
1841 src_y += motion_y >> lowres + 1;
1843 src += src_y * stride + src_x;
1845 if ((
unsigned)src_x >
FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1846 (unsigned)src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1848 (h + 1) << field_based, src_x,
1849 src_y << field_based,
1856 sx = (sx << 2) >>
lowres;
1857 sy = (sy << 2) >>
lowres;
1860 pix_op[op_index](dest, src,
stride, h, sx, sy);
1872 uint8_t **ref_picture,
1874 int motion_x,
int motion_y,
1877 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1878 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
1881 const int op_index =
FFMIN(lowres, 2);
1882 const int block_s = 8>>
lowres;
1883 const int s_mask = (2 <<
lowres) - 1;
1896 motion_y += (bottom_field - field_select) * (1 << lowres - 1);
1899 sx = motion_x & s_mask;
1900 sy = motion_y & s_mask;
1901 src_x = s->
mb_x * 2 * block_s + (motion_x >> lowres + 1);
1902 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1905 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1906 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1907 uvsrc_x = src_x >> 1;
1908 uvsrc_y = src_y >> 1;
1913 uvsx = (2 * mx) & s_mask;
1914 uvsy = (2 * my) & s_mask;
1915 uvsrc_x = s->
mb_x * block_s + (mx >>
lowres);
1916 uvsrc_y = mb_y * block_s + (my >>
lowres);
1922 uvsrc_x = s->
mb_x * block_s + (mx >> lowres + 1);
1923 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1926 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1927 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1928 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1930 if ((
unsigned) src_x >
FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
1931 (unsigned) src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1934 src_x, src_y << field_based, h_edge_pos,
1941 uvsrc_x, uvsrc_y << field_based,
1942 h_edge_pos >> 1, v_edge_pos >> 1);
1945 uvsrc_x, uvsrc_y << field_based,
1946 h_edge_pos >> 1, v_edge_pos >> 1);
1948 ptr_cr = uvbuf + 16;
1965 sx = (sx << 2) >>
lowres;
1966 sy = (sy << 2) >>
lowres;
1967 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1970 uvsx = (uvsx << 2) >>
lowres;
1971 uvsy = (uvsy << 2) >>
lowres;
1972 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->
chroma_y_shift,
1974 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->
chroma_y_shift,
1981 uint8_t *dest_cb, uint8_t *dest_cr,
1982 uint8_t **ref_picture,
1987 const int op_index =
FFMIN(lowres, 2);
1988 const int block_s = 8 >>
lowres;
1989 const int s_mask = (2 <<
lowres) - 1;
1990 const int h_edge_pos = s->
h_edge_pos >> lowres + 1;
1991 const int v_edge_pos = s->
v_edge_pos >> lowres + 1;
1992 int emu = 0, src_x, src_y, offset, sx, sy;
2007 src_x = s->
mb_x * block_s + (mx >> lowres + 1);
2008 src_y = s->
mb_y * block_s + (my >> lowres + 1);
2011 ptr = ref_picture[1] + offset;
2013 if ((
unsigned) src_x >
FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2014 (unsigned) src_y >
FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2016 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2021 sx = (sx << 2) >>
lowres;
2022 sy = (sy << 2) >>
lowres;
2023 pix_op[op_index](dest_cb, ptr, s->
uvlinesize, block_s, sx, sy);
2025 ptr = ref_picture[2] + offset;
2028 src_x, src_y, h_edge_pos, v_edge_pos);
2031 pix_op[op_index](dest_cr, ptr, s->
uvlinesize, block_s, sx, sy);
2046 uint8_t *dest_y, uint8_t *dest_cb,
2048 int dir, uint8_t **ref_picture,
2054 const int block_s = 8 >>
lowres;
2063 ref_picture, pix_op,
2064 s->
mv[dir][0][0], s->
mv[dir][0][1],
2070 for (i = 0; i < 4; i++) {
2073 ref_picture[0], 0, 0,
2074 (2 * mb_x + (i & 1)) * block_s,
2075 (2 * mb_y + (i >> 1)) * block_s,
2078 block_s, block_s, pix_op,
2079 s->
mv[dir][i][0], s->
mv[dir][i][1]);
2081 mx += s->
mv[dir][i][0];
2082 my += s->
mv[dir][i][1];
2094 ref_picture, pix_op,
2095 s->
mv[dir][0][0], s->
mv[dir][0][1],
2100 ref_picture, pix_op,
2101 s->
mv[dir][1][0], s->
mv[dir][1][1],
2111 ref_picture, pix_op,
2113 s->
mv[dir][0][1], 2 * block_s, mb_y >> 1);
2117 for (i = 0; i < 2; i++) {
2118 uint8_t **ref2picture;
2122 ref2picture = ref_picture;
2129 ref2picture, pix_op,
2130 s->
mv[dir][i][0], s->
mv[dir][i][1] +
2131 2 * block_s * i, block_s, mb_y >> 1);
2133 dest_y += 2 * block_s * s->
linesize;
2140 for (i = 0; i < 2; i++) {
2142 for (j = 0; j < 2; j++) {
2145 ref_picture, pix_op,
2146 s->
mv[dir][2 * i + j][0],
2147 s->
mv[dir][2 * i + j][1],
2153 for (i = 0; i < 2; i++) {
2156 ref_picture, pix_op,
2157 s->
mv[dir][2 * i][0],s->
mv[dir][2 * i][1],
2158 2 * block_s, mb_y >> 1);
2181 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->
quarter_sample;
2182 int my,
off, i, mvs;
2200 for (i = 0; i < mvs; i++) {
2201 my = s->
mv[dir][i][1]<<qpel_shift;
2202 my_max =
FFMAX(my_max, my);
2203 my_min =
FFMIN(my_min, my);
2206 off = (
FFMAX(-my_min, my_max) + 63) >> 6;
2215 DCTELEM *
block,
int i, uint8_t *dest,
int line_size,
int qscale)
2231 DCTELEM *
block,
int i, uint8_t *dest,
int line_size,
int qscale)
2253 memset(s->
ac_val[0][xy ], 0, 32 *
sizeof(int16_t));
2254 memset(s->
ac_val[0][xy + wrap], 0, 32 *
sizeof(int16_t));
2267 memset(s->
ac_val[1][xy], 0, 16 *
sizeof(int16_t));
2268 memset(s->
ac_val[2][xy], 0, 16 *
sizeof(int16_t));
2285 int lowres_flag,
int is_mpeg12)
2299 for(j=0; j<64; j++){
2324 uint8_t *dest_y, *dest_cb, *dest_cr;
2325 int dct_linesize, dct_offset;
2331 const int block_size= lowres_flag ? 8>>s->
avctx->
lowres : 8;
2350 dct_offset = s->
interlaced_dct ? linesize : linesize * block_size;
2354 dest_cb= s->
dest[1];
2355 dest_cr= s->
dest[2];
2434 add_dct(s, block[0], 0, dest_y , dct_linesize);
2435 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2436 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2437 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2441 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2442 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2448 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2449 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2450 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2451 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2453 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2454 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2455 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2456 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2468 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->
qscale);
2469 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->
qscale);
2470 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->
qscale);
2487 s->
dsp.
idct_put(dest_y + block_size, dct_linesize, block[1]);
2488 s->
dsp.
idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2489 s->
dsp.
idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2502 s->
dsp.
idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2503 s->
dsp.
idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2505 s->
dsp.
idct_put(dest_cb + 8, dct_linesize, block[8]);
2506 s->
dsp.
idct_put(dest_cr + 8, dct_linesize, block[9]);
2507 s->
dsp.
idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2508 s->
dsp.
idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2550 int sides = 0, edge_h;
2623 s->
dest[0] += s->
mb_y * linesize << mb_size;
2627 s->
dest[0] += (s->
mb_y>>1) * linesize << mb_size;
2665 int i,
level, nCoeffs;
2666 const uint16_t *quant_matrix;
2676 for(i=1;i<=nCoeffs;i++) {
2682 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2683 level = (level - 1) | 1;
2686 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2687 level = (level - 1) | 1;
2697 int i,
level, nCoeffs;
2698 const uint16_t *quant_matrix;
2703 for(i=0; i<=nCoeffs; i++) {
2709 level = (((level << 1) + 1) * qscale *
2710 ((int) (quant_matrix[j]))) >> 4;
2711 level = (level - 1) | 1;
2714 level = (((level << 1) + 1) * qscale *
2715 ((int) (quant_matrix[j]))) >> 4;
2716 level = (level - 1) | 1;
2726 int i,
level, nCoeffs;
2727 const uint16_t *quant_matrix;
2737 for(i=1;i<=nCoeffs;i++) {
2743 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2746 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2756 int i,
level, nCoeffs;
2757 const uint16_t *quant_matrix;
2768 for(i=1;i<=nCoeffs;i++) {
2774 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2777 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2789 int i,
level, nCoeffs;
2790 const uint16_t *quant_matrix;
2797 for(i=0; i<=nCoeffs; i++) {
2803 level = (((level << 1) + 1) * qscale *
2804 ((int) (quant_matrix[j]))) >> 4;
2807 level = (((level << 1) + 1) * qscale *
2808 ((int) (quant_matrix[j]))) >> 4;
2820 int i,
level, qmul, qadd;
2832 qadd = (qscale - 1) | 1;
2841 for(i=1; i<=nCoeffs; i++) {
2845 level = level * qmul - qadd;
2847 level = level * qmul + qadd;
2857 int i,
level, qmul, qadd;
2862 qadd = (qscale - 1) | 1;
2867 for(i=0; i<=nCoeffs; i++) {
2871 level = level * qmul - qadd;
2873 level = level * qmul + qadd;
2887 else if (qscale > 31)