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++) {
1191 "releasing zombie picture\n");
1264 "warning: first frame is no keyframe\n");
1267 "allocate dummy last picture for field based first keyframe\n");
1320 for (i = 0; i < 4; i++) {
1405 assert(i < MAX_PICTURE_COUNT);
1437 static void draw_line(uint8_t *buf,
int sx,
int sy,
int ex,
int ey,
1442 sx = av_clip(sx, 0, w - 1);
1443 sy = av_clip(sy, 0, h - 1);
1444 ex = av_clip(ex, 0, w - 1);
1445 ey = av_clip(ey, 0, h - 1);
1447 buf[sy * stride + sx] +=
color;
1456 f = ((ey - sy) << 16) / ex;
1457 for (x = 0; x = ex; x++) {
1459 fr = (x *
f) & 0xFFFF;
1460 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1461 buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1471 f = ((ex - sx) << 16) / ey;
1474 for (y = 0; y = ey; y++) {
1476 fr = (y *
f) & 0xFFFF;
1477 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1478 buf[y * stride + x + 1] += (color * fr ) >> 16;
1495 sx = av_clip(sx, -100, w + 100);
1496 sy = av_clip(sy, -100, h + 100);
1497 ex = av_clip(ex, -100, w + 100);
1498 ey = av_clip(ey, -100, h + 100);
1503 if (dx * dx + dy * dy > 3 * 3) {
1506 int length =
ff_sqrt((rx * rx + ry * ry) << 8);
1512 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1513 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1515 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1551 for (x = 0; x < s->
mb_width; x++) {
1579 else if (
IS_GMC(mb_type))
1622 int h_chroma_shift, v_chroma_shift, block_height;
1626 const int mv_stride = (s->
mb_width << mv_sample_log2) +
1631 &h_chroma_shift, &v_chroma_shift);
1632 for (i = 0; i < 3; i++) {
1634 (i == 0) ? pict->
linesize[i] * height:
1635 pict->
linesize[i] * height >> v_chroma_shift);
1639 ptr = pict->
data[0];
1640 block_height = 16 >> v_chroma_shift;
1642 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1644 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1645 const int mb_index = mb_x + mb_y * s->
mb_stride;
1648 for (type = 0; type < 3; type++) {
1675 for (i = 0; i < 4; i++) {
1676 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1677 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1678 int xy = (mb_x * 2 + (i & 1) +
1679 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1680 int mx = (pict->
motion_val[direction][xy][0] >> shift) + sx;
1681 int my = (pict->
motion_val[direction][xy][1] >> shift) + sy;
1687 for (i = 0; i < 2; i++) {
1688 int sx = mb_x * 16 + 8;
1689 int sy = mb_y * 16 + 4 + 8 * i;
1690 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1691 int mx = (pict->
motion_val[direction][xy][0] >> shift);
1692 int my = (pict->
motion_val[direction][xy][1] >> shift);
1697 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1702 for (i = 0; i < 2; i++) {
1703 int sx = mb_x * 16 + 4 + 8 * i;
1704 int sy = mb_y * 16 + 8;
1705 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1706 int mx = pict->
motion_val[direction][xy][0] >> shift;
1707 int my = pict->
motion_val[direction][xy][1] >> shift;
1712 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1716 int sx = mb_x * 16 + 8;
1717 int sy = mb_y * 16 + 8;
1718 int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
1719 int mx = pict->
motion_val[direction][xy][0] >> shift + sx;
1720 int my = pict->
motion_val[direction][xy][1] >> shift + sy;
1726 uint64_t c = (pict->
qscale_table[mb_index] * 128 / 31) *
1727 0x0101010101010101ULL;
1729 for (y = 0; y < block_height; y++) {
1730 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1731 (block_height * mb_y + y) *
1733 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
1734 (block_height * mb_y + y) *
1740 int mb_type = pict->
mb_type[mb_index];
1743 #define COLOR(theta, r) \
1744 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1745 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1762 }
else if (
IS_GMC(mb_type)) {
1764 }
else if (
IS_SKIP(mb_type)) {
1775 u *= 0x0101010101010101ULL;
1776 v *= 0x0101010101010101ULL;
1777 for (y = 0; y < block_height; y++) {
1778 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1779 (block_height * mb_y + y) * pict->
linesize[1]) = u;
1780 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
1781 (block_height * mb_y + y) * pict->
linesize[2]) = v;
1786 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 0 +
1787 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
1788 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 8 +
1789 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
1792 for (y = 0; y < 16; y++)
1793 pict->
data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1796 if (
IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1797 int dm = 1 << (mv_sample_log2 - 2);
1798 for (i = 0; i < 4; i++) {
1799 int sx = mb_x * 16 + 8 * (i & 1);
1800 int sy = mb_y * 16 + 8 * (i >> 1);
1801 int xy = (mb_x * 2 + (i & 1) +
1802 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1805 if (mv[0] != mv[dm] ||
1806 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1807 for (y = 0; y < 8; y++)
1808 pict->
data[0][sx + 4 + (sy + y) * pict->
linesize[0]] ^= 0x80;
1809 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1810 *(uint64_t *)(pict->
data[0] + sx + (sy + 4) *
1811 pict->
linesize[0]) ^= 0x8080808080808080ULL;
1827 uint8_t *dest, uint8_t *src,
1828 int field_based,
int field_select,
1829 int src_x,
int src_y,
1831 int h_edge_pos,
int v_edge_pos,
1833 int motion_x,
int motion_y)
1836 const int op_index =
FFMIN(lowres, 2);
1837 const int s_mask = (2 <<
lowres) - 1;
1846 sx = motion_x & s_mask;
1847 sy = motion_y & s_mask;
1848 src_x += motion_x >> lowres + 1;
1849 src_y += motion_y >> lowres + 1;
1851 src += src_y * stride + src_x;
1853 if ((
unsigned)src_x >
FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1854 (unsigned)src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1856 (h + 1) << field_based, src_x,
1857 src_y << field_based,
1864 sx = (sx << 2) >>
lowres;
1865 sy = (sy << 2) >>
lowres;
1868 pix_op[op_index](dest, src,
stride, h, sx, sy);
1880 uint8_t **ref_picture,
1882 int motion_x,
int motion_y,
1885 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1886 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
1889 const int op_index =
FFMIN(lowres, 2);
1890 const int block_s = 8>>
lowres;
1891 const int s_mask = (2 <<
lowres) - 1;
1904 motion_y += (bottom_field - field_select) * (1 << lowres - 1);
1907 sx = motion_x & s_mask;
1908 sy = motion_y & s_mask;
1909 src_x = s->
mb_x * 2 * block_s + (motion_x >> lowres + 1);
1910 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1913 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1914 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1915 uvsrc_x = src_x >> 1;
1916 uvsrc_y = src_y >> 1;
1921 uvsx = (2 * mx) & s_mask;
1922 uvsy = (2 * my) & s_mask;
1923 uvsrc_x = s->
mb_x * block_s + (mx >>
lowres);
1924 uvsrc_y = mb_y * block_s + (my >>
lowres);
1930 uvsrc_x = s->
mb_x * block_s + (mx >> lowres + 1);
1931 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1934 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1935 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1936 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1938 if ((
unsigned) src_x >
FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
1939 (unsigned) src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1942 src_x, src_y << field_based, h_edge_pos,
1949 uvsrc_x, uvsrc_y << field_based,
1950 h_edge_pos >> 1, v_edge_pos >> 1);
1953 uvsrc_x, uvsrc_y << field_based,
1954 h_edge_pos >> 1, v_edge_pos >> 1);
1956 ptr_cr = uvbuf + 16;
1973 sx = (sx << 2) >>
lowres;
1974 sy = (sy << 2) >>
lowres;
1975 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1978 uvsx = (uvsx << 2) >>
lowres;
1979 uvsy = (uvsy << 2) >>
lowres;
1980 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->
chroma_y_shift,
1982 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->
chroma_y_shift,
1989 uint8_t *dest_cb, uint8_t *dest_cr,
1990 uint8_t **ref_picture,
1995 const int op_index =
FFMIN(lowres, 2);
1996 const int block_s = 8 >>
lowres;
1997 const int s_mask = (2 <<
lowres) - 1;
1998 const int h_edge_pos = s->
h_edge_pos >> lowres + 1;
1999 const int v_edge_pos = s->
v_edge_pos >> lowres + 1;
2000 int emu = 0, src_x, src_y, offset, sx, sy;
2015 src_x = s->
mb_x * block_s + (mx >> lowres + 1);
2016 src_y = s->
mb_y * block_s + (my >> lowres + 1);
2019 ptr = ref_picture[1] + offset;
2021 if ((
unsigned) src_x >
FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2022 (unsigned) src_y >
FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2024 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2029 sx = (sx << 2) >>
lowres;
2030 sy = (sy << 2) >>
lowres;
2031 pix_op[op_index](dest_cb, ptr, s->
uvlinesize, block_s, sx, sy);
2033 ptr = ref_picture[2] + offset;
2036 src_x, src_y, h_edge_pos, v_edge_pos);
2039 pix_op[op_index](dest_cr, ptr, s->
uvlinesize, block_s, sx, sy);
2054 uint8_t *dest_y, uint8_t *dest_cb,
2056 int dir, uint8_t **ref_picture,
2062 const int block_s = 8 >>
lowres;
2071 ref_picture, pix_op,
2072 s->
mv[dir][0][0], s->
mv[dir][0][1],
2078 for (i = 0; i < 4; i++) {
2081 ref_picture[0], 0, 0,
2082 (2 * mb_x + (i & 1)) * block_s,
2083 (2 * mb_y + (i >> 1)) * block_s,
2086 block_s, block_s, pix_op,
2087 s->
mv[dir][i][0], s->
mv[dir][i][1]);
2089 mx += s->
mv[dir][i][0];
2090 my += s->
mv[dir][i][1];
2102 ref_picture, pix_op,
2103 s->
mv[dir][0][0], s->
mv[dir][0][1],
2108 ref_picture, pix_op,
2109 s->
mv[dir][1][0], s->
mv[dir][1][1],
2119 ref_picture, pix_op,
2121 s->
mv[dir][0][1], 2 * block_s, mb_y >> 1);
2125 for (i = 0; i < 2; i++) {
2126 uint8_t **ref2picture;
2130 ref2picture = ref_picture;
2137 ref2picture, pix_op,
2138 s->
mv[dir][i][0], s->
mv[dir][i][1] +
2139 2 * block_s * i, block_s, mb_y >> 1);
2141 dest_y += 2 * block_s * s->
linesize;
2148 for (i = 0; i < 2; i++) {
2150 for (j = 0; j < 2; j++) {
2153 ref_picture, pix_op,
2154 s->
mv[dir][2 * i + j][0],
2155 s->
mv[dir][2 * i + j][1],
2161 for (i = 0; i < 2; i++) {
2164 ref_picture, pix_op,
2165 s->
mv[dir][2 * i][0],s->
mv[dir][2 * i][1],
2166 2 * block_s, mb_y >> 1);
2189 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->
quarter_sample;
2190 int my,
off, i, mvs;
2208 for (i = 0; i < mvs; i++) {
2209 my = s->
mv[dir][i][1]<<qpel_shift;
2210 my_max =
FFMAX(my_max, my);
2211 my_min =
FFMIN(my_min, my);
2214 off = (
FFMAX(-my_min, my_max) + 63) >> 6;
2223 DCTELEM *
block,
int i, uint8_t *dest,
int line_size,
int qscale)
2239 DCTELEM *
block,
int i, uint8_t *dest,
int line_size,
int qscale)
2261 memset(s->
ac_val[0][xy ], 0, 32 *
sizeof(int16_t));
2262 memset(s->
ac_val[0][xy + wrap], 0, 32 *
sizeof(int16_t));
2275 memset(s->
ac_val[1][xy], 0, 16 *
sizeof(int16_t));
2276 memset(s->
ac_val[2][xy], 0, 16 *
sizeof(int16_t));
2293 int lowres_flag,
int is_mpeg12)
2307 for(j=0; j<64; j++){
2332 uint8_t *dest_y, *dest_cb, *dest_cr;
2333 int dct_linesize, dct_offset;
2339 const int block_size= lowres_flag ? 8>>s->
avctx->
lowres : 8;
2358 dct_offset = s->
interlaced_dct ? linesize : linesize * block_size;
2362 dest_cb= s->
dest[1];
2363 dest_cr= s->
dest[2];
2442 add_dct(s, block[0], 0, dest_y , dct_linesize);
2443 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2444 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2445 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2449 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2450 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2456 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2457 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2458 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2459 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2461 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2462 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2463 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2464 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2476 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->
qscale);
2477 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->
qscale);
2478 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->
qscale);
2495 s->
dsp.
idct_put(dest_y + block_size, dct_linesize, block[1]);
2496 s->
dsp.
idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2497 s->
dsp.
idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2510 s->
dsp.
idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2511 s->
dsp.
idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2513 s->
dsp.
idct_put(dest_cb + 8, dct_linesize, block[8]);
2514 s->
dsp.
idct_put(dest_cr + 8, dct_linesize, block[9]);
2515 s->
dsp.
idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2516 s->
dsp.
idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2558 int sides = 0, edge_h;
2631 s->
dest[0] += s->
mb_y * linesize << mb_size;
2635 s->
dest[0] += (s->
mb_y>>1) * linesize << mb_size;
2673 int i,
level, nCoeffs;
2674 const uint16_t *quant_matrix;
2684 for(i=1;i<=nCoeffs;i++) {
2690 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2691 level = (level - 1) | 1;
2694 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2695 level = (level - 1) | 1;
2705 int i,
level, nCoeffs;
2706 const uint16_t *quant_matrix;
2711 for(i=0; i<=nCoeffs; i++) {
2717 level = (((level << 1) + 1) * qscale *
2718 ((int) (quant_matrix[j]))) >> 4;
2719 level = (level - 1) | 1;
2722 level = (((level << 1) + 1) * qscale *
2723 ((int) (quant_matrix[j]))) >> 4;
2724 level = (level - 1) | 1;
2734 int i,
level, nCoeffs;
2735 const uint16_t *quant_matrix;
2745 for(i=1;i<=nCoeffs;i++) {
2751 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2754 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2764 int i,
level, nCoeffs;
2765 const uint16_t *quant_matrix;
2776 for(i=1;i<=nCoeffs;i++) {
2782 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2785 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2797 int i,
level, nCoeffs;
2798 const uint16_t *quant_matrix;
2805 for(i=0; i<=nCoeffs; i++) {
2811 level = (((level << 1) + 1) * qscale *
2812 ((int) (quant_matrix[j]))) >> 4;
2815 level = (((level << 1) + 1) * qscale *
2816 ((int) (quant_matrix[j]))) >> 4;
2828 int i,
level, qmul, qadd;
2840 qadd = (qscale - 1) | 1;
2849 for(i=1; i<=nCoeffs; i++) {
2853 level = level * qmul - qadd;
2855 level = level * qmul + qadd;
2865 int i,
level, qmul, qadd;
2870 qadd = (qscale - 1) | 1;
2875 for(i=0; i<=nCoeffs; i++) {
2879 level = level * qmul - qadd;
2881 level = level * qmul + qadd;
2895 else if (qscale > 31)