52 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
53 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
58 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
59 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
60 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
61 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
62 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
63 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
64 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
65 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
70 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
71 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
72 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
73 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
74 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
75 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
76 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
77 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
82 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
83 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
84 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
85 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
86 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
87 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
88 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
89 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
94 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
95 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
96 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
97 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
98 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
99 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
100 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
101 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
112 0, 1, 2, 3, 8, 9, 16, 17,
113 10, 11, 4, 5, 6, 7, 15, 14,
114 13, 12, 19, 18, 24, 25, 32, 33,
115 26, 27, 20, 21, 22, 23, 28, 29,
116 30, 31, 34, 35, 40, 41, 48, 49,
117 42, 43, 36, 37, 38, 39, 44, 45,
118 46, 47, 50, 51, 56, 57, 58, 59,
119 52, 53, 54, 55, 60, 61, 62, 63,
123 0, 8, 16, 24, 1, 9, 2, 10,
124 17, 25, 32, 40, 48, 56, 57, 49,
125 41, 33, 26, 18, 3, 11, 4, 12,
126 19, 27, 34, 42, 50, 58, 35, 43,
127 51, 59, 20, 28, 5, 13, 6, 14,
128 21, 29, 36, 44, 52, 60, 37, 45,
129 53, 61, 22, 30, 7, 15, 23, 31,
130 38, 46, 54, 62, 39, 47, 55, 63,
134 int16_t *
block,
int n,
int qscale)
136 int i,
level, nCoeffs;
137 const uint16_t *quant_matrix;
144 for(i=1;i<=nCoeffs;i++) {
150 level = (int)(level * qscale * quant_matrix[j]) >> 3;
151 level = (level - 1) | 1;
154 level = (int)(level * qscale * quant_matrix[j]) >> 3;
155 level = (level - 1) | 1;
163 int16_t *
block,
int n,
int qscale)
165 int i,
level, nCoeffs;
166 const uint16_t *quant_matrix;
171 for(i=0; i<=nCoeffs; i++) {
177 level = (((level << 1) + 1) * qscale *
178 ((int) (quant_matrix[j]))) >> 4;
179 level = (level - 1) | 1;
182 level = (((level << 1) + 1) * qscale *
183 ((int) (quant_matrix[j]))) >> 4;
184 level = (level - 1) | 1;
192 int16_t *
block,
int n,
int qscale)
194 int i,
level, nCoeffs;
195 const uint16_t *quant_matrix;
202 for(i=1;i<=nCoeffs;i++) {
208 level = (int)(level * qscale * quant_matrix[j]) >> 3;
211 level = (int)(level * qscale * quant_matrix[j]) >> 3;
219 int16_t *
block,
int n,
int qscale)
221 int i,
level, nCoeffs;
222 const uint16_t *quant_matrix;
231 for(i=1;i<=nCoeffs;i++) {
237 level = (int)(level * qscale * quant_matrix[j]) >> 3;
240 level = (int)(level * qscale * quant_matrix[j]) >> 3;
250 int16_t *
block,
int n,
int qscale)
252 int i,
level, nCoeffs;
253 const uint16_t *quant_matrix;
260 for(i=0; i<=nCoeffs; i++) {
266 level = (((level << 1) + 1) * qscale *
267 ((int) (quant_matrix[j]))) >> 4;
270 level = (((level << 1) + 1) * qscale *
271 ((int) (quant_matrix[j]))) >> 4;
281 int16_t *
block,
int n,
int qscale)
283 int i,
level, qmul, qadd;
292 qadd = (qscale - 1) | 1;
301 for(i=1; i<=nCoeffs; i++) {
305 level = level * qmul - qadd;
307 level = level * qmul + qadd;
315 int16_t *
block,
int n,
int qscale)
317 int i,
level, qmul, qadd;
322 qadd = (qscale - 1) | 1;
327 for(i=0; i<=nCoeffs; i++) {
331 level = level * qmul - qadd;
333 level = level * qmul + qadd;
342 int mb_x,
int mb_y,
int mb_intra,
int mb_skipped)
352 memcpy(s->
mv,
mv,
sizeof(*
mv));
365 "Interlaced error concealment is not fully implemented\n");
372 memset(dst + h*linesize, 128, 16);
378 memset(dst + h*linesize, 128, 8);
392 for (i=0; i<4; i++) {
505 if (r < 0 || !pic->f->buf[0]) {
513 for (i = 0; pic->
f->
data[i]; i++) {
538 "get_buffer() failed (stride changed)\n");
545 "get_buffer() failed (uv stride mismatch)\n");
553 "get_buffer() failed to allocate context scratch buffers.\n");
575 for (i = 0; i < 2; i++) {
606 int mv_size = 2 * (b8_array_size + 4) *
sizeof(int16_t);
607 int ref_index_size = 4 * mb_array_size;
609 for (i = 0; mv_size && i < 2; i++) {
626 #define MAKE_WRITABLE(table) \
629 (ret = av_buffer_make_writable(&pic->table)) < 0)\
640 for (i = 0; i < 2; i++) {
692 for (i = 0; i < 2; i++) {
728 memset((
uint8_t*)pic + off, 0,
sizeof(*pic) - off);
735 #define UPDATE_TABLE(table)\
738 (!dst->table || dst->table->buffer != src->table->buffer)) {\
739 av_buffer_unref(&dst->table);\
740 dst->table = av_buffer_ref(src->table);\
742 ff_free_picture_tables(dst);\
743 return AVERROR(ENOMEM);\
754 for (i = 0; i < 2; i++) {
765 for (i = 0; i < 2; i++) {
827 int yc_size = y_size + 2 * c_size;
847 2 * 64 *
sizeof(
int), fail)
853 for (i = 0; i < 12; i++) {
862 yc_size *
sizeof(int16_t) * 16, fail);
895 #define COPY(a) bak->a = src->a
896 COPY(edge_emu_buffer);
901 COPY(obmc_scratchpad);
929 for (i = 0; i < 12; i++) {
937 "scratch buffers.\n");
966 if (
s1->context_initialized){
998 if (
s1->picture[i].f->buf[0] &&
1003 #define UPDATE_PICTURE(pic)\
1005 ff_mpeg_unref_picture(s, &s->pic);\
1006 if (s1->pic.f && s1->pic.f->buf[0])\
1007 ret = ff_mpeg_ref_picture(s, &s->pic, &s1->pic);\
1009 ret = update_picture_tables(&s->pic, &s1->pic);\
1018 #define REBASE_PICTURE(pic, new_ctx, old_ctx) \
1019 ((pic && pic >= old_ctx->picture && \
1020 pic < old_ctx->picture + MAX_PICTURE_COUNT) ? \
1021 &new_ctx->picture[pic - old_ctx->picture] : NULL)
1034 (
char *) &
s1->pb_field_time +
sizeof(
s1->pb_field_time) -
1035 (
char *) &
s1->last_time_base);
1045 if (
s1->bitstream_buffer) {
1046 if (
s1->bitstream_buffer_size +
1050 s1->allocated_bitstream_buffer_size);
1053 s1->bitstream_buffer_size);
1063 "scratch buffers.\n");
1068 "be allocated due to unknown size.\n");
1073 (
char *) &
s1->rtp_mode - (
char *) &
s1->progressive_sequence);
1075 if (!
s1->first_field) {
1077 if (
s1->current_picture_ptr)
1173 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x,
y;
1197 yc_size = y_size + 2 * c_size;
1230 mb_array_size *
sizeof(
float), fail);
1232 mb_array_size *
sizeof(
float), fail);
1239 for (i = 0; i < 2; i++) {
1241 for (j = 0; j < 2; j++) {
1242 for (k = 0; k < 2; k++) {
1245 mv_table_size * 2 *
sizeof(int16_t),
1274 for (i = 0; i < yc_size; i++)
1338 for (i = 0; i < 2; i++) {
1339 for (j = 0; j < 2; j++) {
1340 for (k = 0; k < 2; k++) {
1391 "decoding to AV_PIX_FMT_NONE is not supported.\n");
1402 " reducing to %d\n", nb_slices, max_slices);
1403 nb_slices = max_slices;
1450 if (nb_slices > 1) {
1451 for (i = 1; i < nb_slices; i++) {
1456 for (i = 0; i < nb_slices; i++) {
1460 (s->
mb_height * (i) + nb_slices / 2) / nb_slices;
1462 (s->
mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1501 for (i = 0; i < 2; i++) {
1502 for (j = 0; j < 2; j++) {
1503 for (k = 0; k < 2; k++) {
1578 if (nb_slices > 1) {
1579 for (i = 1; i < nb_slices; i++) {
1584 for (i = 0; i < nb_slices; i++) {
1588 (s->
mb_height * (i) + nb_slices / 2) / nb_slices;
1590 (s->
mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1671 for (last = 0; last < 2; last++) {
1680 memset(max_level, 0,
MAX_RUN + 1);
1682 memset(index_run, rl->
n,
MAX_RUN + 1);
1683 for (i = start; i <
end; i++) {
1686 if (index_run[run] == rl->
n)
1688 if (level > max_level[run])
1690 if (run > max_run[level])
1694 rl->
max_level[last] = static_store[last];
1707 memcpy(rl->
index_run[last], index_run, MAX_RUN + 1);
1715 VLC vlc = { .
table =
table, .table_allocated = static_size };
1719 for (q = 0; q < 32; q++) {
1721 int qadd = (q - 1) | 1;
1728 int code = vlc.
table[i][0];
1735 }
else if (len < 0) {
1739 if (code == rl->
n) {
1745 if (code >= rl->
last) run += 192;
1770 if (!pic->
f->
buf[0])
1794 "Internal error, picture buffer overflow\n");
1826 int i, h_chroma_shift, v_chroma_shift;
1830 for(i=0; i<frame->
height; i++)
1834 0x80, FF_CEIL_RSHIFT(frame->
width, h_chroma_shift));
1836 0x80, FF_CEIL_RSHIFT(frame->
width, h_chroma_shift));
1870 "releasing zombie picture\n");
1930 av_dlog(s->
avctx,
"L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1940 int h_chroma_shift, v_chroma_shift;
1942 &h_chroma_shift, &v_chroma_shift);
1945 "allocating dummy last picture for B frame\n");
1948 "warning: first frame is no keyframe\n");
1951 "allocate dummy last picture for field based first keyframe\n");
1971 for(i=0; i<avctx->
height; i++)
1973 0x80, avctx->
width);
1976 0x80, FF_CEIL_RSHIFT(avctx->
width, h_chroma_shift));
1978 0x80, FF_CEIL_RSHIFT(avctx->
width, h_chroma_shift));
1982 for(i=0; i<avctx->
height; i++)
2012 #if 0 // BUFREF-FIXME
2036 for (i = 0; i < 4; i++) {
2081 static int clip_line(
int *sx,
int *sy,
int *ex,
int *ey,
int maxx)
2089 *sy = *ey + (*sy - *ey) * (int64_t)*ex / (*ex - *sx);
2096 *ey = *sy + (*ey - *sy) * (int64_t)(maxx - *sx) / (*ex - *sx);
2115 if (
clip_line(&sx, &sy, &ex, &ey, w - 1))
2117 if (
clip_line(&sy, &sx, &ey, &ex, h - 1))
2120 sx = av_clip(sx, 0, w - 1);
2121 sy = av_clip(sy, 0, h - 1);
2122 ex = av_clip(ex, 0, w - 1);
2123 ey = av_clip(ey, 0, h - 1);
2125 buf[sy * stride + sx] +=
color;
2132 buf += sx + sy * stride;
2134 f = ((ey - sy) << 16) / ex;
2135 for (x = 0; x <= ex; x++) {
2137 fr = (x * f) & 0xFFFF;
2138 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
2139 if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
2146 buf += sx + sy * stride;
2149 f = ((ex - sx) << 16) / ey;
2152 for(y= 0; y <= ey; y++){
2154 fr = (y*f) & 0xFFFF;
2155 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
2156 if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
2169 int ey,
int w,
int h,
int stride,
int color,
int tail,
int direction)
2178 sx = av_clip(sx, -100, w + 100);
2179 sy = av_clip(sy, -100, h + 100);
2180 ex = av_clip(ex, -100, w + 100);
2181 ey = av_clip(ey, -100, h + 100);
2186 if (dx * dx + dy * dy > 3 * 3) {
2200 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
2201 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
2203 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
2208 int dst_x,
int dst_y,
2209 int src_x,
int src_y,
2218 mb->
source = direction ? 1 : -1;
2227 uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2],
2229 int mb_width,
int mb_height,
int mb_stride,
int quarter_sample)
2232 const int shift = 1 + quarter_sample;
2234 const int mv_stride = (mb_width << mv_sample_log2) +
2236 int mb_x, mb_y, mbcount = 0;
2244 for (mb_y = 0; mb_y < mb_height; mb_y++) {
2245 for (mb_x = 0; mb_x < mb_width; mb_x++) {
2246 int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];
2247 for (direction = 0; direction < 2; direction++) {
2251 for (i = 0; i < 4; i++) {
2252 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2253 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2254 int xy = (mb_x * 2 + (i & 1) +
2255 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2256 int mx = (motion_val[direction][xy][0] >>
shift) + sx;
2257 int my = (motion_val[direction][xy][1] >>
shift) + sy;
2258 mbcount +=
add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, direction);
2260 }
else if (
IS_16X8(mb_type)) {
2261 for (i = 0; i < 2; i++) {
2262 int sx = mb_x * 16 + 8;
2263 int sy = mb_y * 16 + 4 + 8 * i;
2264 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2265 int mx = (motion_val[direction][xy][0] >>
shift);
2266 int my = (motion_val[direction][xy][1] >>
shift);
2271 mbcount +=
add_mb(mvs + mbcount, mb_type, sx, sy, mx + sx, my + sy, direction);
2273 }
else if (
IS_8X16(mb_type)) {
2274 for (i = 0; i < 2; i++) {
2275 int sx = mb_x * 16 + 4 + 8 * i;
2276 int sy = mb_y * 16 + 8;
2277 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2278 int mx = motion_val[direction][xy][0] >>
shift;
2279 int my = motion_val[direction][xy][1] >>
shift;
2284 mbcount +=
add_mb(mvs + mbcount, mb_type, sx, sy, mx + sx, my + sy, direction);
2287 int sx = mb_x * 16 + 8;
2288 int sy = mb_y * 16 + 8;
2289 int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
2290 int mx = (motion_val[direction][xy][0]>>
shift) + sx;
2291 int my = (motion_val[direction][xy][1]>>
shift) + sy;
2292 mbcount +=
add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, direction);
2314 if (avctx->
hwaccel || !mbtype_table
2324 for (y = 0; y < mb_height; y++) {
2325 for (x = 0; x < mb_width; x++) {
2327 int count = mbskip_table[x + y * mb_stride];
2334 qscale_table[x + y * mb_stride]);
2337 int mb_type = mbtype_table[x + y * mb_stride];
2353 else if (
IS_GMC(mb_type))
2393 int h_chroma_shift, v_chroma_shift, block_height;
2395 const int shift = 1 + quarter_sample;
2401 const int mv_stride = (mb_width << mv_sample_log2) +
2412 ptr = pict->
data[0];
2414 block_height = 16 >> v_chroma_shift;
2416 for (mb_y = 0; mb_y < mb_height; mb_y++) {
2418 for (mb_x = 0; mb_x < mb_width; mb_x++) {
2419 const int mb_index = mb_x + mb_y * mb_stride;
2421 if ((avctx->
debug_mv) && motion_val[0]) {
2423 for (type = 0; type < 3; type++) {
2445 if (!
USES_LIST(mbtype_table[mb_index], direction))
2448 if (
IS_8X8(mbtype_table[mb_index])) {
2450 for (i = 0; i < 4; i++) {
2451 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2452 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2453 int xy = (mb_x * 2 + (i & 1) +
2454 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2455 int mx = (motion_val[direction][xy][0] >>
shift) + sx;
2456 int my = (motion_val[direction][xy][1] >>
shift) + sy;
2458 height, pict->
linesize[0], 100, 0, direction);
2460 }
else if (
IS_16X8(mbtype_table[mb_index])) {
2462 for (i = 0; i < 2; i++) {
2463 int sx = mb_x * 16 + 8;
2464 int sy = mb_y * 16 + 4 + 8 * i;
2465 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2466 int mx = (motion_val[direction][xy][0] >>
shift);
2467 int my = (motion_val[direction][xy][1] >>
shift);
2472 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2473 height, pict->
linesize[0], 100, 0, direction);
2475 }
else if (
IS_8X16(mbtype_table[mb_index])) {
2477 for (i = 0; i < 2; i++) {
2478 int sx = mb_x * 16 + 4 + 8 * i;
2479 int sy = mb_y * 16 + 8;
2480 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2481 int mx = motion_val[direction][xy][0] >>
shift;
2482 int my = motion_val[direction][xy][1] >>
shift;
2487 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2488 height, pict->
linesize[0], 100, 0, direction);
2491 int sx= mb_x * 16 + 8;
2492 int sy= mb_y * 16 + 8;
2493 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
2494 int mx= (motion_val[direction][xy][0]>>
shift) + sx;
2495 int my= (motion_val[direction][xy][1]>>
shift) + sy;
2496 draw_arrow(ptr, sx, sy, mx, my, width, height, pict->
linesize[0], 100, 0, direction);
2502 uint64_t
c = (qscale_table[mb_index] * 128 / 31) *
2503 0x0101010101010101ULL;
2505 for (y = 0; y < block_height; y++) {
2506 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
2507 (block_height * mb_y + y) *
2509 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
2510 (block_height * mb_y + y) *
2516 int mb_type = mbtype_table[mb_index];
2519 #define COLOR(theta, r) \
2520 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2521 v = (int)(128 + r * sin(theta * 3.141592 / 180));
2538 }
else if (
IS_GMC(mb_type)) {
2540 }
else if (
IS_SKIP(mb_type)) {
2551 u *= 0x0101010101010101ULL;
2552 v *= 0x0101010101010101ULL;
2553 for (y = 0; y < block_height; y++) {
2554 *(uint64_t *)(pict->
data[1] + 8 * mb_x +
2555 (block_height * mb_y + y) * pict->
linesize[1]) = u;
2556 *(uint64_t *)(pict->
data[2] + 8 * mb_x +
2557 (block_height * mb_y + y) * pict->
linesize[2]) = v;
2562 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 0 +
2563 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
2564 *(uint64_t *)(pict->
data[0] + 16 * mb_x + 8 +
2565 (16 * mb_y + 8) * pict->
linesize[0]) ^= 0x8080808080808080ULL;
2568 for (y = 0; y < 16; y++)
2569 pict->
data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2572 if (
IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2573 int dm = 1 << (mv_sample_log2 - 2);
2574 for (i = 0; i < 4; i++) {
2575 int sx = mb_x * 16 + 8 * (i & 1);
2576 int sy = mb_y * 16 + 8 * (i >> 1);
2577 int xy = (mb_x * 2 + (i & 1) +
2578 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2581 if (mv[0] != mv[dm] ||
2582 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2583 for (y = 0; y < 8; y++)
2584 pict->
data[0][sx + 4 + (sy + y) * pict->
linesize[0]] ^= 0x80;
2585 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2586 *(uint64_t *)(pict->
data[0] + sx + (sy + 4) *
2587 pict->
linesize[0]) ^= 0x8080808080808080ULL;
2596 mbskip_table[mb_index] = 0;
2623 int field_based,
int field_select,
2624 int src_x,
int src_y,
2626 int h_edge_pos,
int v_edge_pos,
2628 int motion_x,
int motion_y)
2631 const int op_index =
FFMIN(lowres, 3);
2632 const int s_mask = (2 <<
lowres) - 1;
2641 sx = motion_x & s_mask;
2642 sy = motion_y & s_mask;
2643 src_x += motion_x >> lowres + 1;
2644 src_y += motion_y >> lowres + 1;
2646 src += src_y * stride + src_x;
2648 if ((
unsigned)src_x >
FFMAX( h_edge_pos - (!!sx) - w, 0) ||
2649 (unsigned)src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2652 w + 1, (h + 1) << field_based,
2653 src_x, src_y << field_based,
2654 h_edge_pos, v_edge_pos);
2659 sx = (sx << 2) >>
lowres;
2660 sy = (sy << 2) >>
lowres;
2663 pix_op[op_index](dest,
src, stride, h, sx, sy);
2677 int motion_x,
int motion_y,
2680 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2681 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
2682 ptrdiff_t uvlinesize, linesize;
2685 const int block_s = 8>>
lowres;
2686 const int s_mask = (2 <<
lowres) - 1;
2699 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2702 sx = motion_x & s_mask;
2703 sy = motion_y & s_mask;
2704 src_x = s->
mb_x * 2 * block_s + (motion_x >> lowres + 1);
2705 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2708 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
2709 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
2710 uvsrc_x = src_x >> 1;
2711 uvsrc_y = src_y >> 1;
2716 uvsx = (2 * mx) & s_mask;
2717 uvsy = (2 * my) & s_mask;
2718 uvsrc_x = s->
mb_x * block_s + (mx >>
lowres);
2719 uvsrc_y = mb_y * block_s + (my >>
lowres);
2726 uvsrc_x = s->
mb_x * block_s + (mx >> lowres + 1);
2727 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
2733 uvsy = motion_y & s_mask;
2735 uvsrc_x = s->
mb_x*block_s + (mx >> (lowres+1));
2738 uvsx = motion_x & s_mask;
2739 uvsy = motion_y & s_mask;
2746 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2747 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2748 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2750 if ((
unsigned) src_x >
FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
2751 (
unsigned) src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2753 linesize >> field_based, linesize >> field_based,
2754 17, 17 + field_based,
2755 src_x, src_y << field_based, h_edge_pos,
2762 uvlinesize >> field_based, uvlinesize >> field_based,
2764 uvsrc_x, uvsrc_y << field_based,
2765 h_edge_pos >> 1, v_edge_pos >> 1);
2767 uvlinesize >> field_based,uvlinesize >> field_based,
2769 uvsrc_x, uvsrc_y << field_based,
2770 h_edge_pos >> 1, v_edge_pos >> 1);
2789 sx = (sx << 2) >>
lowres;
2790 sy = (sy << 2) >>
lowres;
2791 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2795 uvsx = (uvsx << 2) >>
lowres;
2796 uvsy = (uvsy << 2) >>
lowres;
2798 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
2799 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
2812 const int op_index =
FFMIN(lowres, 3);
2813 const int block_s = 8 >>
lowres;
2814 const int s_mask = (2 <<
lowres) - 1;
2815 const int h_edge_pos = s->
h_edge_pos >> lowres + 1;
2816 const int v_edge_pos = s->
v_edge_pos >> lowres + 1;
2817 int emu = 0, src_x, src_y, sx, sy;
2833 src_x = s->
mb_x * block_s + (mx >> lowres + 1);
2834 src_y = s->
mb_y * block_s + (my >> lowres + 1);
2837 ptr = ref_picture[1] +
offset;
2838 if ((
unsigned) src_x >
FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2839 (unsigned) src_y >
FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2843 src_x, src_y, h_edge_pos, v_edge_pos);
2847 sx = (sx << 2) >>
lowres;
2848 sy = (sy << 2) >>
lowres;
2849 pix_op[op_index](dest_cb, ptr, s->
uvlinesize, block_s, sx, sy);
2851 ptr = ref_picture[2] +
offset;
2856 src_x, src_y, h_edge_pos, v_edge_pos);
2859 pix_op[op_index](dest_cr, ptr, s->
uvlinesize, block_s, sx, sy);
2876 int dir,
uint8_t **ref_picture,
2882 const int block_s = 8 >>
lowres;
2891 ref_picture, pix_op,
2892 s->
mv[dir][0][0], s->
mv[dir][0][1],
2898 for (i = 0; i < 4; i++) {
2901 ref_picture[0], 0, 0,
2902 (2 * mb_x + (i & 1)) * block_s,
2903 (2 * mb_y + (i >> 1)) * block_s,
2906 block_s, block_s, pix_op,
2907 s->
mv[dir][i][0], s->
mv[dir][i][1]);
2909 mx += s->
mv[dir][i][0];
2910 my += s->
mv[dir][i][1];
2922 ref_picture, pix_op,
2923 s->
mv[dir][0][0], s->
mv[dir][0][1],
2928 ref_picture, pix_op,
2929 s->
mv[dir][1][0], s->
mv[dir][1][1],
2939 ref_picture, pix_op,
2941 s->
mv[dir][0][1], 2 * block_s, mb_y >> 1);
2945 for (i = 0; i < 2; i++) {
2950 ref2picture = ref_picture;
2957 ref2picture, pix_op,
2958 s->
mv[dir][i][0], s->
mv[dir][i][1] +
2959 2 * block_s * i, block_s, mb_y >> 1);
2961 dest_y += 2 * block_s * s->
linesize;
2968 for (i = 0; i < 2; i++) {
2970 for (j = 0; j < 2; j++) {
2973 ref_picture, pix_op,
2974 s->
mv[dir][2 * i + j][0],
2975 s->
mv[dir][2 * i + j][1],
2981 for (i = 0; i < 2; i++) {
2984 ref_picture, pix_op,
2985 s->
mv[dir][2 * i][0],s->
mv[dir][2 * i][1],
2986 2 * block_s, mb_y >> 1);
3009 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->
quarter_sample;
3010 int my, off, i, mvs;
3029 for (i = 0; i < mvs; i++) {
3030 my = s->
mv[dir][i][1]<<qpel_shift;
3031 my_max =
FFMAX(my_max, my);
3032 my_min =
FFMIN(my_min, my);
3035 off = (
FFMAX(-my_min, my_max) + 63) >> 6;
3044 int16_t *
block,
int i,
uint8_t *dest,
int line_size,
int qscale)
3060 int16_t *
block,
int i,
uint8_t *dest,
int line_size,
int qscale)
3082 memset(s->
ac_val[0][xy ], 0, 32 *
sizeof(int16_t));
3083 memset(s->
ac_val[0][xy + wrap], 0, 32 *
sizeof(int16_t));
3096 memset(s->
ac_val[1][xy], 0, 16 *
sizeof(int16_t));
3097 memset(s->
ac_val[2][xy], 0, 16 *
sizeof(int16_t));
3114 int lowres_flag,
int is_mpeg12)
3129 for(j=0; j<64; j++){
3156 uint8_t *dest_y, *dest_cb, *dest_cr;
3157 int dct_linesize, dct_offset;
3163 const int block_size= lowres_flag ? 8>>s->
avctx->
lowres : 8;
3182 dct_offset = s->
interlaced_dct ? linesize : linesize * block_size;
3186 dest_cb= s->
dest[1];
3187 dest_cr= s->
dest[2];
3270 add_dct(s, block[0], 0, dest_y , dct_linesize);
3271 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
3272 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
3273 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3277 add_dct(s, block[4], 4, dest_cb, uvlinesize);
3278 add_dct(s, block[5], 5, dest_cr, uvlinesize);
3282 dct_offset = s->
interlaced_dct ? uvlinesize : uvlinesize*block_size;
3284 add_dct(s, block[4], 4, dest_cb, dct_linesize);
3285 add_dct(s, block[5], 5, dest_cr, dct_linesize);
3286 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3287 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3289 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
3290 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
3291 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
3292 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
3304 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->
qscale);
3305 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->
qscale);
3306 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->
qscale);
3323 s->
idsp.
idct_put(dest_y + block_size, dct_linesize, block[1]);
3324 s->
idsp.
idct_put(dest_y + dct_offset, dct_linesize, block[2]);
3325 s->
idsp.
idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3334 dct_offset = s->
interlaced_dct ? uvlinesize : uvlinesize*block_size;
3338 s->
idsp.
idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3339 s->
idsp.
idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3341 s->
idsp.
idct_put(dest_cb + block_size, dct_linesize, block[8]);
3342 s->
idsp.
idct_put(dest_cr + block_size, dct_linesize, block[9]);
3343 s->
idsp.
idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
3344 s->
idsp.
idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
3398 s->
dest[0] += s->
mb_y * linesize << mb_size;
3402 s->
dest[0] += (s->
mb_y>>1) * linesize << mb_size;
3426 for(i=0; i<=last; i++){
3427 const int j= scantable[i];
3432 for(i=0; i<=last; i++){
3433 const int j= scantable[i];
3434 const int perm_j= permutation[j];
3435 block[perm_j]= temp[j];
3474 else if (qscale > 31)