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;
732 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++) {
1188 "releasing zombie picture\n");
1261 "warning: first frame is no keyframe\n");
1264 "allocate dummy last picture for field based first keyframe\n");
1317 for (i = 0; i < 4; i++) {
1402 assert(i < MAX_PICTURE_COUNT);
1434 static void draw_line(uint8_t *buf,
int sx,
int sy,
int ex,
int ey,
1439 sx = av_clip(sx, 0, w - 1);
1440 sy = av_clip(sy, 0, h - 1);
1441 ex = av_clip(ex, 0, w - 1);
1442 ey = av_clip(ey, 0, h - 1);
1444 buf[sy * stride + sx] +=
color;
1453 f = ((ey - sy) << 16) / ex;
1454 for (x = 0; x = ex; x++) {
1456 fr = (x *
f) & 0xFFFF;
1457 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1458 buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1468 f = ((ex - sx) << 16) / ey;
1471 for (y = 0; y = ey; y++) {
1473 fr = (y *
f) & 0xFFFF;
1474 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1475 buf[y * stride + x + 1] += (color * fr ) >> 16;
1492 sx = av_clip(sx, -100, w + 100);
1493 sy = av_clip(sy, -100, h + 100);
1494 ex = av_clip(ex, -100, w + 100);
1495 ey = av_clip(ey, -100, h + 100);
1500 if (dx * dx + dy * dy > 3 * 3) {
1503 int length =
ff_sqrt((rx * rx + ry * ry) << 8);
1509 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1510 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1512 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1548 for (x = 0; x < s->
mb_width; x++) {
1576 else if (
IS_GMC(mb_type))
1619 int h_chroma_shift, v_chroma_shift, block_height;
1623 const int mv_stride = (s->
mb_width << mv_sample_log2) +
1628 &h_chroma_shift, &v_chroma_shift);
1629 for (i = 0; i < 3; i++) {
1631 (i == 0) ? pict->
linesize[i] * height:
1632 pict->
linesize[i] * height >> v_chroma_shift);
1636 ptr = pict->
data[0];
1637 block_height = 16 >> v_chroma_shift;
1639 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1641 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1642 const int mb_index = mb_x + mb_y * s->
mb_stride;
1645 for (type = 0; type < 3; type++) {
1672 for (i = 0; i < 4; i++) {
1673 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1674 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1675 int xy = (mb_x * 2 + (i & 1) +
1676 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1677 int mx = (pict->
motion_val[direction][xy][0] >> shift) + sx;
1678 int my = (pict->
motion_val[direction][xy][1] >> shift) + sy;
1684 for (i = 0; i < 2; i++) {
1685 int sx = mb_x * 16 + 8;
1686 int sy = mb_y * 16 + 4 + 8 * i;
1687 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1688 int mx = (pict->
motion_val[direction][xy][0] >> shift);
1689 int my = (pict->
motion_val[direction][xy][1] >> shift);
1694 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1699 for (i = 0; i < 2; i++) {
1700 int sx = mb_x * 16 + 4 + 8 * i;
1701 int sy = mb_y * 16 + 8;
1702 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1703 int mx = pict->
motion_val[direction][xy][0] >> shift;
1704 int my = pict->
motion_val[direction][xy][1] >> shift;
1709 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1713 int sx = mb_x * 16 + 8;
1714 int sy = mb_y * 16 + 8;
1715 int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
1716 int mx = pict->
motion_val[direction][xy][0] >> shift + sx;
1717 int my = pict->
motion_val[direction][xy][1] >> shift + sy;
1723 uint64_t c = (pict->
qscale_table[mb_index] * 128 / 31) *
1724 0x0101010101010101ULL;
1726 for (y = 0; y < block_height; y++) {
1727 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1728 (block_height * mb_y + y) *
1730 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
1731 (block_height * mb_y + y) *
1737 int mb_type = pict->
mb_type[mb_index];
1740 #define COLOR(theta, r) \
1741 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1742 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1759 }
else if (
IS_GMC(mb_type)) {
1761 }
else if (
IS_SKIP(mb_type)) {
1772 u *= 0x0101010101010101ULL;
1773 v *= 0x0101010101010101ULL;
1774 for (y = 0; y < block_height; y++) {
1775 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1776 (block_height * mb_y + y) * pict->
linesize[1]) = u;
1777 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
1778 (block_height * mb_y + y) * pict->
linesize[2]) = v;
1783 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 0 +
1784 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
1785 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 8 +
1786 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
1789 for (y = 0; y < 16; y++)
1790 pict->
data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1793 if (
IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1794 int dm = 1 << (mv_sample_log2 - 2);
1795 for (i = 0; i < 4; i++) {
1796 int sx = mb_x * 16 + 8 * (i & 1);
1797 int sy = mb_y * 16 + 8 * (i >> 1);
1798 int xy = (mb_x * 2 + (i & 1) +
1799 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1802 if (mv[0] != mv[dm] ||
1803 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1804 for (y = 0; y < 8; y++)
1805 pict->
data[0][sx + 4 + (sy + y) * pict->
linesize[0]] ^= 0x80;
1806 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1807 *(uint64_t *)(pict->
data[0] + sx + (sy + 4) *
1808 pict->
linesize[0]) ^= 0x8080808080808080ULL;
1824 uint8_t *dest, uint8_t *src,
1825 int field_based,
int field_select,
1826 int src_x,
int src_y,
1828 int h_edge_pos,
int v_edge_pos,
1830 int motion_x,
int motion_y)
1833 const int op_index =
FFMIN(lowres, 2);
1834 const int s_mask = (2 <<
lowres) - 1;
1843 sx = motion_x & s_mask;
1844 sy = motion_y & s_mask;
1845 src_x += motion_x >> lowres + 1;
1846 src_y += motion_y >> lowres + 1;
1848 src += src_y * stride + src_x;
1850 if ((
unsigned)src_x >
FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1851 (unsigned)src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1853 (h + 1) << field_based, src_x,
1854 src_y << field_based,
1861 sx = (sx << 2) >>
lowres;
1862 sy = (sy << 2) >>
lowres;
1865 pix_op[op_index](dest, src,
stride, h, sx, sy);
1877 uint8_t **ref_picture,
1879 int motion_x,
int motion_y,
1882 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1883 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
1886 const int op_index =
FFMIN(lowres, 2);
1887 const int block_s = 8>>
lowres;
1888 const int s_mask = (2 <<
lowres) - 1;
1901 motion_y += (bottom_field - field_select) * (1 << lowres - 1);
1904 sx = motion_x & s_mask;
1905 sy = motion_y & s_mask;
1906 src_x = s->
mb_x * 2 * block_s + (motion_x >> lowres + 1);
1907 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1910 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1911 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1912 uvsrc_x = src_x >> 1;
1913 uvsrc_y = src_y >> 1;
1918 uvsx = (2 * mx) & s_mask;
1919 uvsy = (2 * my) & s_mask;
1920 uvsrc_x = s->
mb_x * block_s + (mx >>
lowres);
1921 uvsrc_y = mb_y * block_s + (my >>
lowres);
1927 uvsrc_x = s->
mb_x * block_s + (mx >> lowres + 1);
1928 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1931 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1932 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1933 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1935 if ((
unsigned) src_x >
FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
1936 (unsigned) src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1939 src_x, src_y << field_based, h_edge_pos,
1946 uvsrc_x, uvsrc_y << field_based,
1947 h_edge_pos >> 1, v_edge_pos >> 1);
1950 uvsrc_x, uvsrc_y << field_based,
1951 h_edge_pos >> 1, v_edge_pos >> 1);
1953 ptr_cr = uvbuf + 16;
1970 sx = (sx << 2) >>
lowres;
1971 sy = (sy << 2) >>
lowres;
1972 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1975 uvsx = (uvsx << 2) >>
lowres;
1976 uvsy = (uvsy << 2) >>
lowres;
1977 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->
chroma_y_shift,
1979 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->
chroma_y_shift,
1986 uint8_t *dest_cb, uint8_t *dest_cr,
1987 uint8_t **ref_picture,
1992 const int op_index =
FFMIN(lowres, 2);
1993 const int block_s = 8 >>
lowres;
1994 const int s_mask = (2 <<
lowres) - 1;
1995 const int h_edge_pos = s->
h_edge_pos >> lowres + 1;
1996 const int v_edge_pos = s->
v_edge_pos >> lowres + 1;
1997 int emu = 0, src_x, src_y, offset, sx, sy;
2012 src_x = s->
mb_x * block_s + (mx >> lowres + 1);
2013 src_y = s->
mb_y * block_s + (my >> lowres + 1);
2016 ptr = ref_picture[1] + offset;
2018 if ((
unsigned) src_x >
FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2019 (unsigned) src_y >
FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2021 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2026 sx = (sx << 2) >>
lowres;
2027 sy = (sy << 2) >>
lowres;
2028 pix_op[op_index](dest_cb, ptr, s->
uvlinesize, block_s, sx, sy);
2030 ptr = ref_picture[2] + offset;
2033 src_x, src_y, h_edge_pos, v_edge_pos);
2036 pix_op[op_index](dest_cr, ptr, s->
uvlinesize, block_s, sx, sy);
2051 uint8_t *dest_y, uint8_t *dest_cb,
2053 int dir, uint8_t **ref_picture,
2059 const int block_s = 8 >>
lowres;
2068 ref_picture, pix_op,
2069 s->
mv[dir][0][0], s->
mv[dir][0][1],
2075 for (i = 0; i < 4; i++) {
2078 ref_picture[0], 0, 0,
2079 (2 * mb_x + (i & 1)) * block_s,
2080 (2 * mb_y + (i >> 1)) * block_s,
2083 block_s, block_s, pix_op,
2084 s->
mv[dir][i][0], s->
mv[dir][i][1]);
2086 mx += s->
mv[dir][i][0];
2087 my += s->
mv[dir][i][1];
2099 ref_picture, pix_op,
2100 s->
mv[dir][0][0], s->
mv[dir][0][1],
2105 ref_picture, pix_op,
2106 s->
mv[dir][1][0], s->
mv[dir][1][1],
2116 ref_picture, pix_op,
2118 s->
mv[dir][0][1], 2 * block_s, mb_y >> 1);
2122 for (i = 0; i < 2; i++) {
2123 uint8_t **ref2picture;
2127 ref2picture = ref_picture;
2134 ref2picture, pix_op,
2135 s->
mv[dir][i][0], s->
mv[dir][i][1] +
2136 2 * block_s * i, block_s, mb_y >> 1);
2138 dest_y += 2 * block_s * s->
linesize;
2145 for (i = 0; i < 2; i++) {
2147 for (j = 0; j < 2; j++) {
2150 ref_picture, pix_op,
2151 s->
mv[dir][2 * i + j][0],
2152 s->
mv[dir][2 * i + j][1],
2158 for (i = 0; i < 2; i++) {
2161 ref_picture, pix_op,
2162 s->
mv[dir][2 * i][0],s->
mv[dir][2 * i][1],
2163 2 * block_s, mb_y >> 1);
2186 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->
quarter_sample;
2187 int my,
off, i, mvs;
2205 for (i = 0; i < mvs; i++) {
2206 my = s->
mv[dir][i][1]<<qpel_shift;
2207 my_max =
FFMAX(my_max, my);
2208 my_min =
FFMIN(my_min, my);
2211 off = (
FFMAX(-my_min, my_max) + 63) >> 6;
2220 DCTELEM *
block,
int i, uint8_t *dest,
int line_size,
int qscale)
2236 DCTELEM *
block,
int i, uint8_t *dest,
int line_size,
int qscale)
2258 memset(s->
ac_val[0][xy ], 0, 32 *
sizeof(int16_t));
2259 memset(s->
ac_val[0][xy + wrap], 0, 32 *
sizeof(int16_t));
2272 memset(s->
ac_val[1][xy], 0, 16 *
sizeof(int16_t));
2273 memset(s->
ac_val[2][xy], 0, 16 *
sizeof(int16_t));
2290 int lowres_flag,
int is_mpeg12)
2304 for(j=0; j<64; j++){
2329 uint8_t *dest_y, *dest_cb, *dest_cr;
2330 int dct_linesize, dct_offset;
2336 const int block_size= lowres_flag ? 8>>s->
avctx->
lowres : 8;
2355 dct_offset = s->
interlaced_dct ? linesize : linesize * block_size;
2359 dest_cb= s->
dest[1];
2360 dest_cr= s->
dest[2];
2439 add_dct(s, block[0], 0, dest_y , dct_linesize);
2440 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2441 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2442 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2446 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2447 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2453 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2454 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2455 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2456 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2458 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2459 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2460 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2461 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2473 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->
qscale);
2474 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->
qscale);
2475 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->
qscale);
2492 s->
dsp.
idct_put(dest_y + block_size, dct_linesize, block[1]);
2493 s->
dsp.
idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2494 s->
dsp.
idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2507 s->
dsp.
idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2508 s->
dsp.
idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2510 s->
dsp.
idct_put(dest_cb + 8, dct_linesize, block[8]);
2511 s->
dsp.
idct_put(dest_cr + 8, dct_linesize, block[9]);
2512 s->
dsp.
idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2513 s->
dsp.
idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2555 int sides = 0, edge_h;
2628 s->
dest[0] += s->
mb_y * linesize << mb_size;
2632 s->
dest[0] += (s->
mb_y>>1) * linesize << mb_size;
2670 int i,
level, nCoeffs;
2671 const uint16_t *quant_matrix;
2681 for(i=1;i<=nCoeffs;i++) {
2687 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2688 level = (level - 1) | 1;
2691 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2692 level = (level - 1) | 1;
2702 int i,
level, nCoeffs;
2703 const uint16_t *quant_matrix;
2708 for(i=0; i<=nCoeffs; i++) {
2714 level = (((level << 1) + 1) * qscale *
2715 ((int) (quant_matrix[j]))) >> 4;
2716 level = (level - 1) | 1;
2719 level = (((level << 1) + 1) * qscale *
2720 ((int) (quant_matrix[j]))) >> 4;
2721 level = (level - 1) | 1;
2731 int i,
level, nCoeffs;
2732 const uint16_t *quant_matrix;
2742 for(i=1;i<=nCoeffs;i++) {
2748 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2751 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2761 int i,
level, nCoeffs;
2762 const uint16_t *quant_matrix;
2773 for(i=1;i<=nCoeffs;i++) {
2779 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2782 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2794 int i,
level, nCoeffs;
2795 const uint16_t *quant_matrix;
2802 for(i=0; i<=nCoeffs; i++) {
2808 level = (((level << 1) + 1) * qscale *
2809 ((int) (quant_matrix[j]))) >> 4;
2812 level = (((level << 1) + 1) * qscale *
2813 ((int) (quant_matrix[j]))) >> 4;
2825 int i,
level, qmul, qadd;
2837 qadd = (qscale - 1) | 1;
2846 for(i=1; i<=nCoeffs; i++) {
2850 level = level * qmul - qadd;
2852 level = level * qmul + qadd;
2862 int i,
level, qmul, qadd;
2867 qadd = (qscale - 1) | 1;
2872 for(i=0; i<=nCoeffs; i++) {
2876 level = level * qmul - qadd;
2878 level = level * qmul + qadd;
2892 else if (qscale > 31)