66 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
67 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
72 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
73 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
74 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
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,
84 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
85 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
86 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
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,
96 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
97 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
98 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
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,
108 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
109 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
110 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
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,
148 for (i = 0; i < 3; i++) {
149 uint32_t tmp = *state << 8;
150 *state = tmp + *(p++);
151 if (tmp == 0x100 || p == end)
156 if (p[-1] > 1 ) p += 3;
157 else if (p[-2] ) p += 2;
158 else if (p[-3]|(p[-1]-1)) p++;
165 p =
FFMIN(p, end) - 4;
286 if (r < 0 || !pic->f.type || !pic->
f.
data[0]) {
296 "get_buffer() failed (stride changed)\n");
303 "get_buffer() failed (uv stride mismatch)\n");
311 "get_buffer() failed to allocate context scratch buffers.\n");
336 assert(pic->
f.
data[0]);
340 assert(!pic->
f.
data[0]);
352 mb_array_size *
sizeof(int16_t), fail)
354 mb_array_size *
sizeof(int16_t), fail)
356 mb_array_size *
sizeof(int8_t ), fail)
360 mb_array_size *
sizeof(
uint8_t) + 2, fail)
365 (big_mb_num + s->
mb_stride) *
sizeof(uint32_t),
370 for (i = 0; i < 2; i++) {
372 2 * (b4_array_size + 4) *
sizeof(int16_t),
376 4 * mb_array_size *
sizeof(
uint8_t), fail)
381 for (i = 0; i < 2; i++) {
383 2 * (b8_array_size + 4) *
sizeof(int16_t),
387 4 * mb_array_size *
sizeof(
uint8_t), fail)
393 64 * mb_array_size *
sizeof(
DCTELEM) * 6, fail)
431 for (i = 0; i < 2; i++) {
438 for (i = 0; i < 4; i++) {
450 int yc_size = y_size + 2 * c_size;
467 2 * 64 *
sizeof(
int), fail)
473 for (i = 0; i < 12; i++) {
480 yc_size *
sizeof(int16_t) * 16, fail);
513 #define COPY(a) bak->a = src->a
514 COPY(edge_emu_buffer);
519 COPY(obmc_scratchpad);
547 for (i = 0; i < 12; i++) {
553 "scratch buffers.\n");
582 if (
s1->context_initialized){
610 (
char *) &
s1->last_picture_ptr - (
char *) &
s1->last_picture);
627 (
char *) &
s1->shape - (
char *) &
s1->time_increment_bits);
637 if (
s1->bitstream_buffer) {
638 if (
s1->bitstream_buffer_size +
642 s1->allocated_bitstream_buffer_size);
645 s1->bitstream_buffer_size);
655 "scratch buffers.\n");
660 "be allocated due to unknown size.\n");
665 (
char *) &
s1->rtp_mode - (
char *) &
s1->progressive_sequence);
667 if (!
s1->first_field) {
669 if (
s1->current_picture_ptr)
725 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
750 yc_size = y_size + 2 * c_size;
780 mb_array_size *
sizeof(
float), fail);
782 mb_array_size *
sizeof(
float), fail);
787 mb_array_size *
sizeof(
uint8_t), fail);
789 mb_array_size *
sizeof(
uint8_t), fail);
793 for (i = 0; i < 2; i++) {
795 for (j = 0; j < 2; j++) {
796 for (k = 0; k < 2; k++) {
799 mv_table_size * 2 *
sizeof(int16_t),
828 for (i = 0; i < yc_size; i++)
852 int nb_slices = (HAVE_THREADS &&
866 "decoding to AV_PIX_FMT_NONE is not supported.\n");
877 " reducing to %d\n", nb_slices, max_slices);
878 nb_slices = max_slices;
903 (
MAX_RUN + 1) * 2 *
sizeof(
int), fail);
938 for (i = 1; i < nb_slices; i++) {
943 for (i = 0; i < nb_slices; i++) {
947 (s->
mb_height * (i) + nb_slices / 2) / nb_slices;
949 (s->
mb_height * (i + 1) + nb_slices / 2) / nb_slices;
988 for (i = 0; i < 2; i++) {
989 for (j = 0; j < 2; j++) {
990 for (k = 0; k < 2; k++) {
1019 for (i = 0; i < 3; i++)
1067 if (nb_slices > 1) {
1068 for (i = 1; i < nb_slices; i++) {
1073 for (i = 0; i < nb_slices; i++) {
1077 (s->
mb_height * (i) + nb_slices / 2) / nb_slices;
1079 (s->
mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1163 for (last = 0; last < 2; last++) {
1172 memset(max_level, 0,
MAX_RUN + 1);
1174 memset(index_run, rl->
n,
MAX_RUN + 1);
1175 for (i = start; i <
end; i++) {
1178 if (index_run[run] == rl->
n)
1180 if (level > max_level[run])
1182 if (run > max_run[level])
1186 rl->
max_level[last] = static_store[last];
1199 memcpy(rl->
index_run[last], index_run, MAX_RUN + 1);
1207 for (q = 0; q < 32; q++) {
1209 int qadd = (q - 1) | 1;
1223 }
else if (len < 0) {
1227 if (code == rl->
n) {
1233 if (code >= rl->
last) run += 192;
1289 "Internal error, picture buffer overflow\n");
1309 if (ret >= 0 && ret < s->picture_range_end) {
1323 for (intra = 0; intra < 2; intra++) {
1325 for (i = 0; i < 64; i++) {
1331 for (i = 0; i < 64; i++) {
1374 "releasing zombie picture\n");
1437 av_dlog(s->
avctx,
"L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1451 "warning: first frame is no keyframe\n");
1454 "allocate dummy last picture for field based first keyframe\n");
1470 for(i=0; i<avctx->
height; i++)
1516 for (i = 0; i < 4; i++) {
1604 assert(i < MAX_PICTURE_COUNT);
1641 sx = av_clip(sx, 0, w - 1);
1642 sy = av_clip(sy, 0, h - 1);
1643 ex = av_clip(ex, 0, w - 1);
1644 ey = av_clip(ey, 0, h - 1);
1646 buf[sy * stride + sx] +=
color;
1655 f = ((ey - sy) << 16) / ex;
1656 for (x = 0; x <= ex; x++) {
1658 fr = (x * f) & 0xFFFF;
1659 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1660 if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1670 f = ((ex - sx) << 16) / ey;
1673 for(y= 0; y <= ey; y++){
1675 fr = (y*f) & 0xFFFF;
1676 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1677 if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
1694 sx = av_clip(sx, -100, w + 100);
1695 sy = av_clip(sy, -100, h + 100);
1696 ex = av_clip(ex, -100, w + 100);
1697 ey = av_clip(ey, -100, h + 100);
1702 if (dx * dx + dy * dy > 3 * 3) {
1705 int length =
ff_sqrt((rx * rx + ry * ry) << 8);
1711 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1712 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1714 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1733 for (x = 0; x < s->
mb_width; x++) {
1761 else if (
IS_GMC(mb_type))
1803 int h_chroma_shift, v_chroma_shift, block_height;
1807 const int mv_stride = (s->
mb_width << mv_sample_log2) +
1813 for (i = 0; i < 3; i++) {
1822 ptr = pict->
data[0];
1823 block_height = 16 >> v_chroma_shift;
1825 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1827 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1828 const int mb_index = mb_x + mb_y * s->
mb_stride;
1831 for (type = 0; type < 3; type++) {
1858 for (i = 0; i < 4; i++) {
1859 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1860 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1861 int xy = (mb_x * 2 + (i & 1) +
1862 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1870 for (i = 0; i < 2; i++) {
1871 int sx = mb_x * 16 + 8;
1872 int sy = mb_y * 16 + 4 + 8 * i;
1873 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1880 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1885 for (i = 0; i < 2; i++) {
1886 int sx = mb_x * 16 + 4 + 8 * i;
1887 int sy = mb_y * 16 + 8;
1888 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1895 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1899 int sx= mb_x * 16 + 8;
1900 int sy= mb_y * 16 + 8;
1901 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1910 0x0101010101010101ULL;
1912 for (y = 0; y < block_height; y++) {
1913 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1914 (block_height * mb_y + y) *
1916 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
1917 (block_height * mb_y + y) *
1923 int mb_type = pict->
mb_type[mb_index];
1926 #define COLOR(theta, r) \
1927 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1928 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1945 }
else if (
IS_GMC(mb_type)) {
1947 }
else if (
IS_SKIP(mb_type)) {
1958 u *= 0x0101010101010101ULL;
1959 v *= 0x0101010101010101ULL;
1960 for (y = 0; y < block_height; y++) {
1961 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1962 (block_height * mb_y + y) * pict->
linesize[1]) = u;
1963 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
1964 (block_height * mb_y + y) * pict->
linesize[2]) = v;
1969 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 0 +
1970 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
1971 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 8 +
1972 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
1975 for (y = 0; y < 16; y++)
1976 pict->
data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1979 if (
IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1980 int dm = 1 << (mv_sample_log2 - 2);
1981 for (i = 0; i < 4; i++) {
1982 int sx = mb_x * 16 + 8 * (i & 1);
1983 int sy = mb_y * 16 + 8 * (i >> 1);
1984 int xy = (mb_x * 2 + (i & 1) +
1985 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1988 if (mv[0] != mv[dm] ||
1989 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1990 for (y = 0; y < 8; y++)
1991 pict->
data[0][sx + 4 + (sy + y) * pict->
linesize[0]] ^= 0x80;
1992 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1993 *(uint64_t *)(pict->
data[0] + sx + (sy + 4) *
1994 pict->
linesize[0]) ^= 0x8080808080808080ULL;
2011 int field_based,
int field_select,
2012 int src_x,
int src_y,
2014 int h_edge_pos,
int v_edge_pos,
2016 int motion_x,
int motion_y)
2019 const int op_index =
FFMIN(lowres, 2);
2020 const int s_mask = (2 <<
lowres) - 1;
2029 sx = motion_x & s_mask;
2030 sy = motion_y & s_mask;
2031 src_x += motion_x >> lowres + 1;
2032 src_y += motion_y >> lowres + 1;
2034 src += src_y * stride + src_x;
2036 if ((
unsigned)src_x >
FFMAX( h_edge_pos - (!!sx) - w, 0) ||
2037 (unsigned)src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2039 (h + 1) << field_based, src_x,
2040 src_y << field_based,
2047 sx = (sx << 2) >>
lowres;
2048 sy = (sy << 2) >>
lowres;
2051 pix_op[op_index](dest, src,
stride, h, sx, sy);
2065 int motion_x,
int motion_y,
2068 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2069 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2073 const int block_s = 8>>
lowres;
2074 const int s_mask = (2 <<
lowres) - 1;
2087 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2090 sx = motion_x & s_mask;
2091 sy = motion_y & s_mask;
2092 src_x = s->
mb_x * 2 * block_s + (motion_x >> lowres + 1);
2093 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2096 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
2097 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
2098 uvsrc_x = src_x >> 1;
2099 uvsrc_y = src_y >> 1;
2104 uvsx = (2 * mx) & s_mask;
2105 uvsy = (2 * my) & s_mask;
2106 uvsrc_x = s->
mb_x * block_s + (mx >>
lowres);
2107 uvsrc_y = mb_y * block_s + (my >>
lowres);
2114 uvsrc_x = s->
mb_x * block_s + (mx >> lowres + 1);
2115 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
2121 uvsy = motion_y & s_mask;
2123 uvsrc_x = s->
mb_x*block_s + (mx >> (lowres+1));
2126 uvsx = motion_x & s_mask;
2127 uvsy = motion_y & s_mask;
2134 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2135 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2136 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2138 if ((
unsigned) src_x >
FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
2139 (
unsigned) src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2141 linesize >> field_based, 17, 17 + field_based,
2142 src_x, src_y << field_based, h_edge_pos,
2149 uvsrc_x, uvsrc_y << field_based,
2150 h_edge_pos >> 1, v_edge_pos >> 1);
2153 uvsrc_x, uvsrc_y << field_based,
2154 h_edge_pos >> 1, v_edge_pos >> 1);
2156 ptr_cr = uvbuf + 16;
2173 sx = (sx << 2) >>
lowres;
2174 sy = (sy << 2) >>
lowres;
2175 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2179 uvsx = (uvsx << 2) >>
lowres;
2180 uvsy = (uvsy << 2) >>
lowres;
2182 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
2183 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
2196 const int op_index =
FFMIN(lowres, 2);
2197 const int block_s = 8 >>
lowres;
2198 const int s_mask = (2 <<
lowres) - 1;
2199 const int h_edge_pos = s->
h_edge_pos >> lowres + 1;
2200 const int v_edge_pos = s->
v_edge_pos >> lowres + 1;
2201 int emu = 0, src_x, src_y,
offset, sx, sy;
2216 src_x = s->
mb_x * block_s + (mx >> lowres + 1);
2217 src_y = s->
mb_y * block_s + (my >> lowres + 1);
2220 ptr = ref_picture[1] +
offset;
2222 if ((
unsigned) src_x >
FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2223 (unsigned) src_y >
FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2225 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2230 sx = (sx << 2) >>
lowres;
2231 sy = (sy << 2) >>
lowres;
2232 pix_op[op_index](dest_cb, ptr, s->
uvlinesize, block_s, sx, sy);
2234 ptr = ref_picture[2] +
offset;
2237 src_x, src_y, h_edge_pos, v_edge_pos);
2240 pix_op[op_index](dest_cr, ptr, s->
uvlinesize, block_s, sx, sy);
2257 int dir,
uint8_t **ref_picture,
2263 const int block_s = 8 >>
lowres;
2272 ref_picture, pix_op,
2273 s->
mv[dir][0][0], s->
mv[dir][0][1],
2279 for (i = 0; i < 4; i++) {
2282 ref_picture[0], 0, 0,
2283 (2 * mb_x + (i & 1)) * block_s,
2284 (2 * mb_y + (i >> 1)) * block_s,
2287 block_s, block_s, pix_op,
2288 s->
mv[dir][i][0], s->
mv[dir][i][1]);
2290 mx += s->
mv[dir][i][0];
2291 my += s->
mv[dir][i][1];
2303 ref_picture, pix_op,
2304 s->
mv[dir][0][0], s->
mv[dir][0][1],
2309 ref_picture, pix_op,
2310 s->
mv[dir][1][0], s->
mv[dir][1][1],
2320 ref_picture, pix_op,
2322 s->
mv[dir][0][1], 2 * block_s, mb_y >> 1);
2326 for (i = 0; i < 2; i++) {
2331 ref2picture = ref_picture;
2338 ref2picture, pix_op,
2339 s->
mv[dir][i][0], s->
mv[dir][i][1] +
2340 2 * block_s * i, block_s, mb_y >> 1);
2342 dest_y += 2 * block_s * s->
linesize;
2349 for (i = 0; i < 2; i++) {
2351 for (j = 0; j < 2; j++) {
2354 ref_picture, pix_op,
2355 s->
mv[dir][2 * i + j][0],
2356 s->
mv[dir][2 * i + j][1],
2362 for (i = 0; i < 2; i++) {
2365 ref_picture, pix_op,
2366 s->
mv[dir][2 * i][0],s->
mv[dir][2 * i][1],
2367 2 * block_s, mb_y >> 1);
2390 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->
quarter_sample;
2391 int my,
off, i, mvs;
2410 for (i = 0; i < mvs; i++) {
2411 my = s->
mv[dir][i][1]<<qpel_shift;
2412 my_max =
FFMAX(my_max, my);
2413 my_min =
FFMIN(my_min, my);
2416 off = (
FFMAX(-my_min, my_max) + 63) >> 6;
2463 memset(s->
ac_val[0][xy ], 0, 32 *
sizeof(int16_t));
2464 memset(s->
ac_val[0][xy + wrap], 0, 32 *
sizeof(int16_t));
2477 memset(s->
ac_val[1][xy], 0, 16 *
sizeof(int16_t));
2478 memset(s->
ac_val[2][xy], 0, 16 *
sizeof(int16_t));
2495 int lowres_flag,
int is_mpeg12)
2509 for(j=0; j<64; j++){
2534 uint8_t *dest_y, *dest_cb, *dest_cr;
2535 int dct_linesize, dct_offset;
2541 const int block_size= lowres_flag ? 8>>s->
avctx->
lowres : 8;
2560 dct_offset = s->
interlaced_dct ? linesize : linesize * block_size;
2564 dest_cb= s->
dest[1];
2565 dest_cr= s->
dest[2];
2648 add_dct(s, block[0], 0, dest_y , dct_linesize);
2649 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2650 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2651 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2655 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2656 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2660 dct_offset = s->
interlaced_dct ? uvlinesize : uvlinesize*block_size;
2662 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2663 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2664 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2665 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2667 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2668 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2669 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2670 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2675 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2682 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->
qscale);
2683 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->
qscale);
2684 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->
qscale);
2701 s->
dsp.
idct_put(dest_y + block_size, dct_linesize, block[1]);
2702 s->
dsp.
idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2703 s->
dsp.
idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2712 dct_offset = s->
interlaced_dct? uvlinesize : uvlinesize*block_size;
2716 s->
dsp.
idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2717 s->
dsp.
idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2719 s->
dsp.
idct_put(dest_cb + block_size, dct_linesize, block[8]);
2720 s->
dsp.
idct_put(dest_cr + block_size, dct_linesize, block[9]);
2721 s->
dsp.
idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2722 s->
dsp.
idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2765 int sides = 0, edge_h;
2838 s->
dest[0] += s->
mb_y * linesize << mb_size;
2842 s->
dest[0] += (s->
mb_y>>1) * linesize << mb_size;
2881 int i,
level, nCoeffs;
2882 const uint16_t *quant_matrix;
2889 for(i=1;i<=nCoeffs;i++) {
2895 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2896 level = (level - 1) | 1;
2899 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2900 level = (level - 1) | 1;
2910 int i,
level, nCoeffs;
2911 const uint16_t *quant_matrix;
2916 for(i=0; i<=nCoeffs; i++) {
2922 level = (((level << 1) + 1) * qscale *
2923 ((int) (quant_matrix[j]))) >> 4;
2924 level = (level - 1) | 1;
2927 level = (((level << 1) + 1) * qscale *
2928 ((int) (quant_matrix[j]))) >> 4;
2929 level = (level - 1) | 1;
2939 int i,
level, nCoeffs;
2940 const uint16_t *quant_matrix;
2947 for(i=1;i<=nCoeffs;i++) {
2953 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2956 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2966 int i,
level, nCoeffs;
2967 const uint16_t *quant_matrix;
2976 for(i=1;i<=nCoeffs;i++) {
2982 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2985 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2997 int i,
level, nCoeffs;
2998 const uint16_t *quant_matrix;
3005 for(i=0; i<=nCoeffs; i++) {
3011 level = (((level << 1) + 1) * qscale *
3012 ((int) (quant_matrix[j]))) >> 4;
3015 level = (((level << 1) + 1) * qscale *
3016 ((int) (quant_matrix[j]))) >> 4;
3028 int i,
level, qmul, qadd;
3037 qadd = (qscale - 1) | 1;
3046 for(i=1; i<=nCoeffs; i++) {
3050 level = level * qmul - qadd;
3052 level = level * qmul + qadd;
3062 int i,
level, qmul, qadd;
3067 qadd = (qscale - 1) | 1;
3072 for(i=0; i<=nCoeffs; i++) {
3076 level = level * qmul - qadd;
3078 level = level * qmul + qadd;
3092 else if (qscale > 31)