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