30 #include "libavutil/imgutils.h"
47 int16_t *
block,
int n,
int qscale);
49 int16_t *
block,
int n,
int qscale);
51 int16_t *
block,
int n,
int qscale);
53 int16_t *
block,
int n,
int qscale);
55 int16_t *
block,
int n,
int qscale);
57 int16_t *
block,
int n,
int qscale);
59 int16_t *
block,
int n,
int qscale);
67 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
68 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
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,
80 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
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,
92 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
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,
104 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
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,
116 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
133 int mb_x,
int mb_y,
int mb_intra,
int mb_skipped)
143 memcpy(s->
mv,
mv,
sizeof(*
mv));
168 for (i = 0; i < 3; i++) {
169 uint32_t tmp = *state << 8;
170 *state = tmp + *(p++);
171 if (tmp == 0x100 || p == end)
176 if (p[-1] > 1 ) p += 3;
177 else if (p[-2] ) p += 2;
178 else if (p[-3]|(p[-1]-1)) p++;
185 p =
FFMIN(p, end) - 4;
308 if (r < 0 || !pic->f.type || !pic->
f.
data[0]) {
318 "get_buffer() failed (stride changed)\n");
325 "get_buffer() failed (uv stride mismatch)\n");
333 "get_buffer() failed to allocate context scratch buffers.\n");
358 assert(pic->
f.
data[0]);
362 assert(!pic->
f.
data[0]);
374 mb_array_size *
sizeof(int16_t), fail)
376 mb_array_size *
sizeof(int16_t), fail)
378 mb_array_size *
sizeof(int8_t ), fail)
382 mb_array_size *
sizeof(
uint8_t) + 2, fail)
387 (big_mb_num + s->
mb_stride) *
sizeof(uint32_t),
392 for (i = 0; i < 2; i++) {
394 2 * (b4_array_size + 4) *
sizeof(int16_t),
398 4 * mb_array_size *
sizeof(
uint8_t), fail)
403 for (i = 0; i < 2; i++) {
405 2 * (b8_array_size + 4) *
sizeof(int16_t),
409 4 * mb_array_size *
sizeof(
uint8_t), fail)
415 64 * mb_array_size *
sizeof(int16_t) * 6, fail)
453 for (i = 0; i < 2; i++) {
460 for (i = 0; i < 4; i++) {
472 int yc_size = y_size + 2 * c_size;
489 2 * 64 *
sizeof(
int), fail)
495 for (i = 0; i < 12; i++) {
502 yc_size *
sizeof(int16_t) * 16, fail);
535 #define COPY(a) bak->a = src->a
536 COPY(edge_emu_buffer);
541 COPY(obmc_scratchpad);
569 for (i = 0; i < 12; i++) {
575 "scratch buffers.\n");
604 if (
s1->context_initialized){
635 (
char *) &
s1->last_picture_ptr - (
char *) &
s1->last_picture);
654 (
char *) &
s1->shape - (
char *) &
s1->time_increment_bits);
664 if (
s1->bitstream_buffer) {
665 if (
s1->bitstream_buffer_size +
669 s1->allocated_bitstream_buffer_size);
672 s1->bitstream_buffer_size);
682 "scratch buffers.\n");
687 "be allocated due to unknown size.\n");
692 (
char *) &
s1->rtp_mode - (
char *) &
s1->progressive_sequence);
694 if (!
s1->first_field) {
696 if (
s1->current_picture_ptr)
789 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x,
y;
814 yc_size = y_size + 2 * c_size;
844 mb_array_size *
sizeof(
float), fail);
846 mb_array_size *
sizeof(
float), fail);
853 for (i = 0; i < 2; i++) {
855 for (j = 0; j < 2; j++) {
856 for (k = 0; k < 2; k++) {
859 mv_table_size * 2 *
sizeof(int16_t),
888 for (i = 0; i < yc_size; i++)
926 "decoding to AV_PIX_FMT_NONE is not supported.\n");
937 " reducing to %d\n", nb_slices, max_slices);
938 nb_slices = max_slices;
963 (
MAX_RUN + 1) * 2 *
sizeof(
int), fail);
998 for (i = 1; i < nb_slices; i++) {
1003 for (i = 0; i < nb_slices; i++) {
1007 (s->
mb_height * (i) + nb_slices / 2) / nb_slices;
1009 (s->
mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1048 for (i = 0; i < 2; i++) {
1049 for (j = 0; j < 2; j++) {
1050 for (k = 0; k < 2; k++) {
1079 for (i = 0; i < 3; i++)
1130 if (nb_slices > 1) {
1131 for (i = 1; i < nb_slices; i++) {
1136 for (i = 0; i < nb_slices; i++) {
1140 (s->
mb_height * (i) + nb_slices / 2) / nb_slices;
1142 (s->
mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1226 for (last = 0; last < 2; last++) {
1235 memset(max_level, 0,
MAX_RUN + 1);
1237 memset(index_run, rl->
n,
MAX_RUN + 1);
1238 for (i = start; i <
end; i++) {
1241 if (index_run[run] == rl->
n)
1243 if (level > max_level[run])
1245 if (run > max_run[level])
1249 rl->
max_level[last] = static_store[last];
1262 memcpy(rl->
index_run[last], index_run, MAX_RUN + 1);
1270 for (q = 0; q < 32; q++) {
1272 int qadd = (q - 1) | 1;
1286 }
else if (len < 0) {
1290 if (code == rl->
n) {
1296 if (code >= rl->
last) run += 192;
1356 "Internal error, picture buffer overflow\n");
1376 if (ret >= 0 && ret < s->picture_range_end) {
1390 for (intra = 0; intra < 2; intra++) {
1392 for (i = 0; i < 64; i++) {
1398 for (i = 0; i < 64; i++) {
1441 "releasing zombie picture\n");
1504 av_dlog(s->
avctx,
"L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1516 int h_chroma_shift, v_chroma_shift;
1518 &h_chroma_shift, &v_chroma_shift);
1521 "warning: first frame is no keyframe\n");
1524 "allocate dummy last picture for field based first keyframe\n");
1542 (avctx->
height >> v_chroma_shift) *
1545 (avctx->
height >> v_chroma_shift) *
1549 for(i=0; i<avctx->
height; i++)
1597 for (i = 0; i < 4; i++) {
1685 assert(i < MAX_PICTURE_COUNT);
1722 sx = av_clip(sx, 0, w - 1);
1723 sy = av_clip(sy, 0, h - 1);
1724 ex = av_clip(ex, 0, w - 1);
1725 ey = av_clip(ey, 0, h - 1);
1727 buf[sy * stride + sx] +=
color;
1736 f = ((ey - sy) << 16) / ex;
1737 for (x = 0; x <= ex; x++) {
1739 fr = (x * f) & 0xFFFF;
1740 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1741 if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1751 f = ((ex - sx) << 16) / ey;
1754 for(y= 0; y <= ey; y++){
1756 fr = (y*f) & 0xFFFF;
1757 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1758 if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
1775 sx = av_clip(sx, -100, w + 100);
1776 sy = av_clip(sy, -100, h + 100);
1777 ex = av_clip(ex, -100, w + 100);
1778 ey = av_clip(ey, -100, h + 100);
1783 if (dx * dx + dy * dy > 3 * 3) {
1786 int length =
ff_sqrt((rx * rx + ry * ry) << 8);
1792 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1793 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1795 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1802 uint8_t *visualization_buffer[3],
int *low_delay,
1803 int mb_width,
int mb_height,
int mb_stride,
int quarter_sample)
1815 for (y = 0; y < mb_height; y++) {
1816 for (x = 0; x < mb_width; x++) {
1818 int count = mbskip_table[x + y * mb_stride];
1828 int mb_type = pict->
mb_type[x + y * mb_stride];
1844 else if (
IS_GMC(mb_type))
1882 const int shift = 1 + quarter_sample;
1886 int h_chroma_shift, v_chroma_shift, block_height;
1890 const int mv_stride = (mb_width << mv_sample_log2) +
1896 for (i = 0; i < 3; i++) {
1899 visualization_buffer[i]=
av_realloc(visualization_buffer[i], size);
1900 memcpy(visualization_buffer[i], pict->
data[i], size);
1901 pict->
data[i] = visualization_buffer[i];
1905 ptr = pict->
data[0];
1906 block_height = 16 >> v_chroma_shift;
1908 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1910 for (mb_x = 0; mb_x < mb_width; mb_x++) {
1911 const int mb_index = mb_x + mb_y * mb_stride;
1914 for (type = 0; type < 3; type++) {
1941 for (i = 0; i < 4; i++) {
1942 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1943 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1944 int xy = (mb_x * 2 + (i & 1) +
1945 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1953 for (i = 0; i < 2; i++) {
1954 int sx = mb_x * 16 + 8;
1955 int sy = mb_y * 16 + 4 + 8 * i;
1956 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1963 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1968 for (i = 0; i < 2; i++) {
1969 int sx = mb_x * 16 + 4 + 8 * i;
1970 int sy = mb_y * 16 + 8;
1971 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1978 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1982 int sx= mb_x * 16 + 8;
1983 int sy= mb_y * 16 + 8;
1984 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1993 0x0101010101010101ULL;
1995 for (y = 0; y < block_height; y++) {
1996 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
1997 (block_height * mb_y + y) *
1999 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
2000 (block_height * mb_y + y) *
2006 int mb_type = pict->
mb_type[mb_index];
2009 #define COLOR(theta, r) \
2010 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2011 v = (int)(128 + r * sin(theta * 3.141592 / 180));
2028 }
else if (
IS_GMC(mb_type)) {
2030 }
else if (
IS_SKIP(mb_type)) {
2041 u *= 0x0101010101010101ULL;
2042 v *= 0x0101010101010101ULL;
2043 for (y = 0; y < block_height; y++) {
2044 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
2045 (block_height * mb_y + y) * pict->
linesize[1]) = u;
2046 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
2047 (block_height * mb_y + y) * pict->
linesize[2]) = v;
2052 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 0 +
2053 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
2054 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 8 +
2055 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
2058 for (y = 0; y < 16; y++)
2059 pict->
data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2062 if (
IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2063 int dm = 1 << (mv_sample_log2 - 2);
2064 for (i = 0; i < 4; i++) {
2065 int sx = mb_x * 16 + 8 * (i & 1);
2066 int sy = mb_y * 16 + 8 * (i >> 1);
2067 int xy = (mb_x * 2 + (i & 1) +
2068 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2071 if (mv[0] != mv[dm] ||
2072 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2073 for (y = 0; y < 8; y++)
2074 pict->
data[0][sx + 4 + (sy + y) * pict->
linesize[0]] ^= 0x80;
2075 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2076 *(uint64_t *)(pict->
data[0] + sx + (sy + 4) *
2077 pict->
linesize[0]) ^= 0x8080808080808080ULL;
2086 mbskip_table[mb_index] = 0;
2100 int field_based,
int field_select,
2101 int src_x,
int src_y,
2103 int h_edge_pos,
int v_edge_pos,
2105 int motion_x,
int motion_y)
2108 const int op_index =
FFMIN(lowres, 3);
2109 const int s_mask = (2 <<
lowres) - 1;
2118 sx = motion_x & s_mask;
2119 sy = motion_y & s_mask;
2120 src_x += motion_x >> lowres + 1;
2121 src_y += motion_y >> lowres + 1;
2123 src += src_y * stride + src_x;
2125 if ((
unsigned)src_x >
FFMAX( h_edge_pos - (!!sx) - w, 0) ||
2126 (unsigned)src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2128 (h + 1) << field_based, src_x,
2129 src_y << field_based,
2136 sx = (sx << 2) >>
lowres;
2137 sy = (sy << 2) >>
lowres;
2140 pix_op[op_index](dest, src,
stride, h, sx, sy);
2154 int motion_x,
int motion_y,
2157 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2158 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2162 const int block_s = 8>>
lowres;
2163 const int s_mask = (2 <<
lowres) - 1;
2176 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2179 sx = motion_x & s_mask;
2180 sy = motion_y & s_mask;
2181 src_x = s->
mb_x * 2 * block_s + (motion_x >> lowres + 1);
2182 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2185 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
2186 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
2187 uvsrc_x = src_x >> 1;
2188 uvsrc_y = src_y >> 1;
2193 uvsx = (2 * mx) & s_mask;
2194 uvsy = (2 * my) & s_mask;
2195 uvsrc_x = s->
mb_x * block_s + (mx >>
lowres);
2196 uvsrc_y = mb_y * block_s + (my >>
lowres);
2203 uvsrc_x = s->
mb_x * block_s + (mx >> lowres + 1);
2204 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
2210 uvsy = motion_y & s_mask;
2212 uvsrc_x = s->
mb_x*block_s + (mx >> (lowres+1));
2215 uvsx = motion_x & s_mask;
2216 uvsy = motion_y & s_mask;
2223 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2224 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2225 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2227 if ((
unsigned) src_x >
FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
2228 (
unsigned) src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2230 linesize >> field_based, 17, 17 + field_based,
2231 src_x, src_y << field_based, h_edge_pos,
2238 uvsrc_x, uvsrc_y << field_based,
2239 h_edge_pos >> 1, v_edge_pos >> 1);
2242 uvsrc_x, uvsrc_y << field_based,
2243 h_edge_pos >> 1, v_edge_pos >> 1);
2245 ptr_cr = uvbuf + 16;
2262 sx = (sx << 2) >>
lowres;
2263 sy = (sy << 2) >>
lowres;
2264 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2268 uvsx = (uvsx << 2) >>
lowres;
2269 uvsy = (uvsy << 2) >>
lowres;
2271 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
2272 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
2285 const int op_index =
FFMIN(lowres, 3);
2286 const int block_s = 8 >>
lowres;
2287 const int s_mask = (2 <<
lowres) - 1;
2288 const int h_edge_pos = s->
h_edge_pos >> lowres + 1;
2289 const int v_edge_pos = s->
v_edge_pos >> lowres + 1;
2290 int emu = 0, src_x, src_y,
offset, sx, sy;
2305 src_x = s->
mb_x * block_s + (mx >> lowres + 1);
2306 src_y = s->
mb_y * block_s + (my >> lowres + 1);
2309 ptr = ref_picture[1] +
offset;
2311 if ((
unsigned) src_x >
FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2312 (unsigned) src_y >
FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2314 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2319 sx = (sx << 2) >>
lowres;
2320 sy = (sy << 2) >>
lowres;
2321 pix_op[op_index](dest_cb, ptr, s->
uvlinesize, block_s, sx, sy);
2323 ptr = ref_picture[2] +
offset;
2326 src_x, src_y, h_edge_pos, v_edge_pos);
2329 pix_op[op_index](dest_cr, ptr, s->
uvlinesize, block_s, sx, sy);
2346 int dir,
uint8_t **ref_picture,
2352 const int block_s = 8 >>
lowres;
2361 ref_picture, pix_op,
2362 s->
mv[dir][0][0], s->
mv[dir][0][1],
2368 for (i = 0; i < 4; i++) {
2371 ref_picture[0], 0, 0,
2372 (2 * mb_x + (i & 1)) * block_s,
2373 (2 * mb_y + (i >> 1)) * block_s,
2376 block_s, block_s, pix_op,
2377 s->
mv[dir][i][0], s->
mv[dir][i][1]);
2379 mx += s->
mv[dir][i][0];
2380 my += s->
mv[dir][i][1];
2392 ref_picture, pix_op,
2393 s->
mv[dir][0][0], s->
mv[dir][0][1],
2398 ref_picture, pix_op,
2399 s->
mv[dir][1][0], s->
mv[dir][1][1],
2409 ref_picture, pix_op,
2411 s->
mv[dir][0][1], 2 * block_s, mb_y >> 1);
2415 for (i = 0; i < 2; i++) {
2420 ref2picture = ref_picture;
2427 ref2picture, pix_op,
2428 s->
mv[dir][i][0], s->
mv[dir][i][1] +
2429 2 * block_s * i, block_s, mb_y >> 1);
2431 dest_y += 2 * block_s * s->
linesize;
2438 for (i = 0; i < 2; i++) {
2440 for (j = 0; j < 2; j++) {
2443 ref_picture, pix_op,
2444 s->
mv[dir][2 * i + j][0],
2445 s->
mv[dir][2 * i + j][1],
2451 for (i = 0; i < 2; i++) {
2454 ref_picture, pix_op,
2455 s->
mv[dir][2 * i][0],s->
mv[dir][2 * i][1],
2456 2 * block_s, mb_y >> 1);
2479 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->
quarter_sample;
2480 int my,
off, i, mvs;
2499 for (i = 0; i < mvs; i++) {
2500 my = s->
mv[dir][i][1]<<qpel_shift;
2501 my_max =
FFMAX(my_max, my);
2502 my_min =
FFMIN(my_min, my);
2505 off = (
FFMAX(-my_min, my_max) + 63) >> 6;
2514 int16_t *
block,
int i,
uint8_t *dest,
int line_size,
int qscale)
2530 int16_t *
block,
int i,
uint8_t *dest,
int line_size,
int qscale)
2552 memset(s->
ac_val[0][xy ], 0, 32 *
sizeof(int16_t));
2553 memset(s->
ac_val[0][xy + wrap], 0, 32 *
sizeof(int16_t));
2566 memset(s->
ac_val[1][xy], 0, 16 *
sizeof(int16_t));
2567 memset(s->
ac_val[2][xy], 0, 16 *
sizeof(int16_t));
2584 int lowres_flag,
int is_mpeg12)
2598 for(j=0; j<64; j++){
2623 uint8_t *dest_y, *dest_cb, *dest_cr;
2624 int dct_linesize, dct_offset;
2630 const int block_size= lowres_flag ? 8>>s->
avctx->
lowres : 8;
2649 dct_offset = s->
interlaced_dct ? linesize : linesize * block_size;
2653 dest_cb= s->
dest[1];
2654 dest_cr= s->
dest[2];
2737 add_dct(s, block[0], 0, dest_y , dct_linesize);
2738 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2739 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2740 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2744 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2745 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2749 dct_offset = s->
interlaced_dct ? uvlinesize : uvlinesize*block_size;
2751 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2752 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2753 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2754 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2756 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2757 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2758 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2759 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2771 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->
qscale);
2772 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->
qscale);
2773 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->
qscale);
2790 s->
dsp.
idct_put(dest_y + block_size, dct_linesize, block[1]);
2791 s->
dsp.
idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2792 s->
dsp.
idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2801 dct_offset = s->
interlaced_dct? uvlinesize : uvlinesize*block_size;
2805 s->
dsp.
idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2806 s->
dsp.
idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2808 s->
dsp.
idct_put(dest_cb + block_size, dct_linesize, block[8]);
2809 s->
dsp.
idct_put(dest_cr + block_size, dct_linesize, block[9]);
2810 s->
dsp.
idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2811 s->
dsp.
idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2841 Picture *last,
int y,
int h,
int picture_structure,
2843 int v_edge_pos,
int h_edge_pos)
2848 const int field_pic = picture_structure !=
PICT_FRAME;
2860 int sides = 0, edge_h;
2862 if (y + h >= v_edge_pos)
2865 edge_h=
FFMIN(h, v_edge_pos - y);
2868 linesize[0], h_edge_pos, edge_h,
2871 linesize[1], h_edge_pos >> hshift, edge_h >> vshift,
2874 linesize[2], h_edge_pos >> hshift, edge_h >> vshift,
2904 offset[2]= (y >> vshift) * src->
linesize[1];
2912 y, picture_structure, h);
2945 s->
dest[0] += s->
mb_y * linesize << mb_size;
2949 s->
dest[0] += (s->
mb_y>>1) * linesize << mb_size;
2973 for(i=0; i<=last; i++){
2974 const int j= scantable[i];
2979 for(i=0; i<=last; i++){
2980 const int j= scantable[i];
2981 const int perm_j= permutation[j];
2982 block[perm_j]= temp[j];
3015 int16_t *
block,
int n,
int qscale)
3017 int i,
level, nCoeffs;
3018 const uint16_t *quant_matrix;
3025 for(i=1;i<=nCoeffs;i++) {
3031 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3032 level = (level - 1) | 1;
3035 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3036 level = (level - 1) | 1;
3044 int16_t *
block,
int n,
int qscale)
3046 int i,
level, nCoeffs;
3047 const uint16_t *quant_matrix;
3052 for(i=0; i<=nCoeffs; i++) {
3058 level = (((level << 1) + 1) * qscale *
3059 ((int) (quant_matrix[j]))) >> 4;
3060 level = (level - 1) | 1;
3063 level = (((level << 1) + 1) * qscale *
3064 ((int) (quant_matrix[j]))) >> 4;
3065 level = (level - 1) | 1;
3073 int16_t *
block,
int n,
int qscale)
3075 int i,
level, nCoeffs;
3076 const uint16_t *quant_matrix;
3083 for(i=1;i<=nCoeffs;i++) {
3089 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3092 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3100 int16_t *
block,
int n,
int qscale)
3102 int i,
level, nCoeffs;
3103 const uint16_t *quant_matrix;
3112 for(i=1;i<=nCoeffs;i++) {
3118 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3121 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3131 int16_t *
block,
int n,
int qscale)
3133 int i,
level, nCoeffs;
3134 const uint16_t *quant_matrix;
3141 for(i=0; i<=nCoeffs; i++) {
3147 level = (((level << 1) + 1) * qscale *
3148 ((int) (quant_matrix[j]))) >> 4;
3151 level = (((level << 1) + 1) * qscale *
3152 ((int) (quant_matrix[j]))) >> 4;
3162 int16_t *
block,
int n,
int qscale)
3164 int i,
level, qmul, qadd;
3173 qadd = (qscale - 1) | 1;
3182 for(i=1; i<=nCoeffs; i++) {
3186 level = level * qmul - qadd;
3188 level = level * qmul + qadd;
3196 int16_t *
block,
int n,
int qscale)
3198 int i,
level, qmul, qadd;
3203 qadd = (qscale - 1) | 1;
3208 for(i=0; i<=nCoeffs; i++) {
3212 level = level * qmul - qadd;
3214 level = level * qmul + qadd;
3228 else if (qscale > 31)