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