78fae1026de7508c03d1af8599b1f9807f57c98e
[ffmpeg.git] / libavcodec / mpegvideo.c
1 /*
2  * The simplest mpeg encoder (well, it was the simplest!)
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of Libav.
9  *
10  * Libav is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * Libav is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 /**
26  * @file
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29
30 #include "libavutil/intmath.h"
31 #include "libavutil/imgutils.h"
32 #include "avcodec.h"
33 #include "dsputil.h"
34 #include "internal.h"
35 #include "mpegvideo.h"
36 #include "mpegvideo_common.h"
37 #include "mjpegenc.h"
38 #include "msmpeg4.h"
39 #include "faandct.h"
40 #include "xvmc_internal.h"
41 #include "thread.h"
42 #include <limits.h>
43
44 //#undef NDEBUG
45 //#include <assert.h>
46
47 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
48                                    DCTELEM *block, int n, int qscale);
49 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
50                                    DCTELEM *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
52                                    DCTELEM *block, int n, int qscale);
53 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
54                                    DCTELEM *block, int n, int qscale);
55 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
56                                    DCTELEM *block, int n, int qscale);
57 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
58                                   DCTELEM *block, int n, int qscale);
59 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
60                                   DCTELEM *block, int n, int qscale);
61
62
63 /* enable all paranoid tests for rounding, overflows, etc... */
64 //#define PARANOID
65
66 //#define DEBUG
67
68
69 static const uint8_t ff_default_chroma_qscale_table[32] = {
70 //   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
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
73 };
74
75 const uint8_t ff_mpeg1_dc_scale_table[128] = {
76 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
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,
85 };
86
87 static const uint8_t mpeg2_dc_scale_table1[128] = {
88 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
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,
97 };
98
99 static const uint8_t mpeg2_dc_scale_table2[128] = {
100 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
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,
109 };
110
111 static const uint8_t mpeg2_dc_scale_table3[128] = {
112 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
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,
121 };
122
123 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
124     ff_mpeg1_dc_scale_table,
125     mpeg2_dc_scale_table1,
126     mpeg2_dc_scale_table2,
127     mpeg2_dc_scale_table3,
128 };
129
130 const enum PixelFormat ff_pixfmt_list_420[] = {
131     PIX_FMT_YUV420P,
132     PIX_FMT_NONE
133 };
134
135 const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
136     PIX_FMT_DXVA2_VLD,
137     PIX_FMT_VAAPI_VLD,
138     PIX_FMT_VDA_VLD,
139     PIX_FMT_YUV420P,
140     PIX_FMT_NONE
141 };
142
143 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *restrict p,
144                                           const uint8_t *end,
145                                           uint32_t * restrict state)
146 {
147     int i;
148
149     assert(p <= end);
150     if (p >= end)
151         return end;
152
153     for (i = 0; i < 3; i++) {
154         uint32_t tmp = *state << 8;
155         *state = tmp + *(p++);
156         if (tmp == 0x100 || p == end)
157             return p;
158     }
159
160     while (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++;
164         else {
165             p++;
166             break;
167         }
168     }
169
170     p = FFMIN(p, end) - 4;
171     *state = AV_RB32(p);
172
173     return p + 4;
174 }
175
176 /* init common dct for both encoder and decoder */
177 av_cold int ff_dct_common_init(MpegEncContext *s)
178 {
179     dsputil_init(&s->dsp, s->avctx);
180
181     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
182     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
183     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
184     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
185     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
186     if (s->flags & CODEC_FLAG_BITEXACT)
187         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
188     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
189
190 #if HAVE_MMX
191     MPV_common_init_mmx(s);
192 #elif ARCH_ALPHA
193     MPV_common_init_axp(s);
194 #elif CONFIG_MLIB
195     MPV_common_init_mlib(s);
196 #elif HAVE_MMI
197     MPV_common_init_mmi(s);
198 #elif ARCH_ARM
199     MPV_common_init_arm(s);
200 #elif HAVE_ALTIVEC
201     MPV_common_init_altivec(s);
202 #elif ARCH_BFIN
203     MPV_common_init_bfin(s);
204 #endif
205
206     /* load & permutate scantables
207      * note: only wmv uses different ones
208      */
209     if (s->alternate_scan) {
210         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
211         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
212     } else {
213         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
214         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
215     }
216     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
217     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
218
219     return 0;
220 }
221
222 void ff_copy_picture(Picture *dst, Picture *src)
223 {
224     *dst = *src;
225     dst->f.type = FF_BUFFER_TYPE_COPY;
226 }
227
228 /**
229  * Release a frame buffer
230  */
231 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
232 {
233     /* Windows Media Image codecs allocate internal buffers with different
234      * dimensions; ignore user defined callbacks for these
235      */
236     if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
237         ff_thread_release_buffer(s->avctx, (AVFrame *) pic);
238     else
239         avcodec_default_release_buffer(s->avctx, (AVFrame *) pic);
240     av_freep(&pic->f.hwaccel_picture_private);
241 }
242
243 /**
244  * Allocate a frame buffer
245  */
246 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
247 {
248     int r;
249
250     if (s->avctx->hwaccel) {
251         assert(!pic->f.hwaccel_picture_private);
252         if (s->avctx->hwaccel->priv_data_size) {
253             pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
254             if (!pic->f.hwaccel_picture_private) {
255                 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
256                 return -1;
257             }
258         }
259     }
260
261     if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
262         r = ff_thread_get_buffer(s->avctx, (AVFrame *) pic);
263     else
264         r = avcodec_default_get_buffer(s->avctx, (AVFrame *) pic);
265
266     if (r < 0 || !pic->f.age || !pic->f.type || !pic->f.data[0]) {
267         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n",
268                r, pic->f.age, pic->f.type, pic->f.data[0]);
269         av_freep(&pic->f.hwaccel_picture_private);
270         return -1;
271     }
272
273     if (s->linesize && (s->linesize   != pic->f.linesize[0] ||
274                         s->uvlinesize != pic->f.linesize[1])) {
275         av_log(s->avctx, AV_LOG_ERROR,
276                "get_buffer() failed (stride changed)\n");
277         free_frame_buffer(s, pic);
278         return -1;
279     }
280
281     if (pic->f.linesize[1] != pic->f.linesize[2]) {
282         av_log(s->avctx, AV_LOG_ERROR,
283                "get_buffer() failed (uv stride mismatch)\n");
284         free_frame_buffer(s, pic);
285         return -1;
286     }
287
288     return 0;
289 }
290
291 /**
292  * allocates a Picture
293  * The pixels are allocated/set by calling get_buffer() if shared = 0
294  */
295 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
296 {
297     const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
298
299     // the + 1 is needed so memset(,,stride*height) does not sig11
300
301     const int mb_array_size = s->mb_stride * s->mb_height;
302     const int b8_array_size = s->b8_stride * s->mb_height * 2;
303     const int b4_array_size = s->b4_stride * s->mb_height * 4;
304     int i;
305     int r = -1;
306
307     if (shared) {
308         assert(pic->f.data[0]);
309         assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
310         pic->f.type = FF_BUFFER_TYPE_SHARED;
311     } else {
312         assert(!pic->f.data[0]);
313
314         if (alloc_frame_buffer(s, pic) < 0)
315             return -1;
316
317         s->linesize   = pic->f.linesize[0];
318         s->uvlinesize = pic->f.linesize[1];
319     }
320
321     if (pic->f.qscale_table == NULL) {
322         if (s->encoding) {
323             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
324                               mb_array_size * sizeof(int16_t), fail)
325             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
326                               mb_array_size * sizeof(int16_t), fail)
327             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
328                               mb_array_size * sizeof(int8_t ), fail)
329         }
330
331         FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
332                           mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
333         FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
334                           (big_mb_num + s->mb_stride) * sizeof(uint8_t),
335                           fail)
336         FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
337                           (big_mb_num + s->mb_stride) * sizeof(uint32_t),
338                           fail)
339         pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
340         pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
341         if (s->out_format == FMT_H264) {
342             for (i = 0; i < 2; i++) {
343                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
344                                   2 * (b4_array_size + 4) * sizeof(int16_t),
345                                   fail)
346                 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
347                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
348                                   4 * mb_array_size * sizeof(uint8_t), fail)
349             }
350             pic->f.motion_subsample_log2 = 2;
351         } else if (s->out_format == FMT_H263 || s->encoding ||
352                    (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
353             for (i = 0; i < 2; i++) {
354                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
355                                   2 * (b8_array_size + 4) * sizeof(int16_t),
356                                   fail)
357                 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
358                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
359                                   4 * mb_array_size * sizeof(uint8_t), fail)
360             }
361             pic->f.motion_subsample_log2 = 3;
362         }
363         if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
364             FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
365                               64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
366         }
367         pic->f.qstride = s->mb_stride;
368         FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
369                           1 * sizeof(AVPanScan), fail)
370     }
371
372     /* It might be nicer if the application would keep track of these
373      * but it would require an API change. */
374     memmove(s->prev_pict_types + 1, s->prev_pict_types,
375             PREV_PICT_TYPES_BUFFER_SIZE-1);
376     s->prev_pict_types[0] =  s->dropable ? AV_PICTURE_TYPE_B : s->pict_type;
377     if (pic->f.age < PREV_PICT_TYPES_BUFFER_SIZE &&
378         s->prev_pict_types[pic->f.age] == AV_PICTURE_TYPE_B)
379         pic->f.age = INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2
380                               // and it is a bit tricky to skip them anyway.
381     pic->owner2 = s;
382
383     return 0;
384 fail: // for  the FF_ALLOCZ_OR_GOTO macro
385     if (r >= 0)
386         free_frame_buffer(s, pic);
387     return -1;
388 }
389
390 /**
391  * deallocates a picture
392  */
393 static void free_picture(MpegEncContext *s, Picture *pic)
394 {
395     int i;
396
397     if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
398         free_frame_buffer(s, pic);
399     }
400
401     av_freep(&pic->mb_var);
402     av_freep(&pic->mc_mb_var);
403     av_freep(&pic->mb_mean);
404     av_freep(&pic->f.mbskip_table);
405     av_freep(&pic->qscale_table_base);
406     av_freep(&pic->mb_type_base);
407     av_freep(&pic->f.dct_coeff);
408     av_freep(&pic->f.pan_scan);
409     pic->f.mb_type = NULL;
410     for (i = 0; i < 2; i++) {
411         av_freep(&pic->motion_val_base[i]);
412         av_freep(&pic->f.ref_index[i]);
413     }
414
415     if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
416         for (i = 0; i < 4; i++) {
417             pic->f.base[i] =
418             pic->f.data[i] = NULL;
419         }
420         pic->f.type = 0;
421     }
422 }
423
424 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base)
425 {
426     int y_size = s->b8_stride * (2 * s->mb_height + 1);
427     int c_size = s->mb_stride * (s->mb_height + 1);
428     int yc_size = y_size + 2 * c_size;
429     int i;
430
431     // edge emu needs blocksize + filter length - 1
432     // (= 17x17 for  halfpel / 21x21 for  h264)
433     FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer,
434                       (s->width + 64) * 2 * 21 * 2, fail);    // (width + edge + align)*interlaced*MBsize*tolerance
435
436     // FIXME should be linesize instead of s->width * 2
437     // but that is not known before get_buffer()
438     FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,
439                       (s->width + 64) * 4 * 16 * 2 * sizeof(uint8_t), fail)
440     s->me.temp         = s->me.scratchpad;
441     s->rd_scratchpad   = s->me.scratchpad;
442     s->b_scratchpad    = s->me.scratchpad;
443     s->obmc_scratchpad = s->me.scratchpad + 16;
444     if (s->encoding) {
445         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
446                           ME_MAP_SIZE * sizeof(uint32_t), fail)
447         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
448                           ME_MAP_SIZE * sizeof(uint32_t), fail)
449         if (s->avctx->noise_reduction) {
450             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
451                               2 * 64 * sizeof(int), fail)
452         }
453     }
454     FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(DCTELEM), fail)
455     s->block = s->blocks[0];
456
457     for (i = 0; i < 12; i++) {
458         s->pblocks[i] = &s->block[i];
459     }
460
461     if (s->out_format == FMT_H263) {
462         /* ac values */
463         FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
464                           yc_size * sizeof(int16_t) * 16, fail);
465         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
466         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
467         s->ac_val[2] = s->ac_val[1] + c_size;
468     }
469
470     return 0;
471 fail:
472     return -1; // free() through MPV_common_end()
473 }
474
475 static void free_duplicate_context(MpegEncContext *s)
476 {
477     if (s == NULL)
478         return;
479
480     av_freep(&s->edge_emu_buffer);
481     av_freep(&s->me.scratchpad);
482     s->me.temp =
483     s->rd_scratchpad =
484     s->b_scratchpad =
485     s->obmc_scratchpad = NULL;
486
487     av_freep(&s->dct_error_sum);
488     av_freep(&s->me.map);
489     av_freep(&s->me.score_map);
490     av_freep(&s->blocks);
491     av_freep(&s->ac_val_base);
492     s->block = NULL;
493 }
494
495 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
496 {
497 #define COPY(a) bak->a = src->a
498     COPY(edge_emu_buffer);
499     COPY(me.scratchpad);
500     COPY(me.temp);
501     COPY(rd_scratchpad);
502     COPY(b_scratchpad);
503     COPY(obmc_scratchpad);
504     COPY(me.map);
505     COPY(me.score_map);
506     COPY(blocks);
507     COPY(block);
508     COPY(start_mb_y);
509     COPY(end_mb_y);
510     COPY(me.map_generation);
511     COPY(pb);
512     COPY(dct_error_sum);
513     COPY(dct_count[0]);
514     COPY(dct_count[1]);
515     COPY(ac_val_base);
516     COPY(ac_val[0]);
517     COPY(ac_val[1]);
518     COPY(ac_val[2]);
519 #undef COPY
520 }
521
522 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
523 {
524     MpegEncContext bak;
525     int i;
526     // FIXME copy only needed parts
527     // START_TIMER
528     backup_duplicate_context(&bak, dst);
529     memcpy(dst, src, sizeof(MpegEncContext));
530     backup_duplicate_context(dst, &bak);
531     for (i = 0; i < 12; i++) {
532         dst->pblocks[i] = &dst->block[i];
533     }
534     // STOP_TIMER("update_duplicate_context")
535     // about 10k cycles / 0.01 sec for  1000frames on 1ghz with 2 threads
536 }
537
538 int ff_mpeg_update_thread_context(AVCodecContext *dst,
539                                   const AVCodecContext *src)
540 {
541     MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
542
543     if (dst == src || !s1->context_initialized)
544         return 0;
545
546     // FIXME can parameters change on I-frames?
547     // in that case dst may need a reinit
548     if (!s->context_initialized) {
549         memcpy(s, s1, sizeof(MpegEncContext));
550
551         s->avctx                 = dst;
552         s->picture_range_start  += MAX_PICTURE_COUNT;
553         s->picture_range_end    += MAX_PICTURE_COUNT;
554         s->bitstream_buffer      = NULL;
555         s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
556
557         MPV_common_init(s);
558     }
559
560     s->avctx->coded_height  = s1->avctx->coded_height;
561     s->avctx->coded_width   = s1->avctx->coded_width;
562     s->avctx->width         = s1->avctx->width;
563     s->avctx->height        = s1->avctx->height;
564
565     s->coded_picture_number = s1->coded_picture_number;
566     s->picture_number       = s1->picture_number;
567     s->input_picture_number = s1->input_picture_number;
568
569     memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
570     memcpy(&s->last_picture, &s1->last_picture,
571            (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
572
573     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
574     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
575     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
576
577     memcpy(s->prev_pict_types, s1->prev_pict_types,
578            PREV_PICT_TYPES_BUFFER_SIZE);
579
580     // Error/bug resilience
581     s->next_p_frame_damaged = s1->next_p_frame_damaged;
582     s->workaround_bugs      = s1->workaround_bugs;
583
584     // MPEG4 timing info
585     memcpy(&s->time_increment_bits, &s1->time_increment_bits,
586            (char *) &s1->shape - (char *) &s1->time_increment_bits);
587
588     // B-frame info
589     s->max_b_frames = s1->max_b_frames;
590     s->low_delay    = s1->low_delay;
591     s->dropable     = s1->dropable;
592
593     // DivX handling (doesn't work)
594     s->divx_packed  = s1->divx_packed;
595
596     if (s1->bitstream_buffer) {
597         if (s1->bitstream_buffer_size +
598             FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
599             av_fast_malloc(&s->bitstream_buffer,
600                            &s->allocated_bitstream_buffer_size,
601                            s1->allocated_bitstream_buffer_size);
602             s->bitstream_buffer_size = s1->bitstream_buffer_size;
603         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
604                s1->bitstream_buffer_size);
605         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
606                FF_INPUT_BUFFER_PADDING_SIZE);
607     }
608
609     // MPEG2/interlacing info
610     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
611            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
612
613     if (!s1->first_field) {
614         s->last_pict_type = s1->pict_type;
615         if (s1->current_picture_ptr)
616             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
617
618         if (s1->pict_type != AV_PICTURE_TYPE_B) {
619             s->last_non_b_pict_type = s1->pict_type;
620         }
621     }
622
623     return 0;
624 }
625
626 /**
627  * sets the given MpegEncContext to common defaults
628  * (same for encoding and decoding).
629  * the changed fields will not depend upon the
630  * prior state of the MpegEncContext.
631  */
632 void MPV_common_defaults(MpegEncContext *s)
633 {
634     s->y_dc_scale_table      =
635     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
636     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
637     s->progressive_frame     = 1;
638     s->progressive_sequence  = 1;
639     s->picture_structure     = PICT_FRAME;
640
641     s->coded_picture_number  = 0;
642     s->picture_number        = 0;
643     s->input_picture_number  = 0;
644
645     s->picture_in_gop_number = 0;
646
647     s->f_code                = 1;
648     s->b_code                = 1;
649
650     s->picture_range_start   = 0;
651     s->picture_range_end     = MAX_PICTURE_COUNT;
652 }
653
654 /**
655  * sets the given MpegEncContext to defaults for decoding.
656  * the changed fields will not depend upon
657  * the prior state of the MpegEncContext.
658  */
659 void MPV_decode_defaults(MpegEncContext *s)
660 {
661     MPV_common_defaults(s);
662 }
663
664 /**
665  * init common structure for both encoder and decoder.
666  * this assumes that some variables like width/height are already set
667  */
668 av_cold int MPV_common_init(MpegEncContext *s)
669 {
670     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y,
671         threads = (s->encoding ||
672                    (HAVE_THREADS &&
673                     s->avctx->active_thread_type & FF_THREAD_SLICE)) ?
674                   s->avctx->thread_count : 1;
675
676     if (s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
677         s->mb_height = (s->height + 31) / 32 * 2;
678     else if (s->codec_id != CODEC_ID_H264)
679         s->mb_height = (s->height + 15) / 16;
680
681     if (s->avctx->pix_fmt == PIX_FMT_NONE) {
682         av_log(s->avctx, AV_LOG_ERROR,
683                "decoding to PIX_FMT_NONE is not supported.\n");
684         return -1;
685     }
686
687     if ((s->encoding || (s->avctx->active_thread_type & FF_THREAD_SLICE)) &&
688         (s->avctx->thread_count > MAX_THREADS ||
689          (s->avctx->thread_count > s->mb_height && s->mb_height))) {
690         int max_threads = FFMIN(MAX_THREADS, s->mb_height);
691         av_log(s->avctx, AV_LOG_WARNING,
692                "too many threads (%d), reducing to %d\n",
693                s->avctx->thread_count, max_threads);
694         threads = max_threads;
695     }
696
697     if ((s->width || s->height) &&
698         av_image_check_size(s->width, s->height, 0, s->avctx))
699         return -1;
700
701     ff_dct_common_init(s);
702
703     s->flags  = s->avctx->flags;
704     s->flags2 = s->avctx->flags2;
705
706     if (s->width && s->height) {
707         s->mb_width   = (s->width + 15) / 16;
708         s->mb_stride  = s->mb_width + 1;
709         s->b8_stride  = s->mb_width * 2 + 1;
710         s->b4_stride  = s->mb_width * 4 + 1;
711         mb_array_size = s->mb_height * s->mb_stride;
712         mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
713
714         /* set chroma shifts */
715         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
716                                       &(s->chroma_y_shift) );
717
718         /* set default edge pos, will be overriden
719          * in decode_header if needed */
720         s->h_edge_pos = s->mb_width * 16;
721         s->v_edge_pos = s->mb_height * 16;
722
723         s->mb_num     = s->mb_width * s->mb_height;
724
725         s->block_wrap[0] =
726         s->block_wrap[1] =
727         s->block_wrap[2] =
728         s->block_wrap[3] = s->b8_stride;
729         s->block_wrap[4] =
730         s->block_wrap[5] = s->mb_stride;
731
732         y_size  = s->b8_stride * (2 * s->mb_height + 1);
733         c_size  = s->mb_stride * (s->mb_height + 1);
734         yc_size = y_size + 2   * c_size;
735
736         /* convert fourcc to upper case */
737         s->codec_tag          = avpriv_toupper4(s->avctx->codec_tag);
738
739         s->stream_codec_tag   = avpriv_toupper4(s->avctx->stream_codec_tag);
740
741         s->avctx->coded_frame = (AVFrame *)&s->current_picture;
742
743         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
744                           fail); // error ressilience code looks cleaner with this
745         for (y = 0; y < s->mb_height; y++)
746             for (x = 0; x < s->mb_width; x++)
747                 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
748
749         s->mb_index2xy[s->mb_height * s->mb_width] =
750                        (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
751
752         if (s->encoding) {
753             /* Allocate MV tables */
754             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,
755                               mv_table_size * 2 * sizeof(int16_t), fail);
756             FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,
757                               mv_table_size * 2 * sizeof(int16_t), fail);
758             FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,
759                               mv_table_size * 2 * sizeof(int16_t), fail);
760             FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,
761                               mv_table_size * 2 * sizeof(int16_t), fail);
762             FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,
763                               mv_table_size * 2 * sizeof(int16_t), fail);
764             FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,
765                               mv_table_size * 2 * sizeof(int16_t), fail);
766             s->p_mv_table            = s->p_mv_table_base +
767                                        s->mb_stride + 1;
768             s->b_forw_mv_table       = s->b_forw_mv_table_base +
769                                        s->mb_stride + 1;
770             s->b_back_mv_table       = s->b_back_mv_table_base +
771                                        s->mb_stride + 1;
772             s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base +
773                                        s->mb_stride + 1;
774             s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base +
775                                        s->mb_stride + 1;
776             s->b_direct_mv_table     = s->b_direct_mv_table_base +
777                                        s->mb_stride + 1;
778
779             if (s->msmpeg4_version) {
780                 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
781                                   2 * 2 * (MAX_LEVEL + 1) *
782                                   (MAX_RUN + 1) * 2 * sizeof(int), fail);
783             }
784             FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
785
786             /* Allocate MB type table */
787             FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size *
788                               sizeof(uint16_t), fail); // needed for encoding
789
790             FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size *
791                               sizeof(int), fail);
792
793             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,
794                               64 * 32   * sizeof(int), fail);
795             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,
796                               64 * 32   * sizeof(int), fail);
797             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,
798                               64 * 32 * 2 * sizeof(uint16_t), fail);
799             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,
800                               64 * 32 * 2 * sizeof(uint16_t), fail);
801             FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
802                               MAX_PICTURE_COUNT * sizeof(Picture *), fail);
803             FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
804                               MAX_PICTURE_COUNT * sizeof(Picture *), fail);
805
806             if (s->avctx->noise_reduction) {
807                 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
808                                   2 * 64 * sizeof(uint16_t), fail);
809             }
810         }
811     }
812
813     s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
814     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
815                       s->picture_count * sizeof(Picture), fail);
816     for (i = 0; i < s->picture_count; i++) {
817         avcodec_get_frame_defaults((AVFrame *) &s->picture[i]);
818     }
819
820     if (s->width && s->height) {
821         FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
822                           mb_array_size * sizeof(uint8_t), fail);
823
824         if (s->codec_id == CODEC_ID_MPEG4 ||
825             (s->flags & CODEC_FLAG_INTERLACED_ME)) {
826             /* interlaced direct mode decoding tables */
827             for (i = 0; i < 2; i++) {
828                 int j, k;
829                 for (j = 0; j < 2; j++) {
830                     for (k = 0; k < 2; k++) {
831                         FF_ALLOCZ_OR_GOTO(s->avctx,
832                                           s->b_field_mv_table_base[i][j][k],
833                                           mv_table_size * 2 * sizeof(int16_t),
834                                           fail);
835                         s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
836                                                        s->mb_stride + 1;
837                     }
838                     FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j],
839                                       mb_array_size * 2 * sizeof(uint8_t),
840                                       fail);
841                     FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j],
842                                       mv_table_size * 2 * sizeof(int16_t),
843                                       fail);
844                     s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]
845                                                 + s->mb_stride + 1;
846                 }
847                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i],
848                                   mb_array_size * 2 * sizeof(uint8_t),
849                                   fail);
850             }
851         }
852         if (s->out_format == FMT_H263) {
853             /* cbp values */
854             FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
855             s->coded_block = s->coded_block_base + s->b8_stride + 1;
856
857             /* cbp, ac_pred, pred_dir */
858             FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table,
859                               mb_array_size * sizeof(uint8_t), fail);
860             FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table,
861                               mb_array_size * sizeof(uint8_t), fail);
862         }
863
864         if (s->h263_pred || s->h263_plus || !s->encoding) {
865             /* dc values */
866             // MN: we need these for  error resilience of intra-frames
867             FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base,
868                               yc_size * sizeof(int16_t), fail);
869             s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
870             s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
871             s->dc_val[2] = s->dc_val[1] + c_size;
872             for (i = 0; i < yc_size; i++)
873                 s->dc_val_base[i] = 1024;
874         }
875
876         /* which mb is a intra block */
877         FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
878         memset(s->mbintra_table, 1, mb_array_size);
879
880         /* init macroblock skip table */
881         FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
882         // Note the + 1 is for  a quicker mpeg4 slice_end detection
883         FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types,
884                           PREV_PICT_TYPES_BUFFER_SIZE, fail);
885
886         s->parse_context.state = -1;
887         if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
888             (s->avctx->debug_mv)) {
889             s->visualization_buffer[0] = av_malloc((s->mb_width * 16 +
890                         2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
891             s->visualization_buffer[1] = av_malloc((s->mb_width * 16 +
892                         2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
893             s->visualization_buffer[2] = av_malloc((s->mb_width * 16 +
894                         2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
895         }
896     }
897
898     s->context_initialized = 1;
899     s->thread_context[0]   = s;
900
901     if (s->width && s->height) {
902         if (s->encoding || (HAVE_THREADS &&
903                             s->avctx->active_thread_type&FF_THREAD_SLICE)) {
904             for (i = 1; i < threads; i++) {
905                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
906                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
907             }
908
909             for (i = 0; i < threads; i++) {
910                 if (init_duplicate_context(s->thread_context[i], s) < 0)
911                     goto fail;
912                     s->thread_context[i]->start_mb_y =
913                         (s->mb_height * (i) + s->avctx->thread_count / 2) /
914                         s->avctx->thread_count;
915                     s->thread_context[i]->end_mb_y   =
916                         (s->mb_height * (i + 1) + s->avctx->thread_count / 2) /
917                         s->avctx->thread_count;
918             }
919         } else {
920             if (init_duplicate_context(s, s) < 0)
921                 goto fail;
922             s->start_mb_y = 0;
923             s->end_mb_y   = s->mb_height;
924         }
925     }
926
927     return 0;
928  fail:
929     MPV_common_end(s);
930     return -1;
931 }
932
933 /* init common structure for both encoder and decoder */
934 void MPV_common_end(MpegEncContext *s)
935 {
936     int i, j, k;
937
938     if (s->encoding || (HAVE_THREADS &&
939         s->avctx->active_thread_type & FF_THREAD_SLICE)) {
940         for (i = 0; i < s->avctx->thread_count; i++) {
941             free_duplicate_context(s->thread_context[i]);
942         }
943         for (i = 1; i < s->avctx->thread_count; i++) {
944             av_freep(&s->thread_context[i]);
945         }
946     } else free_duplicate_context(s);
947
948     av_freep(&s->parse_context.buffer);
949     s->parse_context.buffer_size = 0;
950
951     av_freep(&s->mb_type);
952     av_freep(&s->p_mv_table_base);
953     av_freep(&s->b_forw_mv_table_base);
954     av_freep(&s->b_back_mv_table_base);
955     av_freep(&s->b_bidir_forw_mv_table_base);
956     av_freep(&s->b_bidir_back_mv_table_base);
957     av_freep(&s->b_direct_mv_table_base);
958     s->p_mv_table            = NULL;
959     s->b_forw_mv_table       = NULL;
960     s->b_back_mv_table       = NULL;
961     s->b_bidir_forw_mv_table = NULL;
962     s->b_bidir_back_mv_table = NULL;
963     s->b_direct_mv_table     = NULL;
964     for (i = 0; i < 2; i++) {
965         for (j = 0; j < 2; j++) {
966             for (k = 0; k < 2; k++) {
967                 av_freep(&s->b_field_mv_table_base[i][j][k]);
968                 s->b_field_mv_table[i][j][k] = NULL;
969             }
970             av_freep(&s->b_field_select_table[i][j]);
971             av_freep(&s->p_field_mv_table_base[i][j]);
972             s->p_field_mv_table[i][j] = NULL;
973         }
974         av_freep(&s->p_field_select_table[i]);
975     }
976
977     av_freep(&s->dc_val_base);
978     av_freep(&s->coded_block_base);
979     av_freep(&s->mbintra_table);
980     av_freep(&s->cbp_table);
981     av_freep(&s->pred_dir_table);
982
983     av_freep(&s->mbskip_table);
984     av_freep(&s->prev_pict_types);
985     av_freep(&s->bitstream_buffer);
986     s->allocated_bitstream_buffer_size = 0;
987
988     av_freep(&s->avctx->stats_out);
989     av_freep(&s->ac_stats);
990     av_freep(&s->error_status_table);
991     av_freep(&s->mb_index2xy);
992     av_freep(&s->lambda_table);
993     av_freep(&s->q_intra_matrix);
994     av_freep(&s->q_inter_matrix);
995     av_freep(&s->q_intra_matrix16);
996     av_freep(&s->q_inter_matrix16);
997     av_freep(&s->input_picture);
998     av_freep(&s->reordered_input_picture);
999     av_freep(&s->dct_offset);
1000
1001     if (s->picture && !s->avctx->internal->is_copy) {
1002         for (i = 0; i < s->picture_count; i++) {
1003             free_picture(s, &s->picture[i]);
1004         }
1005     }
1006     av_freep(&s->picture);
1007     s->context_initialized      = 0;
1008     s->last_picture_ptr         =
1009     s->next_picture_ptr         =
1010     s->current_picture_ptr      = NULL;
1011     s->linesize = s->uvlinesize = 0;
1012
1013     for (i = 0; i < 3; i++)
1014         av_freep(&s->visualization_buffer[i]);
1015
1016     if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
1017         avcodec_default_free_buffers(s->avctx);
1018 }
1019
1020 void init_rl(RLTable *rl,
1021              uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1022 {
1023     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1024     uint8_t index_run[MAX_RUN + 1];
1025     int last, run, level, start, end, i;
1026
1027     /* If  table is static, we can quit if rl->max_level[0] is not NULL */
1028     if (static_store && rl->max_level[0])
1029         return;
1030
1031     /* compute max_level[], max_run[] and index_run[] */
1032     for (last = 0; last < 2; last++) {
1033         if (last == 0) {
1034             start = 0;
1035             end = rl->last;
1036         } else {
1037             start = rl->last;
1038             end = rl->n;
1039         }
1040
1041         memset(max_level, 0, MAX_RUN + 1);
1042         memset(max_run, 0, MAX_LEVEL + 1);
1043         memset(index_run, rl->n, MAX_RUN + 1);
1044         for (i = start; i < end; i++) {
1045             run   = rl->table_run[i];
1046             level = rl->table_level[i];
1047             if (index_run[run] == rl->n)
1048                 index_run[run] = i;
1049             if (level > max_level[run])
1050                 max_level[run] = level;
1051             if (run > max_run[level])
1052                 max_run[level] = run;
1053         }
1054         if (static_store)
1055             rl->max_level[last] = static_store[last];
1056         else
1057             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1058         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1059         if (static_store)
1060             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1061         else
1062             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1063         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1064         if (static_store)
1065             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1066         else
1067             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1068         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1069     }
1070 }
1071
1072 void init_vlc_rl(RLTable *rl)
1073 {
1074     int i, q;
1075
1076     for (q = 0; q < 32; q++) {
1077         int qmul = q * 2;
1078         int qadd = (q - 1) | 1;
1079
1080         if (q == 0) {
1081             qmul = 1;
1082             qadd = 0;
1083         }
1084         for (i = 0; i < rl->vlc.table_size; i++) {
1085             int code = rl->vlc.table[i][0];
1086             int len  = rl->vlc.table[i][1];
1087             int level, run;
1088
1089             if (len == 0) { // illegal code
1090                 run   = 66;
1091                 level = MAX_LEVEL;
1092             } else if (len < 0) { // more bits needed
1093                 run   = 0;
1094                 level = code;
1095             } else {
1096                 if (code == rl->n) { // esc
1097                     run   = 66;
1098                     level =  0;
1099                 } else {
1100                     run   = rl->table_run[code] + 1;
1101                     level = rl->table_level[code] * qmul + qadd;
1102                     if (code >= rl->last) run += 192;
1103                 }
1104             }
1105             rl->rl_vlc[q][i].len   = len;
1106             rl->rl_vlc[q][i].level = level;
1107             rl->rl_vlc[q][i].run   = run;
1108         }
1109     }
1110 }
1111
1112 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1113 {
1114     int i;
1115
1116     /* release non reference frames */
1117     for (i = 0; i < s->picture_count; i++) {
1118         if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1119             (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1120             (remove_current || &s->picture[i] !=  s->current_picture_ptr)
1121             /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1122             free_frame_buffer(s, &s->picture[i]);
1123         }
1124     }
1125 }
1126
1127 int ff_find_unused_picture(MpegEncContext *s, int shared)
1128 {
1129     int i;
1130
1131     if (shared) {
1132         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1133             if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1134                 return i;
1135         }
1136     } else {
1137         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1138             if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type != 0)
1139                 return i; // FIXME
1140         }
1141         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1142             if (s->picture[i].f.data[0] == NULL)
1143                 return i;
1144         }
1145     }
1146
1147     av_log(s->avctx, AV_LOG_FATAL,
1148            "Internal error, picture buffer overflow\n");
1149     /* We could return -1, but the codec would crash trying to draw into a
1150      * non-existing frame anyway. This is safer than waiting for a random crash.
1151      * Also the return of this is never useful, an encoder must only allocate
1152      * as much as allowed in the specification. This has no relationship to how
1153      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1154      * enough for such valid streams).
1155      * Plus, a decoder has to check stream validity and remove frames if too
1156      * many reference frames are around. Waiting for "OOM" is not correct at
1157      * all. Similarly, missing reference frames have to be replaced by
1158      * interpolated/MC frames, anything else is a bug in the codec ...
1159      */
1160     abort();
1161     return -1;
1162 }
1163
1164 static void update_noise_reduction(MpegEncContext *s){
1165     int intra, i;
1166
1167     for(intra=0; intra<2; intra++){
1168         if(s->dct_count[intra] > (1<<16)){
1169             for(i=0; i<64; i++){
1170                 s->dct_error_sum[intra][i] >>=1;
1171             }
1172             s->dct_count[intra] >>= 1;
1173         }
1174
1175         for(i=0; i<64; i++){
1176             s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1177         }
1178     }
1179 }
1180
1181 /**
1182  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1183  */
1184 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1185 {
1186     int i;
1187     Picture *pic;
1188     s->mb_skipped = 0;
1189
1190     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1191
1192     /* mark&release old frames */
1193     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->f.data[0]) {
1194       if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1195           if (s->last_picture_ptr->owner2 == s)
1196               free_frame_buffer(s, s->last_picture_ptr);
1197
1198         /* release forgotten pictures */
1199         /* if(mpeg124/h263) */
1200         if(!s->encoding){
1201             for(i=0; i<s->picture_count; i++){
1202                 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].f.reference) {
1203                     if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1204                         av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1205                     free_frame_buffer(s, &s->picture[i]);
1206                 }
1207             }
1208         }
1209       }
1210     }
1211
1212     if(!s->encoding){
1213         ff_release_unused_pictures(s, 1);
1214
1215         if (s->current_picture_ptr && s->current_picture_ptr->f.data[0] == NULL)
1216             pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1217         else{
1218             i= ff_find_unused_picture(s, 0);
1219             pic= &s->picture[i];
1220         }
1221
1222         pic->f.reference = 0;
1223         if (!s->dropable){
1224             if (s->codec_id == CODEC_ID_H264)
1225                 pic->f.reference = s->picture_structure;
1226             else if (s->pict_type != AV_PICTURE_TYPE_B)
1227                 pic->f.reference = 3;
1228         }
1229
1230         pic->f.coded_picture_number = s->coded_picture_number++;
1231
1232         if(ff_alloc_picture(s, pic, 0) < 0)
1233             return -1;
1234
1235         s->current_picture_ptr= pic;
1236         //FIXME use only the vars from current_pic
1237         s->current_picture_ptr->f.top_field_first = s->top_field_first;
1238         if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1239             if(s->picture_structure != PICT_FRAME)
1240                 s->current_picture_ptr->f.top_field_first = (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1241         }
1242         s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame && !s->progressive_sequence;
1243         s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1244     }
1245
1246     s->current_picture_ptr->f.pict_type = s->pict_type;
1247 //    if(s->flags && CODEC_FLAG_QSCALE)
1248   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1249     s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1250
1251     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1252
1253     if (s->pict_type != AV_PICTURE_TYPE_B) {
1254         s->last_picture_ptr= s->next_picture_ptr;
1255         if(!s->dropable)
1256             s->next_picture_ptr= s->current_picture_ptr;
1257     }
1258 /*    av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1259         s->last_picture_ptr    ? s->last_picture_ptr->f.data[0]    : NULL,
1260         s->next_picture_ptr    ? s->next_picture_ptr->f.data[0]    : NULL,
1261         s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1262         s->pict_type, s->dropable);*/
1263
1264     if(s->codec_id != CODEC_ID_H264){
1265         if ((s->last_picture_ptr == NULL || s->last_picture_ptr->f.data[0] == NULL) &&
1266            (s->pict_type!=AV_PICTURE_TYPE_I || s->picture_structure != PICT_FRAME)){
1267             if (s->pict_type != AV_PICTURE_TYPE_I)
1268                 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1269             else if (s->picture_structure != PICT_FRAME)
1270                 av_log(avctx, AV_LOG_INFO, "allocate dummy last picture for field based first keyframe\n");
1271
1272             /* Allocate a dummy frame */
1273             i= ff_find_unused_picture(s, 0);
1274             s->last_picture_ptr= &s->picture[i];
1275             if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1276                 return -1;
1277             ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1278             ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1279         }
1280         if ((s->next_picture_ptr == NULL || s->next_picture_ptr->f.data[0] == NULL) && s->pict_type == AV_PICTURE_TYPE_B) {
1281             /* Allocate a dummy frame */
1282             i= ff_find_unused_picture(s, 0);
1283             s->next_picture_ptr= &s->picture[i];
1284             if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1285                 return -1;
1286             ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1287             ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1288         }
1289     }
1290
1291     if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1292     if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1293
1294     assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr && s->last_picture_ptr->f.data[0]));
1295
1296     if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1297         int i;
1298         for(i=0; i<4; i++){
1299             if(s->picture_structure == PICT_BOTTOM_FIELD){
1300                  s->current_picture.f.data[i] += s->current_picture.f.linesize[i];
1301             }
1302             s->current_picture.f.linesize[i] *= 2;
1303             s->last_picture.f.linesize[i]    *= 2;
1304             s->next_picture.f.linesize[i]    *= 2;
1305         }
1306     }
1307
1308     s->error_recognition= avctx->error_recognition;
1309
1310     /* set dequantizer, we can't do it during init as it might change for mpeg4
1311        and we can't do it in the header decode as init is not called for mpeg4 there yet */
1312     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1313         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1314         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1315     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1316         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1317         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1318     }else{
1319         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1320         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1321     }
1322
1323     if(s->dct_error_sum){
1324         assert(s->avctx->noise_reduction && s->encoding);
1325
1326         update_noise_reduction(s);
1327     }
1328
1329     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1330         return ff_xvmc_field_start(s, avctx);
1331
1332     return 0;
1333 }
1334
1335 /* generic function for encode/decode called after a frame has been coded/decoded */
1336 void MPV_frame_end(MpegEncContext *s)
1337 {
1338     int i;
1339     /* redraw edges for the frame if decoding didn't complete */
1340     //just to make sure that all data is rendered.
1341     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1342         ff_xvmc_field_end(s);
1343    }else if((s->error_count || s->encoding)
1344        && !s->avctx->hwaccel
1345        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1346        && s->unrestricted_mv
1347        && s->current_picture.f.reference
1348        && !s->intra_only
1349        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1350             int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1351             int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1352             s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
1353                               s->h_edge_pos             , s->v_edge_pos,
1354                               EDGE_WIDTH        , EDGE_WIDTH        , EDGE_TOP | EDGE_BOTTOM);
1355             s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
1356                               s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1357                               EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1358             s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
1359                               s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1360                               EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1361     }
1362
1363     emms_c();
1364
1365     s->last_pict_type    = s->pict_type;
1366     s->last_lambda_for[s->pict_type] = s->current_picture_ptr->f.quality;
1367     if(s->pict_type!=AV_PICTURE_TYPE_B){
1368         s->last_non_b_pict_type= s->pict_type;
1369     }
1370 #if 0
1371         /* copy back current_picture variables */
1372     for(i=0; i<MAX_PICTURE_COUNT; i++){
1373         if(s->picture[i].f.data[0] == s->current_picture.f.data[0]){
1374             s->picture[i]= s->current_picture;
1375             break;
1376         }
1377     }
1378     assert(i<MAX_PICTURE_COUNT);
1379 #endif
1380
1381     if(s->encoding){
1382         /* release non-reference frames */
1383         for(i=0; i<s->picture_count; i++){
1384             if (s->picture[i].f.data[0] && !s->picture[i].f.reference /*&& s->picture[i].type != FF_BUFFER_TYPE_SHARED*/) {
1385                 free_frame_buffer(s, &s->picture[i]);
1386             }
1387         }
1388     }
1389     // clear copies, to avoid confusion
1390 #if 0
1391     memset(&s->last_picture, 0, sizeof(Picture));
1392     memset(&s->next_picture, 0, sizeof(Picture));
1393     memset(&s->current_picture, 0, sizeof(Picture));
1394 #endif
1395     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1396
1397     if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1398         ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1399     }
1400 }
1401
1402 /**
1403  * draws an line from (ex, ey) -> (sx, sy).
1404  * @param w width of the image
1405  * @param h height of the image
1406  * @param stride stride/linesize of the image
1407  * @param color color of the arrow
1408  */
1409 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1410     int x, y, fr, f;
1411
1412     sx= av_clip(sx, 0, w-1);
1413     sy= av_clip(sy, 0, h-1);
1414     ex= av_clip(ex, 0, w-1);
1415     ey= av_clip(ey, 0, h-1);
1416
1417     buf[sy*stride + sx]+= color;
1418
1419     if(FFABS(ex - sx) > FFABS(ey - sy)){
1420         if(sx > ex){
1421             FFSWAP(int, sx, ex);
1422             FFSWAP(int, sy, ey);
1423         }
1424         buf+= sx + sy*stride;
1425         ex-= sx;
1426         f= ((ey-sy)<<16)/ex;
1427         for(x= 0; x <= ex; x++){
1428             y = (x*f)>>16;
1429             fr= (x*f)&0xFFFF;
1430             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1431             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1432         }
1433     }else{
1434         if(sy > ey){
1435             FFSWAP(int, sx, ex);
1436             FFSWAP(int, sy, ey);
1437         }
1438         buf+= sx + sy*stride;
1439         ey-= sy;
1440         if(ey) f= ((ex-sx)<<16)/ey;
1441         else   f= 0;
1442         for(y= 0; y <= ey; y++){
1443             x = (y*f)>>16;
1444             fr= (y*f)&0xFFFF;
1445             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1446             buf[y*stride + x+1]+= (color*         fr )>>16;
1447         }
1448     }
1449 }
1450
1451 /**
1452  * draws an arrow from (ex, ey) -> (sx, sy).
1453  * @param w width of the image
1454  * @param h height of the image
1455  * @param stride stride/linesize of the image
1456  * @param color color of the arrow
1457  */
1458 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1459     int dx,dy;
1460
1461     sx= av_clip(sx, -100, w+100);
1462     sy= av_clip(sy, -100, h+100);
1463     ex= av_clip(ex, -100, w+100);
1464     ey= av_clip(ey, -100, h+100);
1465
1466     dx= ex - sx;
1467     dy= ey - sy;
1468
1469     if(dx*dx + dy*dy > 3*3){
1470         int rx=  dx + dy;
1471         int ry= -dx + dy;
1472         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1473
1474         //FIXME subpixel accuracy
1475         rx= ROUNDED_DIV(rx*3<<4, length);
1476         ry= ROUNDED_DIV(ry*3<<4, length);
1477
1478         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1479         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1480     }
1481     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1482 }
1483
1484 /**
1485  * prints debuging info for the given picture.
1486  */
1487 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1488
1489     if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1490
1491     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1492         int x,y;
1493
1494         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1495         switch (pict->pict_type) {
1496             case AV_PICTURE_TYPE_I: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1497             case AV_PICTURE_TYPE_P: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1498             case AV_PICTURE_TYPE_B: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1499             case AV_PICTURE_TYPE_S: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1500             case AV_PICTURE_TYPE_SI: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1501             case AV_PICTURE_TYPE_SP: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1502         }
1503         for(y=0; y<s->mb_height; y++){
1504             for(x=0; x<s->mb_width; x++){
1505                 if(s->avctx->debug&FF_DEBUG_SKIP){
1506                     int count= s->mbskip_table[x + y*s->mb_stride];
1507                     if(count>9) count=9;
1508                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1509                 }
1510                 if(s->avctx->debug&FF_DEBUG_QP){
1511                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1512                 }
1513                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1514                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1515                     //Type & MV direction
1516                     if(IS_PCM(mb_type))
1517                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1518                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1519                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1520                     else if(IS_INTRA4x4(mb_type))
1521                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1522                     else if(IS_INTRA16x16(mb_type))
1523                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1524                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1525                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1526                     else if(IS_DIRECT(mb_type))
1527                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1528                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1529                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1530                     else if(IS_GMC(mb_type))
1531                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1532                     else if(IS_SKIP(mb_type))
1533                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1534                     else if(!USES_LIST(mb_type, 1))
1535                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1536                     else if(!USES_LIST(mb_type, 0))
1537                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1538                     else{
1539                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1540                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1541                     }
1542
1543                     //segmentation
1544                     if(IS_8X8(mb_type))
1545                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1546                     else if(IS_16X8(mb_type))
1547                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1548                     else if(IS_8X16(mb_type))
1549                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1550                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1551                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1552                     else
1553                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1554
1555
1556                     if(IS_INTERLACED(mb_type))
1557                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1558                     else
1559                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1560                 }
1561 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1562             }
1563             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1564         }
1565     }
1566
1567     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1568         const int shift= 1 + s->quarter_sample;
1569         int mb_y;
1570         uint8_t *ptr;
1571         int i;
1572         int h_chroma_shift, v_chroma_shift, block_height;
1573         const int width = s->avctx->width;
1574         const int height= s->avctx->height;
1575         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1576         const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1577         s->low_delay=0; //needed to see the vectors without trashing the buffers
1578
1579         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1580         for(i=0; i<3; i++){
1581             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1582             pict->data[i]= s->visualization_buffer[i];
1583         }
1584         pict->type= FF_BUFFER_TYPE_COPY;
1585         ptr= pict->data[0];
1586         block_height = 16>>v_chroma_shift;
1587
1588         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1589             int mb_x;
1590             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1591                 const int mb_index= mb_x + mb_y*s->mb_stride;
1592                 if((s->avctx->debug_mv) && pict->motion_val){
1593                   int type;
1594                   for(type=0; type<3; type++){
1595                     int direction = 0;
1596                     switch (type) {
1597                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1598                                 continue;
1599                               direction = 0;
1600                               break;
1601                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1602                                 continue;
1603                               direction = 0;
1604                               break;
1605                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1606                                 continue;
1607                               direction = 1;
1608                               break;
1609                     }
1610                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1611                         continue;
1612
1613                     if(IS_8X8(pict->mb_type[mb_index])){
1614                       int i;
1615                       for(i=0; i<4; i++){
1616                         int sx= mb_x*16 + 4 + 8*(i&1);
1617                         int sy= mb_y*16 + 4 + 8*(i>>1);
1618                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1619                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1620                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1621                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1622                       }
1623                     }else if(IS_16X8(pict->mb_type[mb_index])){
1624                       int i;
1625                       for(i=0; i<2; i++){
1626                         int sx=mb_x*16 + 8;
1627                         int sy=mb_y*16 + 4 + 8*i;
1628                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1629                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1630                         int my=(pict->motion_val[direction][xy][1]>>shift);
1631
1632                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1633                             my*=2;
1634
1635                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1636                       }
1637                     }else if(IS_8X16(pict->mb_type[mb_index])){
1638                       int i;
1639                       for(i=0; i<2; i++){
1640                         int sx=mb_x*16 + 4 + 8*i;
1641                         int sy=mb_y*16 + 8;
1642                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1643                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1644                         int my=(pict->motion_val[direction][xy][1]>>shift);
1645
1646                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1647                             my*=2;
1648
1649                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1650                       }
1651                     }else{
1652                       int sx= mb_x*16 + 8;
1653                       int sy= mb_y*16 + 8;
1654                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1655                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1656                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1657                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1658                     }
1659                   }
1660                 }
1661                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1662                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1663                     int y;
1664                     for(y=0; y<block_height; y++){
1665                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1666                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1667                     }
1668                 }
1669                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1670                     int mb_type= pict->mb_type[mb_index];
1671                     uint64_t u,v;
1672                     int y;
1673 #define COLOR(theta, r)\
1674 u= (int)(128 + r*cos(theta*3.141592/180));\
1675 v= (int)(128 + r*sin(theta*3.141592/180));
1676
1677
1678                     u=v=128;
1679                     if(IS_PCM(mb_type)){
1680                         COLOR(120,48)
1681                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1682                         COLOR(30,48)
1683                     }else if(IS_INTRA4x4(mb_type)){
1684                         COLOR(90,48)
1685                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1686 //                        COLOR(120,48)
1687                     }else if(IS_DIRECT(mb_type)){
1688                         COLOR(150,48)
1689                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1690                         COLOR(170,48)
1691                     }else if(IS_GMC(mb_type)){
1692                         COLOR(190,48)
1693                     }else if(IS_SKIP(mb_type)){
1694 //                        COLOR(180,48)
1695                     }else if(!USES_LIST(mb_type, 1)){
1696                         COLOR(240,48)
1697                     }else if(!USES_LIST(mb_type, 0)){
1698                         COLOR(0,48)
1699                     }else{
1700                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1701                         COLOR(300,48)
1702                     }
1703
1704                     u*= 0x0101010101010101ULL;
1705                     v*= 0x0101010101010101ULL;
1706                     for(y=0; y<block_height; y++){
1707                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1708                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1709                     }
1710
1711                     //segmentation
1712                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1713                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1714                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1715                     }
1716                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1717                         for(y=0; y<16; y++)
1718                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1719                     }
1720                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1721                         int dm= 1 << (mv_sample_log2-2);
1722                         for(i=0; i<4; i++){
1723                             int sx= mb_x*16 + 8*(i&1);
1724                             int sy= mb_y*16 + 8*(i>>1);
1725                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1726                             //FIXME bidir
1727                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1728                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1729                                 for(y=0; y<8; y++)
1730                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1731                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1732                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1733                         }
1734                     }
1735
1736                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1737                         // hmm
1738                     }
1739                 }
1740                 s->mbskip_table[mb_index]=0;
1741             }
1742         }
1743     }
1744 }
1745
1746 static inline int hpel_motion_lowres(MpegEncContext *s,
1747                                   uint8_t *dest, uint8_t *src,
1748                                   int field_based, int field_select,
1749                                   int src_x, int src_y,
1750                                   int width, int height, int stride,
1751                                   int h_edge_pos, int v_edge_pos,
1752                                   int w, int h, h264_chroma_mc_func *pix_op,
1753                                   int motion_x, int motion_y)
1754 {
1755     const int lowres= s->avctx->lowres;
1756     const int op_index= FFMIN(lowres, 2);
1757     const int s_mask= (2<<lowres)-1;
1758     int emu=0;
1759     int sx, sy;
1760
1761     if(s->quarter_sample){
1762         motion_x/=2;
1763         motion_y/=2;
1764     }
1765
1766     sx= motion_x & s_mask;
1767     sy= motion_y & s_mask;
1768     src_x += motion_x >> (lowres+1);
1769     src_y += motion_y >> (lowres+1);
1770
1771     src += src_y * stride + src_x;
1772
1773     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1774        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1775         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1776                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1777         src= s->edge_emu_buffer;
1778         emu=1;
1779     }
1780
1781     sx= (sx << 2) >> lowres;
1782     sy= (sy << 2) >> lowres;
1783     if(field_select)
1784         src += s->linesize;
1785     pix_op[op_index](dest, src, stride, h, sx, sy);
1786     return emu;
1787 }
1788
1789 /* apply one mpeg motion vector to the three components */
1790 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1791                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1792                                int field_based, int bottom_field, int field_select,
1793                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1794                                int motion_x, int motion_y, int h, int mb_y)
1795 {
1796     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1797     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1798     const int lowres= s->avctx->lowres;
1799     const int op_index= FFMIN(lowres, 2);
1800     const int block_s= 8>>lowres;
1801     const int s_mask= (2<<lowres)-1;
1802     const int h_edge_pos = s->h_edge_pos >> lowres;
1803     const int v_edge_pos = s->v_edge_pos >> lowres;
1804     linesize   = s->current_picture.f.linesize[0] << field_based;
1805     uvlinesize = s->current_picture.f.linesize[1] << field_based;
1806
1807     if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1808         motion_x/=2;
1809         motion_y/=2;
1810     }
1811
1812     if(field_based){
1813         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1814     }
1815
1816     sx= motion_x & s_mask;
1817     sy= motion_y & s_mask;
1818     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1819     src_y =(   mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1820
1821     if (s->out_format == FMT_H263) {
1822         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1823         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1824         uvsrc_x = src_x>>1;
1825         uvsrc_y = src_y>>1;
1826     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1827         mx = motion_x / 4;
1828         my = motion_y / 4;
1829         uvsx = (2*mx) & s_mask;
1830         uvsy = (2*my) & s_mask;
1831         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1832         uvsrc_y =    mb_y*block_s               + (my >> lowres);
1833     } else {
1834         mx = motion_x / 2;
1835         my = motion_y / 2;
1836         uvsx = mx & s_mask;
1837         uvsy = my & s_mask;
1838         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1839         uvsrc_y =(   mb_y*block_s>>field_based) + (my >> (lowres+1));
1840     }
1841
1842     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1843     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1844     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1845
1846     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1847        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1848             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1849                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1850             ptr_y = s->edge_emu_buffer;
1851             if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1852                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1853                 s->dsp.emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1854                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1855                 s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1856                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1857                 ptr_cb= uvbuf;
1858                 ptr_cr= uvbuf+16;
1859             }
1860     }
1861
1862     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1863         dest_y += s->linesize;
1864         dest_cb+= s->uvlinesize;
1865         dest_cr+= s->uvlinesize;
1866     }
1867
1868     if(field_select){
1869         ptr_y += s->linesize;
1870         ptr_cb+= s->uvlinesize;
1871         ptr_cr+= s->uvlinesize;
1872     }
1873
1874     sx= (sx << 2) >> lowres;
1875     sy= (sy << 2) >> lowres;
1876     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1877
1878     if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1879         uvsx= (uvsx << 2) >> lowres;
1880         uvsy= (uvsy << 2) >> lowres;
1881         pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1882         pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1883     }
1884     //FIXME h261 lowres loop filter
1885 }
1886
1887 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1888                                      uint8_t *dest_cb, uint8_t *dest_cr,
1889                                      uint8_t **ref_picture,
1890                                      h264_chroma_mc_func *pix_op,
1891                                      int mx, int my){
1892     const int lowres= s->avctx->lowres;
1893     const int op_index= FFMIN(lowres, 2);
1894     const int block_s= 8>>lowres;
1895     const int s_mask= (2<<lowres)-1;
1896     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1897     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1898     int emu=0, src_x, src_y, offset, sx, sy;
1899     uint8_t *ptr;
1900
1901     if(s->quarter_sample){
1902         mx/=2;
1903         my/=2;
1904     }
1905
1906     /* In case of 8X8, we construct a single chroma motion vector
1907        with a special rounding */
1908     mx= ff_h263_round_chroma(mx);
1909     my= ff_h263_round_chroma(my);
1910
1911     sx= mx & s_mask;
1912     sy= my & s_mask;
1913     src_x = s->mb_x*block_s + (mx >> (lowres+1));
1914     src_y = s->mb_y*block_s + (my >> (lowres+1));
1915
1916     offset = src_y * s->uvlinesize + src_x;
1917     ptr = ref_picture[1] + offset;
1918     if(s->flags&CODEC_FLAG_EMU_EDGE){
1919         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1920            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1921             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1922             ptr= s->edge_emu_buffer;
1923             emu=1;
1924         }
1925     }
1926     sx= (sx << 2) >> lowres;
1927     sy= (sy << 2) >> lowres;
1928     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1929
1930     ptr = ref_picture[2] + offset;
1931     if(emu){
1932         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1933         ptr= s->edge_emu_buffer;
1934     }
1935     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1936 }
1937
1938 /**
1939  * motion compensation of a single macroblock
1940  * @param s context
1941  * @param dest_y luma destination pointer
1942  * @param dest_cb chroma cb/u destination pointer
1943  * @param dest_cr chroma cr/v destination pointer
1944  * @param dir direction (0->forward, 1->backward)
1945  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1946  * @param pix_op halfpel motion compensation function (average or put normally)
1947  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1948  */
1949 static inline void MPV_motion_lowres(MpegEncContext *s,
1950                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1951                               int dir, uint8_t **ref_picture,
1952                               h264_chroma_mc_func *pix_op)
1953 {
1954     int mx, my;
1955     int mb_x, mb_y, i;
1956     const int lowres= s->avctx->lowres;
1957     const int block_s= 8>>lowres;
1958
1959     mb_x = s->mb_x;
1960     mb_y = s->mb_y;
1961
1962     switch(s->mv_type) {
1963     case MV_TYPE_16X16:
1964         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1965                     0, 0, 0,
1966                     ref_picture, pix_op,
1967                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1968         break;
1969     case MV_TYPE_8X8:
1970         mx = 0;
1971         my = 0;
1972             for(i=0;i<4;i++) {
1973                 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1974                             ref_picture[0], 0, 0,
1975                             (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1976                             s->width, s->height, s->linesize,
1977                             s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1978                             block_s, block_s, pix_op,
1979                             s->mv[dir][i][0], s->mv[dir][i][1]);
1980
1981                 mx += s->mv[dir][i][0];
1982                 my += s->mv[dir][i][1];
1983             }
1984
1985         if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1986             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1987         break;
1988     case MV_TYPE_FIELD:
1989         if (s->picture_structure == PICT_FRAME) {
1990             /* top field */
1991             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1992                         1, 0, s->field_select[dir][0],
1993                         ref_picture, pix_op,
1994                         s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1995             /* bottom field */
1996             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1997                         1, 1, s->field_select[dir][1],
1998                         ref_picture, pix_op,
1999                         s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
2000         } else {
2001             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){
2002                 ref_picture = s->current_picture_ptr->f.data;
2003             }
2004
2005             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2006                         0, 0, s->field_select[dir][0],
2007                         ref_picture, pix_op,
2008                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
2009         }
2010         break;
2011     case MV_TYPE_16X8:
2012         for(i=0; i<2; i++){
2013             uint8_t ** ref2picture;
2014
2015             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
2016                 ref2picture= ref_picture;
2017             }else{
2018                 ref2picture = s->current_picture_ptr->f.data;
2019             }
2020
2021             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2022                         0, 0, s->field_select[dir][i],
2023                         ref2picture, pix_op,
2024                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
2025
2026             dest_y += 2*block_s*s->linesize;
2027             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
2028             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
2029         }
2030         break;
2031     case MV_TYPE_DMV:
2032         if(s->picture_structure == PICT_FRAME){
2033             for(i=0; i<2; i++){
2034                 int j;
2035                 for(j=0; j<2; j++){
2036                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2037                                 1, j, j^i,
2038                                 ref_picture, pix_op,
2039                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
2040                 }
2041                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2042             }
2043         }else{
2044             for(i=0; i<2; i++){
2045                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2046                             0, 0, s->picture_structure != i+1,
2047                             ref_picture, pix_op,
2048                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
2049
2050                 // after put we make avg of the same block
2051                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2052
2053                 //opposite parity is always in the same frame if this is second field
2054                 if(!s->first_field){
2055                     ref_picture = s->current_picture_ptr->f.data;
2056                 }
2057             }
2058         }
2059     break;
2060     default: assert(0);
2061     }
2062 }
2063
2064 /**
2065  * find the lowest MB row referenced in the MVs
2066  */
2067 int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2068 {
2069     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2070     int my, off, i, mvs;
2071
2072     if (s->picture_structure != PICT_FRAME) goto unhandled;
2073
2074     switch (s->mv_type) {
2075         case MV_TYPE_16X16:
2076             mvs = 1;
2077             break;
2078         case MV_TYPE_16X8:
2079             mvs = 2;
2080             break;
2081         case MV_TYPE_8X8:
2082             mvs = 4;
2083             break;
2084         default:
2085             goto unhandled;
2086     }
2087
2088     for (i = 0; i < mvs; i++) {
2089         my = s->mv[dir][i][1]<<qpel_shift;
2090         my_max = FFMAX(my_max, my);
2091         my_min = FFMIN(my_min, my);
2092     }
2093
2094     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2095
2096     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2097 unhandled:
2098     return s->mb_height-1;
2099 }
2100
2101 /* put block[] to dest[] */
2102 static inline void put_dct(MpegEncContext *s,
2103                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2104 {
2105     s->dct_unquantize_intra(s, block, i, qscale);
2106     s->dsp.idct_put (dest, line_size, block);
2107 }
2108
2109 /* add block[] to dest[] */
2110 static inline void add_dct(MpegEncContext *s,
2111                            DCTELEM *block, int i, uint8_t *dest, int line_size)
2112 {
2113     if (s->block_last_index[i] >= 0) {
2114         s->dsp.idct_add (dest, line_size, block);
2115     }
2116 }
2117
2118 static inline void add_dequant_dct(MpegEncContext *s,
2119                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2120 {
2121     if (s->block_last_index[i] >= 0) {
2122         s->dct_unquantize_inter(s, block, i, qscale);
2123
2124         s->dsp.idct_add (dest, line_size, block);
2125     }
2126 }
2127
2128 /**
2129  * cleans dc, ac, coded_block for the current non intra MB
2130  */
2131 void ff_clean_intra_table_entries(MpegEncContext *s)
2132 {
2133     int wrap = s->b8_stride;
2134     int xy = s->block_index[0];
2135
2136     s->dc_val[0][xy           ] =
2137     s->dc_val[0][xy + 1       ] =
2138     s->dc_val[0][xy     + wrap] =
2139     s->dc_val[0][xy + 1 + wrap] = 1024;
2140     /* ac pred */
2141     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2142     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2143     if (s->msmpeg4_version>=3) {
2144         s->coded_block[xy           ] =
2145         s->coded_block[xy + 1       ] =
2146         s->coded_block[xy     + wrap] =
2147         s->coded_block[xy + 1 + wrap] = 0;
2148     }
2149     /* chroma */
2150     wrap = s->mb_stride;
2151     xy = s->mb_x + s->mb_y * wrap;
2152     s->dc_val[1][xy] =
2153     s->dc_val[2][xy] = 1024;
2154     /* ac pred */
2155     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2156     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2157
2158     s->mbintra_table[xy]= 0;
2159 }
2160
2161 /* generic function called after a macroblock has been parsed by the
2162    decoder or after it has been encoded by the encoder.
2163
2164    Important variables used:
2165    s->mb_intra : true if intra macroblock
2166    s->mv_dir   : motion vector direction
2167    s->mv_type  : motion vector type
2168    s->mv       : motion vector
2169    s->interlaced_dct : true if interlaced dct used (mpeg2)
2170  */
2171 static av_always_inline
2172 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2173                             int lowres_flag, int is_mpeg12)
2174 {
2175     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2176     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2177         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2178         return;
2179     }
2180
2181     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2182        /* save DCT coefficients */
2183        int i,j;
2184        DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2185        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2186        for(i=0; i<6; i++){
2187            for(j=0; j<64; j++){
2188                *dct++ = block[i][s->dsp.idct_permutation[j]];
2189                av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2190            }
2191            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2192        }
2193     }
2194
2195     s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2196
2197     /* update DC predictors for P macroblocks */
2198     if (!s->mb_intra) {
2199         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2200             if(s->mbintra_table[mb_xy])
2201                 ff_clean_intra_table_entries(s);
2202         } else {
2203             s->last_dc[0] =
2204             s->last_dc[1] =
2205             s->last_dc[2] = 128 << s->intra_dc_precision;
2206         }
2207     }
2208     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2209         s->mbintra_table[mb_xy]=1;
2210
2211     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2212         uint8_t *dest_y, *dest_cb, *dest_cr;
2213         int dct_linesize, dct_offset;
2214         op_pixels_func (*op_pix)[4];
2215         qpel_mc_func (*op_qpix)[16];
2216         const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2217         const int uvlinesize = s->current_picture.f.linesize[1];
2218         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2219         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2220
2221         /* avoid copy if macroblock skipped in last frame too */
2222         /* skip only during decoding as we might trash the buffers during encoding a bit */
2223         if(!s->encoding){
2224             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2225             const int age = s->current_picture.f.age;
2226
2227             assert(age);
2228
2229             if (s->mb_skipped) {
2230                 s->mb_skipped= 0;
2231                 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2232
2233                 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2234                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2235
2236                 /* if previous was skipped too, then nothing to do !  */
2237                 if (*mbskip_ptr >= age && s->current_picture.f.reference){
2238                     return;
2239                 }
2240             } else if(!s->current_picture.f.reference) {
2241                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2242                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2243             } else{
2244                 *mbskip_ptr = 0; /* not skipped */
2245             }
2246         }
2247
2248         dct_linesize = linesize << s->interlaced_dct;
2249         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2250
2251         if(readable){
2252             dest_y=  s->dest[0];
2253             dest_cb= s->dest[1];
2254             dest_cr= s->dest[2];
2255         }else{
2256             dest_y = s->b_scratchpad;
2257             dest_cb= s->b_scratchpad+16*linesize;
2258             dest_cr= s->b_scratchpad+32*linesize;
2259         }
2260
2261         if (!s->mb_intra) {
2262             /* motion handling */
2263             /* decoding or more than one mb_type (MC was already done otherwise) */
2264             if(!s->encoding){
2265
2266                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2267                     if (s->mv_dir & MV_DIR_FORWARD) {
2268                         ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2269                     }
2270                     if (s->mv_dir & MV_DIR_BACKWARD) {
2271                         ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2272                     }
2273                 }
2274
2275                 if(lowres_flag){
2276                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2277
2278                     if (s->mv_dir & MV_DIR_FORWARD) {
2279                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2280                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2281                     }
2282                     if (s->mv_dir & MV_DIR_BACKWARD) {
2283                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2284                     }
2285                 }else{
2286                     op_qpix= s->me.qpel_put;
2287                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2288                         op_pix = s->dsp.put_pixels_tab;
2289                     }else{
2290                         op_pix = s->dsp.put_no_rnd_pixels_tab;
2291                     }
2292                     if (s->mv_dir & MV_DIR_FORWARD) {
2293                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2294                         op_pix = s->dsp.avg_pixels_tab;
2295                         op_qpix= s->me.qpel_avg;
2296                     }
2297                     if (s->mv_dir & MV_DIR_BACKWARD) {
2298                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2299                     }
2300                 }
2301             }
2302
2303             /* skip dequant / idct if we are really late ;) */
2304             if(s->avctx->skip_idct){
2305                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2306                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2307                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2308                     goto skip_idct;
2309             }
2310
2311             /* add dct residue */
2312             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2313                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2314                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2315                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2316                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2317                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2318
2319                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2320                     if (s->chroma_y_shift){
2321                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2322                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2323                     }else{
2324                         dct_linesize >>= 1;
2325                         dct_offset >>=1;
2326                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2327                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2328                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2329                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2330                     }
2331                 }
2332             } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2333                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2334                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2335                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2336                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2337
2338                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2339                     if(s->chroma_y_shift){//Chroma420
2340                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2341                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2342                     }else{
2343                         //chroma422
2344                         dct_linesize = uvlinesize << s->interlaced_dct;
2345                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2346
2347                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2348                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2349                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2350                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2351                         if(!s->chroma_x_shift){//Chroma444
2352                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2353                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2354                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2355                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2356                         }
2357                     }
2358                 }//fi gray
2359             }
2360             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2361                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2362             }
2363         } else {
2364             /* dct only in intra block */
2365             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2366                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2367                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2368                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2369                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2370
2371                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2372                     if(s->chroma_y_shift){
2373                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2374                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2375                     }else{
2376                         dct_offset >>=1;
2377                         dct_linesize >>=1;
2378                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2379                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2380                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2381                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2382                     }
2383                 }
2384             }else{
2385                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2386                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2387                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2388                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2389
2390                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2391                     if(s->chroma_y_shift){
2392                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2393                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2394                     }else{
2395
2396                         dct_linesize = uvlinesize << s->interlaced_dct;
2397                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2398
2399                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2400                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2401                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2402                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2403                         if(!s->chroma_x_shift){//Chroma444
2404                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2405                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2406                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2407                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2408                         }
2409                     }
2410                 }//gray
2411             }
2412         }
2413 skip_idct:
2414         if(!readable){
2415             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2416             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2417             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2418         }
2419     }
2420 }
2421
2422 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2423 #if !CONFIG_SMALL
2424     if(s->out_format == FMT_MPEG1) {
2425         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2426         else                 MPV_decode_mb_internal(s, block, 0, 1);
2427     } else
2428 #endif
2429     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2430     else                  MPV_decode_mb_internal(s, block, 0, 0);
2431 }
2432
2433 /**
2434  *
2435  * @param h is the normal height, this will be reduced automatically if needed for the last row
2436  */
2437 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2438     const int field_pic= s->picture_structure != PICT_FRAME;
2439     if(field_pic){
2440         h <<= 1;
2441         y <<= 1;
2442     }
2443
2444     if (!s->avctx->hwaccel
2445        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2446        && s->unrestricted_mv
2447        && s->current_picture.f.reference
2448        && !s->intra_only
2449        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2450         int sides = 0, edge_h;
2451         int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2452         int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2453         if (y==0) sides |= EDGE_TOP;
2454         if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2455
2456         edge_h= FFMIN(h, s->v_edge_pos - y);
2457
2458         s->dsp.draw_edges(s->current_picture_ptr->f.data[0] +  y         *s->linesize,
2459                           s->linesize,           s->h_edge_pos,         edge_h,
2460                           EDGE_WIDTH,            EDGE_WIDTH,            sides);
2461         s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2462                           s->uvlinesize,         s->h_edge_pos>>hshift, edge_h>>vshift,
2463                           EDGE_WIDTH>>hshift,    EDGE_WIDTH>>vshift,    sides);
2464         s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2465                           s->uvlinesize,         s->h_edge_pos>>hshift, edge_h>>vshift,
2466                           EDGE_WIDTH>>hshift,    EDGE_WIDTH>>vshift,    sides);
2467     }
2468
2469     h= FFMIN(h, s->avctx->height - y);
2470
2471     if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2472
2473     if (s->avctx->draw_horiz_band) {
2474         AVFrame *src;
2475         int offset[AV_NUM_DATA_POINTERS];
2476         int i;
2477
2478         if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2479             src= (AVFrame*)s->current_picture_ptr;
2480         else if(s->last_picture_ptr)
2481             src= (AVFrame*)s->last_picture_ptr;
2482         else
2483             return;
2484
2485         if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2486             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2487                 offset[i] = 0;
2488         }else{
2489             offset[0]= y * s->linesize;
2490             offset[1]=
2491             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2492             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2493                 offset[i] = 0;
2494         }
2495
2496         emms_c();
2497
2498         s->avctx->draw_horiz_band(s->avctx, src, offset,
2499                                   y, s->picture_structure, h);
2500     }
2501 }
2502
2503 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2504     const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2505     const int uvlinesize = s->current_picture.f.linesize[1];
2506     const int mb_size= 4 - s->avctx->lowres;
2507
2508     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2509     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2510     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2511     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2512     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2513     s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2514     //block_index is not used by mpeg2, so it is not affected by chroma_format
2515
2516     s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) <<  mb_size);
2517     s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2518     s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2519
2520     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2521     {
2522         if(s->picture_structure==PICT_FRAME){
2523         s->dest[0] += s->mb_y *   linesize << mb_size;
2524         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2525         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2526         }else{
2527             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2528             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2529             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2530             assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2531         }
2532     }
2533 }
2534
2535 void ff_mpeg_flush(AVCodecContext *avctx){
2536     int i;
2537     MpegEncContext *s = avctx->priv_data;
2538
2539     if(s==NULL || s->picture==NULL)
2540         return;
2541
2542     for(i=0; i<s->picture_count; i++){
2543        if (s->picture[i].f.data[0] &&
2544            (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2545             s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2546         free_frame_buffer(s, &s->picture[i]);
2547     }
2548     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2549
2550     s->mb_x= s->mb_y= 0;
2551
2552     s->parse_context.state= -1;
2553     s->parse_context.frame_start_found= 0;
2554     s->parse_context.overread= 0;
2555     s->parse_context.overread_index= 0;
2556     s->parse_context.index= 0;
2557     s->parse_context.last_index= 0;
2558     s->bitstream_buffer_size=0;
2559     s->pp_time=0;
2560 }
2561
2562 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2563                                    DCTELEM *block, int n, int qscale)
2564 {
2565     int i, level, nCoeffs;
2566     const uint16_t *quant_matrix;
2567
2568     nCoeffs= s->block_last_index[n];
2569
2570     if (n < 4)
2571         block[0] = block[0] * s->y_dc_scale;
2572     else
2573         block[0] = block[0] * s->c_dc_scale;
2574     /* XXX: only mpeg1 */
2575     quant_matrix = s->intra_matrix;
2576     for(i=1;i<=nCoeffs;i++) {
2577         int j= s->intra_scantable.permutated[i];
2578         level = block[j];
2579         if (level) {
2580             if (level < 0) {
2581                 level = -level;
2582                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2583                 level = (level - 1) | 1;
2584                 level = -level;
2585             } else {
2586                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2587                 level = (level - 1) | 1;
2588             }
2589             block[j] = level;
2590         }
2591     }
2592 }
2593
2594 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2595                                    DCTELEM *block, int n, int qscale)
2596 {
2597     int i, level, nCoeffs;
2598     const uint16_t *quant_matrix;
2599
2600     nCoeffs= s->block_last_index[n];
2601
2602     quant_matrix = s->inter_matrix;
2603     for(i=0; i<=nCoeffs; i++) {
2604         int j= s->intra_scantable.permutated[i];
2605         level = block[j];
2606         if (level) {
2607             if (level < 0) {
2608                 level = -level;
2609                 level = (((level << 1) + 1) * qscale *
2610                          ((int) (quant_matrix[j]))) >> 4;
2611                 level = (level - 1) | 1;
2612                 level = -level;
2613             } else {
2614                 level = (((level << 1) + 1) * qscale *
2615                          ((int) (quant_matrix[j]))) >> 4;
2616                 level = (level - 1) | 1;
2617             }
2618             block[j] = level;
2619         }
2620     }
2621 }
2622
2623 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2624                                    DCTELEM *block, int n, int qscale)
2625 {
2626     int i, level, nCoeffs;
2627     const uint16_t *quant_matrix;
2628
2629     if(s->alternate_scan) nCoeffs= 63;
2630     else nCoeffs= s->block_last_index[n];
2631
2632     if (n < 4)
2633         block[0] = block[0] * s->y_dc_scale;
2634     else
2635         block[0] = block[0] * s->c_dc_scale;
2636     quant_matrix = s->intra_matrix;
2637     for(i=1;i<=nCoeffs;i++) {
2638         int j= s->intra_scantable.permutated[i];
2639         level = block[j];
2640         if (level) {
2641             if (level < 0) {
2642                 level = -level;
2643                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2644                 level = -level;
2645             } else {
2646                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2647             }
2648             block[j] = level;
2649         }
2650     }
2651 }
2652
2653 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2654                                    DCTELEM *block, int n, int qscale)
2655 {
2656     int i, level, nCoeffs;
2657     const uint16_t *quant_matrix;
2658     int sum=-1;
2659
2660     if(s->alternate_scan) nCoeffs= 63;
2661     else nCoeffs= s->block_last_index[n];
2662
2663     if (n < 4)
2664         block[0] = block[0] * s->y_dc_scale;
2665     else
2666         block[0] = block[0] * s->c_dc_scale;
2667     quant_matrix = s->intra_matrix;
2668     for(i=1;i<=nCoeffs;i++) {
2669         int j= s->intra_scantable.permutated[i];
2670         level = block[j];
2671         if (level) {
2672             if (level < 0) {
2673                 level = -level;
2674                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2675                 level = -level;
2676             } else {
2677                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2678             }
2679             block[j] = level;
2680             sum+=level;
2681         }
2682     }
2683     block[63]^=sum&1;
2684 }
2685
2686 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2687                                    DCTELEM *block, int n, int qscale)
2688 {
2689     int i, level, nCoeffs;
2690     const uint16_t *quant_matrix;
2691     int sum=-1;
2692
2693     if(s->alternate_scan) nCoeffs= 63;
2694     else nCoeffs= s->block_last_index[n];
2695
2696     quant_matrix = s->inter_matrix;
2697     for(i=0; i<=nCoeffs; i++) {
2698         int j= s->intra_scantable.permutated[i];
2699         level = block[j];
2700         if (level) {
2701             if (level < 0) {
2702                 level = -level;
2703                 level = (((level << 1) + 1) * qscale *
2704                          ((int) (quant_matrix[j]))) >> 4;
2705                 level = -level;
2706             } else {
2707                 level = (((level << 1) + 1) * qscale *
2708                          ((int) (quant_matrix[j]))) >> 4;
2709             }
2710             block[j] = level;
2711             sum+=level;
2712         }
2713     }
2714     block[63]^=sum&1;
2715 }
2716
2717 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2718                                   DCTELEM *block, int n, int qscale)
2719 {
2720     int i, level, qmul, qadd;
2721     int nCoeffs;
2722
2723     assert(s->block_last_index[n]>=0);
2724
2725     qmul = qscale << 1;
2726
2727     if (!s->h263_aic) {
2728         if (n < 4)
2729             block[0] = block[0] * s->y_dc_scale;
2730         else
2731             block[0] = block[0] * s->c_dc_scale;
2732         qadd = (qscale - 1) | 1;
2733     }else{
2734         qadd = 0;
2735     }
2736     if(s->ac_pred)
2737         nCoeffs=63;
2738     else
2739         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2740
2741     for(i=1; i<=nCoeffs; i++) {
2742         level = block[i];
2743         if (level) {
2744             if (level < 0) {
2745                 level = level * qmul - qadd;
2746             } else {
2747                 level = level * qmul + qadd;
2748             }
2749             block[i] = level;
2750         }
2751     }
2752 }
2753
2754 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2755                                   DCTELEM *block, int n, int qscale)
2756 {
2757     int i, level, qmul, qadd;
2758     int nCoeffs;
2759
2760     assert(s->block_last_index[n]>=0);
2761
2762     qadd = (qscale - 1) | 1;
2763     qmul = qscale << 1;
2764
2765     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2766
2767     for(i=0; i<=nCoeffs; i++) {
2768         level = block[i];
2769         if (level) {
2770             if (level < 0) {
2771                 level = level * qmul - qadd;
2772             } else {
2773                 level = level * qmul + qadd;
2774             }
2775             block[i] = level;
2776         }
2777     }
2778 }
2779
2780 /**
2781  * set qscale and update qscale dependent variables.
2782  */
2783 void ff_set_qscale(MpegEncContext * s, int qscale)
2784 {
2785     if (qscale < 1)
2786         qscale = 1;
2787     else if (qscale > 31)
2788         qscale = 31;
2789
2790     s->qscale = qscale;
2791     s->chroma_qscale= s->chroma_qscale_table[qscale];
2792
2793     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2794     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2795 }
2796
2797 void MPV_report_decode_progress(MpegEncContext *s)
2798 {
2799     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2800         ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
2801 }