10l (dont modify the input picture pts)
[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  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
21  */
22  
23 /**
24  * @file mpegvideo.c
25  * The simplest mpeg encoder (well, it was the simplest!).
26  */ 
27  
28 #include "avcodec.h"
29 #include "dsputil.h"
30 #include "mpegvideo.h"
31 #include "faandct.h"
32 #include <limits.h>
33
34 #ifdef USE_FASTMEMCPY
35 #include "fastmemcpy.h"
36 #endif
37
38 //#undef NDEBUG
39 //#include <assert.h>
40
41 #ifdef CONFIG_ENCODERS
42 static void encode_picture(MpegEncContext *s, int picture_number);
43 #endif //CONFIG_ENCODERS
44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, 
45                                    DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, 
47                                    DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49                                    DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51                                    DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_h263_intra_c(MpegEncContext *s, 
53                                   DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_h263_inter_c(MpegEncContext *s, 
55                                   DCTELEM *block, int n, int qscale);
56 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57 #ifdef CONFIG_ENCODERS
58 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
60 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
61 static int sse_mb(MpegEncContext *s);
62 static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block);
63 #endif //CONFIG_ENCODERS
64
65 #ifdef HAVE_XVMC
66 extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
67 extern void XVMC_field_end(MpegEncContext *s);
68 extern void XVMC_decode_mb(MpegEncContext *s);
69 #endif
70
71 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
72
73
74 /* enable all paranoid tests for rounding, overflows, etc... */
75 //#define PARANOID
76
77 //#define DEBUG
78
79
80 /* for jpeg fast DCT */
81 #define CONST_BITS 14
82
83 static const uint16_t aanscales[64] = {
84     /* precomputed values scaled up by 14 bits */
85     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
86     22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
87     21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
88     19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
89     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
90     12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
91     8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
92     4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
93 };
94
95 static const uint8_t h263_chroma_roundtab[16] = {
96 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
97     0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
98 };
99
100 static const uint8_t ff_default_chroma_qscale_table[32]={
101 //  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
102     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
103 };
104
105 #ifdef CONFIG_ENCODERS
106 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
107 static uint8_t default_fcode_tab[MAX_MV*2+1];
108
109 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
110
111 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
112                            const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
113 {
114     int qscale;
115     int shift=0;
116
117     for(qscale=qmin; qscale<=qmax; qscale++){
118         int i;
119         if (dsp->fdct == ff_jpeg_fdct_islow 
120 #ifdef FAAN_POSTSCALE
121             || dsp->fdct == ff_faandct
122 #endif
123             ) {
124             for(i=0;i<64;i++) {
125                 const int j= dsp->idct_permutation[i];
126                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
127                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
128                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
129                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
130                 
131                 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / 
132                                 (qscale * quant_matrix[j]));
133             }
134         } else if (dsp->fdct == fdct_ifast
135 #ifndef FAAN_POSTSCALE
136                    || dsp->fdct == ff_faandct
137 #endif
138                    ) {
139             for(i=0;i<64;i++) {
140                 const int j= dsp->idct_permutation[i];
141                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
142                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
143                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
144                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
145                 
146                 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) / 
147                                 (aanscales[i] * qscale * quant_matrix[j]));
148             }
149         } else {
150             for(i=0;i<64;i++) {
151                 const int j= dsp->idct_permutation[i];
152                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
153                    So 16           <= qscale * quant_matrix[i]             <= 7905
154                    so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
155                    so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
156                 */
157                 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
158 //                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
159                 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
160
161                 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
162                 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
163             }
164         }
165         
166         for(i=intra; i<64; i++){
167             int64_t max= 8191;
168             if (dsp->fdct == fdct_ifast
169 #ifndef FAAN_POSTSCALE
170                    || dsp->fdct == ff_faandct
171 #endif
172                    ) {
173                 max= (8191LL*aanscales[i]) >> 14;
174             }
175             while(((max * qmat[qscale][i]) >> shift) > INT_MAX){ 
176                 shift++;
177             }
178         }
179     }
180     if(shift){
181         av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
182     }
183 }
184
185 static inline void update_qscale(MpegEncContext *s){
186     s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
187     s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
188     
189     s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
190 }
191 #endif //CONFIG_ENCODERS
192
193 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
194     int i;
195     int end;
196     
197     st->scantable= src_scantable;
198
199     for(i=0; i<64; i++){
200         int j;
201         j = src_scantable[i];
202         st->permutated[i] = permutation[j];
203 #ifdef ARCH_POWERPC
204         st->inverse[j] = i;
205 #endif
206     }
207     
208     end=-1;
209     for(i=0; i<64; i++){
210         int j;
211         j = st->permutated[i];
212         if(j>end) end=j;
213         st->raster_end[i]= end;
214     }
215 }
216
217 #ifdef CONFIG_ENCODERS
218 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
219     int i;
220
221     if(matrix){
222         put_bits(pb, 1, 1);
223         for(i=0;i<64;i++) {
224             put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
225         }
226     }else
227         put_bits(pb, 1, 0);
228 }
229 #endif //CONFIG_ENCODERS
230
231 /* init common dct for both encoder and decoder */
232 int DCT_common_init(MpegEncContext *s)
233 {
234     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
235     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
236     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
237     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
238     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
239     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
240
241 #ifdef CONFIG_ENCODERS
242     s->dct_quantize= dct_quantize_c;
243     s->denoise_dct= denoise_dct_c;
244 #endif
245         
246 #ifdef HAVE_MMX
247     MPV_common_init_mmx(s);
248 #endif
249 #ifdef ARCH_ALPHA
250     MPV_common_init_axp(s);
251 #endif
252 #ifdef HAVE_MLIB
253     MPV_common_init_mlib(s);
254 #endif
255 #ifdef HAVE_MMI
256     MPV_common_init_mmi(s);
257 #endif
258 #ifdef ARCH_ARMV4L
259     MPV_common_init_armv4l(s);
260 #endif
261 #ifdef ARCH_POWERPC
262     MPV_common_init_ppc(s);
263 #endif
264
265 #ifdef CONFIG_ENCODERS
266     s->fast_dct_quantize= s->dct_quantize;
267
268     if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
269         s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
270     }
271
272 #endif //CONFIG_ENCODERS
273
274     /* load & permutate scantables
275        note: only wmv uses differnt ones 
276     */
277     if(s->alternate_scan){
278         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
279         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
280     }else{
281         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
282         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
283     }
284     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
285     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
286
287     return 0;
288 }
289
290 static void copy_picture(Picture *dst, Picture *src){
291     *dst = *src;
292     dst->type= FF_BUFFER_TYPE_COPY;
293 }
294
295 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
296     int i;
297
298     dst->pict_type              = src->pict_type;
299     dst->quality                = src->quality;
300     dst->coded_picture_number   = src->coded_picture_number;
301     dst->display_picture_number = src->display_picture_number;
302 //    dst->reference              = src->reference;
303     dst->pts                    = src->pts;
304     dst->interlaced_frame       = src->interlaced_frame;
305     dst->top_field_first        = src->top_field_first;
306
307     if(s->avctx->me_threshold){
308         if(!src->motion_val[0])
309             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
310         if(!src->mb_type)
311             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
312         if(!src->ref_index[0])
313             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
314         if(src->motion_subsample_log2 != dst->motion_subsample_log2)
315             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesnt match! (%d!=%d)\n",
316             src->motion_subsample_log2, dst->motion_subsample_log2);
317
318         memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
319         
320         for(i=0; i<2; i++){
321             int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
322             int height= ((16*s->mb_height)>>src->motion_subsample_log2);
323
324             if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
325                 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
326             }
327             if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
328                 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
329             }
330         }
331     }
332 }
333
334 /**
335  * allocates a Picture
336  * The pixels are allocated/set by calling get_buffer() if shared=0
337  */
338 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
339     const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
340     const int mb_array_size= s->mb_stride*s->mb_height;
341     const int b8_array_size= s->b8_stride*s->mb_height*2;
342     const int b4_array_size= s->b4_stride*s->mb_height*4;
343     int i;
344     
345     if(shared){
346         assert(pic->data[0]);
347         assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
348         pic->type= FF_BUFFER_TYPE_SHARED;
349     }else{
350         int r;
351         
352         assert(!pic->data[0]);
353         
354         r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
355         
356         if(r<0 || !pic->age || !pic->type || !pic->data[0]){
357             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
358             return -1;
359         }
360
361         if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
362             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
363             return -1;
364         }
365
366         if(pic->linesize[1] != pic->linesize[2]){
367             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
368             return -1;
369         }
370
371         s->linesize  = pic->linesize[0];
372         s->uvlinesize= pic->linesize[1];
373     }
374     
375     if(pic->qscale_table==NULL){
376         if (s->encoding) {        
377             CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
378             CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
379             CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
380         }
381
382         CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
383         CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
384         CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
385         pic->mb_type= pic->mb_type_base + s->mb_stride+1;
386         if(s->out_format == FMT_H264){
387             for(i=0; i<2; i++){
388                 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+2)  * sizeof(int16_t))
389                 pic->motion_val[i]= pic->motion_val_base[i]+2;
390                 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
391             }
392             pic->motion_subsample_log2= 2;
393         }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
394             for(i=0; i<2; i++){
395                 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+2) * sizeof(int16_t))
396                 pic->motion_val[i]= pic->motion_val_base[i]+2;
397                 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
398             }
399             pic->motion_subsample_log2= 3;
400         }
401         if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
402             CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
403         }
404         pic->qstride= s->mb_stride;
405         CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
406     }
407
408     //it might be nicer if the application would keep track of these but it would require a API change
409     memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
410     s->prev_pict_types[0]= s->pict_type;
411     if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
412         pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
413     
414     return 0;
415 fail: //for the CHECKED_ALLOCZ macro
416     return -1;
417 }
418
419 /**
420  * deallocates a picture
421  */
422 static void free_picture(MpegEncContext *s, Picture *pic){
423     int i;
424
425     if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
426         s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
427     }
428
429     av_freep(&pic->mb_var);
430     av_freep(&pic->mc_mb_var);
431     av_freep(&pic->mb_mean);
432     av_freep(&pic->mbskip_table);
433     av_freep(&pic->qscale_table);
434     av_freep(&pic->mb_type_base);
435     av_freep(&pic->dct_coeff);
436     av_freep(&pic->pan_scan);
437     pic->mb_type= NULL;
438     for(i=0; i<2; i++){
439         av_freep(&pic->motion_val_base[i]);
440         av_freep(&pic->ref_index[i]);
441     }
442     
443     if(pic->type == FF_BUFFER_TYPE_SHARED){
444         for(i=0; i<4; i++){
445             pic->base[i]=
446             pic->data[i]= NULL;
447         }
448         pic->type= 0;        
449     }
450 }
451
452 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
453     int i;
454
455     // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264) 
456     CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
457     s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
458
459      //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
460     CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t)) 
461     s->rd_scratchpad=   s->me.scratchpad;
462     s->b_scratchpad=    s->me.scratchpad;
463     s->obmc_scratchpad= s->me.scratchpad + 16;
464     if (s->encoding) {
465         CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
466         CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
467         if(s->avctx->noise_reduction){
468             CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
469         }
470     }   
471     CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
472     s->block= s->blocks[0];
473
474     for(i=0;i<12;i++){
475         s->pblocks[i] = (short *)(&s->block[i]);
476     }
477     return 0;
478 fail:
479     return -1; //free() through MPV_common_end()
480 }
481
482 static void free_duplicate_context(MpegEncContext *s){
483     if(s==NULL) return;
484
485     av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
486     av_freep(&s->me.scratchpad);
487     s->rd_scratchpad=   
488     s->b_scratchpad=    
489     s->obmc_scratchpad= NULL;
490     
491     av_freep(&s->dct_error_sum);
492     av_freep(&s->me.map);
493     av_freep(&s->me.score_map);
494     av_freep(&s->blocks);
495     s->block= NULL;
496 }
497
498 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
499 #define COPY(a) bak->a= src->a
500     COPY(allocated_edge_emu_buffer);
501     COPY(edge_emu_buffer);
502     COPY(me.scratchpad);
503     COPY(rd_scratchpad);
504     COPY(b_scratchpad);
505     COPY(obmc_scratchpad);
506     COPY(me.map);
507     COPY(me.score_map);
508     COPY(blocks);
509     COPY(block);
510     COPY(start_mb_y);
511     COPY(end_mb_y);
512     COPY(me.map_generation);
513     COPY(pb);
514     COPY(dct_error_sum);
515     COPY(dct_count[0]);
516     COPY(dct_count[1]);
517 #undef COPY
518 }
519
520 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
521     MpegEncContext bak;
522     int i;
523     //FIXME copy only needed parts
524 //START_TIMER
525     backup_duplicate_context(&bak, dst);
526     memcpy(dst, src, sizeof(MpegEncContext));
527     backup_duplicate_context(dst, &bak);
528     for(i=0;i<12;i++){
529         dst->pblocks[i] = (short *)(&dst->block[i]);
530     }
531 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
532 }
533
534 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
535 #define COPY(a) dst->a= src->a
536     COPY(pict_type);
537     COPY(current_picture);
538     COPY(f_code);
539     COPY(b_code);
540     COPY(qscale);
541     COPY(lambda);
542     COPY(lambda2);
543     COPY(picture_in_gop_number);
544     COPY(gop_picture_number);
545     COPY(frame_pred_frame_dct); //FIXME dont set in encode_header
546     COPY(progressive_frame); //FIXME dont set in encode_header
547     COPY(partitioned_frame); //FIXME dont set in encode_header
548 #undef COPY
549 }
550
551 /**
552  * sets the given MpegEncContext to common defaults (same for encoding and decoding).
553  * the changed fields will not depend upon the prior state of the MpegEncContext.
554  */
555 static void MPV_common_defaults(MpegEncContext *s){
556     s->y_dc_scale_table=
557     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
558     s->chroma_qscale_table= ff_default_chroma_qscale_table;
559     s->progressive_frame= 1;
560     s->progressive_sequence= 1;
561     s->picture_structure= PICT_FRAME;
562
563     s->coded_picture_number = 0;
564     s->picture_number = 0;
565     s->input_picture_number = 0;
566
567     s->picture_in_gop_number = 0;
568
569     s->f_code = 1;
570     s->b_code = 1;
571 }
572
573 /**
574  * sets the given MpegEncContext to defaults for decoding.
575  * the changed fields will not depend upon the prior state of the MpegEncContext.
576  */
577 void MPV_decode_defaults(MpegEncContext *s){
578     MPV_common_defaults(s);
579 }
580
581 /**
582  * sets the given MpegEncContext to defaults for encoding.
583  * the changed fields will not depend upon the prior state of the MpegEncContext.
584  */
585
586 #ifdef CONFIG_ENCODERS
587 static void MPV_encode_defaults(MpegEncContext *s){
588     static int done=0;
589     
590     MPV_common_defaults(s);
591     
592     if(!done){
593         int i;
594         done=1;
595
596         default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
597         memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
598
599         for(i=-16; i<16; i++){
600             default_fcode_tab[i + MAX_MV]= 1;
601         }
602     }
603     s->me.mv_penalty= default_mv_penalty;
604     s->fcode_tab= default_fcode_tab;
605 }
606 #endif //CONFIG_ENCODERS
607
608 /** 
609  * init common structure for both encoder and decoder.
610  * this assumes that some variables like width/height are already set
611  */
612 int MPV_common_init(MpegEncContext *s)
613 {
614     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
615
616     if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
617         av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
618         return -1;
619     }
620
621     if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
622         return -1;
623
624     dsputil_init(&s->dsp, s->avctx);
625     DCT_common_init(s);
626
627     s->flags= s->avctx->flags;
628     s->flags2= s->avctx->flags2;
629
630     s->mb_width  = (s->width  + 15) / 16;
631     s->mb_height = (s->height + 15) / 16;
632     s->mb_stride = s->mb_width + 1;
633     s->b8_stride = s->mb_width*2 + 1;
634     s->b4_stride = s->mb_width*4 + 1;
635     mb_array_size= s->mb_height * s->mb_stride;
636     mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
637
638     /* set chroma shifts */
639     avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
640                                                     &(s->chroma_y_shift) );
641
642     /* set default edge pos, will be overriden in decode_header if needed */
643     s->h_edge_pos= s->mb_width*16;
644     s->v_edge_pos= s->mb_height*16;
645
646     s->mb_num = s->mb_width * s->mb_height;
647     
648     s->block_wrap[0]=
649     s->block_wrap[1]=
650     s->block_wrap[2]=
651     s->block_wrap[3]= s->b8_stride;
652     s->block_wrap[4]=
653     s->block_wrap[5]= s->mb_stride;
654  
655     y_size = s->b8_stride * (2 * s->mb_height + 1);
656     c_size = s->mb_stride * (s->mb_height + 1);
657     yc_size = y_size + 2 * c_size;
658     
659     /* convert fourcc to upper case */
660     s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
661                         + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
662                         + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
663                         + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
664
665     s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
666                                + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
667                                + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
668                                + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
669
670     s->avctx->coded_frame= (AVFrame*)&s->current_picture;
671
672     CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
673     for(y=0; y<s->mb_height; y++){
674         for(x=0; x<s->mb_width; x++){
675             s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
676         }
677     }
678     s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
679     
680     if (s->encoding) {
681         /* Allocate MV tables */
682         CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
683         CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
684         CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
685         CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
686         CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
687         CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
688         s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
689         s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
690         s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
691         s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
692         s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
693         s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
694
695         if(s->msmpeg4_version){
696             CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
697         }
698         CHECKED_ALLOCZ(s->avctx->stats_out, 256);
699
700         /* Allocate MB type table */
701         CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
702         
703         CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
704         
705         CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
706         CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
707         CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
708         CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
709         CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
710         CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
711         
712         if(s->avctx->noise_reduction){
713             CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
714         }
715     }
716     CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
717
718     CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
719     
720     if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
721         /* interlaced direct mode decoding tables */
722             for(i=0; i<2; i++){
723                 int j, k;
724                 for(j=0; j<2; j++){
725                     for(k=0; k<2; k++){
726                         CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
727                         s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
728                     }
729                     CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
730                     CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
731                     s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
732                 }
733                 CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
734             }
735     }
736     if (s->out_format == FMT_H263) {
737         /* ac values */
738         CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
739         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
740         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
741         s->ac_val[2] = s->ac_val[1] + c_size;
742         
743         /* cbp values */
744         CHECKED_ALLOCZ(s->coded_block_base, y_size);
745         s->coded_block= s->coded_block_base + s->b8_stride + 1;
746         
747         /* cbp, ac_pred, pred_dir */
748         CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
749         CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
750     }
751     
752     if (s->h263_pred || s->h263_plus || !s->encoding) {
753         /* dc values */
754         //MN: we need these for error resilience of intra-frames
755         CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
756         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
757         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
758         s->dc_val[2] = s->dc_val[1] + c_size;
759         for(i=0;i<yc_size;i++)
760             s->dc_val_base[i] = 1024;
761     }
762
763     /* which mb is a intra block */
764     CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
765     memset(s->mbintra_table, 1, mb_array_size);
766     
767     /* init macroblock skip table */
768     CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
769     //Note the +1 is for a quicker mpeg4 slice_end detection
770     CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
771     
772     s->parse_context.state= -1;
773     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
774        s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
775        s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
776        s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
777     }
778
779     s->context_initialized = 1;
780
781     s->thread_context[0]= s;
782     for(i=1; i<s->avctx->thread_count; i++){
783         s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
784         memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
785     }
786
787     for(i=0; i<s->avctx->thread_count; i++){
788         if(init_duplicate_context(s->thread_context[i], s) < 0)
789            goto fail;
790         s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
791         s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
792     }
793
794     return 0;
795  fail:
796     MPV_common_end(s);
797     return -1;
798 }
799
800 /* init common structure for both encoder and decoder */
801 void MPV_common_end(MpegEncContext *s)
802 {
803     int i, j, k;
804
805     for(i=0; i<s->avctx->thread_count; i++){
806         free_duplicate_context(s->thread_context[i]);
807     }
808     for(i=1; i<s->avctx->thread_count; i++){
809         av_freep(&s->thread_context[i]);
810     }
811
812     av_freep(&s->parse_context.buffer);
813     s->parse_context.buffer_size=0;
814
815     av_freep(&s->mb_type);
816     av_freep(&s->p_mv_table_base);
817     av_freep(&s->b_forw_mv_table_base);
818     av_freep(&s->b_back_mv_table_base);
819     av_freep(&s->b_bidir_forw_mv_table_base);
820     av_freep(&s->b_bidir_back_mv_table_base);
821     av_freep(&s->b_direct_mv_table_base);
822     s->p_mv_table= NULL;
823     s->b_forw_mv_table= NULL;
824     s->b_back_mv_table= NULL;
825     s->b_bidir_forw_mv_table= NULL;
826     s->b_bidir_back_mv_table= NULL;
827     s->b_direct_mv_table= NULL;
828     for(i=0; i<2; i++){
829         for(j=0; j<2; j++){
830             for(k=0; k<2; k++){
831                 av_freep(&s->b_field_mv_table_base[i][j][k]);
832                 s->b_field_mv_table[i][j][k]=NULL;
833             }
834             av_freep(&s->b_field_select_table[i][j]);
835             av_freep(&s->p_field_mv_table_base[i][j]);
836             s->p_field_mv_table[i][j]=NULL;
837         }
838         av_freep(&s->p_field_select_table[i]);
839     }
840     
841     av_freep(&s->dc_val_base);
842     av_freep(&s->ac_val_base);
843     av_freep(&s->coded_block_base);
844     av_freep(&s->mbintra_table);
845     av_freep(&s->cbp_table);
846     av_freep(&s->pred_dir_table);
847     
848     av_freep(&s->mbskip_table);
849     av_freep(&s->prev_pict_types);
850     av_freep(&s->bitstream_buffer);
851     s->allocated_bitstream_buffer_size=0;
852
853     av_freep(&s->avctx->stats_out);
854     av_freep(&s->ac_stats);
855     av_freep(&s->error_status_table);
856     av_freep(&s->mb_index2xy);
857     av_freep(&s->lambda_table);
858     av_freep(&s->q_intra_matrix);
859     av_freep(&s->q_inter_matrix);
860     av_freep(&s->q_intra_matrix16);
861     av_freep(&s->q_inter_matrix16);
862     av_freep(&s->input_picture);
863     av_freep(&s->reordered_input_picture);
864     av_freep(&s->dct_offset);
865
866     if(s->picture){
867         for(i=0; i<MAX_PICTURE_COUNT; i++){
868             free_picture(s, &s->picture[i]);
869         }
870     }
871     av_freep(&s->picture);
872     s->context_initialized = 0;
873     s->last_picture_ptr=
874     s->next_picture_ptr=
875     s->current_picture_ptr= NULL;
876     s->linesize= s->uvlinesize= 0;
877
878     for(i=0; i<3; i++)
879         av_freep(&s->visualization_buffer[i]);
880
881     avcodec_default_free_buffers(s->avctx);
882 }
883
884 #ifdef CONFIG_ENCODERS
885
886 /* init video encoder */
887 int MPV_encode_init(AVCodecContext *avctx)
888 {
889     MpegEncContext *s = avctx->priv_data;
890     int i, dummy;
891     int chroma_h_shift, chroma_v_shift;
892     
893     MPV_encode_defaults(s);
894
895     avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
896
897     s->bit_rate = avctx->bit_rate;
898     s->width = avctx->width;
899     s->height = avctx->height;
900     if(avctx->gop_size > 600){
901         av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
902         avctx->gop_size=600;
903     }
904     s->gop_size = avctx->gop_size;
905     s->avctx = avctx;
906     s->flags= avctx->flags;
907     s->flags2= avctx->flags2;
908     s->max_b_frames= avctx->max_b_frames;
909     s->codec_id= avctx->codec->id;
910     s->luma_elim_threshold  = avctx->luma_elim_threshold;
911     s->chroma_elim_threshold= avctx->chroma_elim_threshold;
912     s->strict_std_compliance= avctx->strict_std_compliance;
913     s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
914     s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
915     s->mpeg_quant= avctx->mpeg_quant;
916     s->rtp_mode= !!avctx->rtp_payload_size;
917     s->intra_dc_precision= avctx->intra_dc_precision;
918     s->user_specified_pts = AV_NOPTS_VALUE;
919
920     if (s->gop_size <= 1) {
921         s->intra_only = 1;
922         s->gop_size = 12;
923     } else {
924         s->intra_only = 0;
925     }
926
927     s->me_method = avctx->me_method;
928
929     /* Fixed QSCALE */
930     s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
931     
932     s->adaptive_quant= (   s->avctx->lumi_masking
933                         || s->avctx->dark_masking
934                         || s->avctx->temporal_cplx_masking 
935                         || s->avctx->spatial_cplx_masking
936                         || s->avctx->p_masking
937                         || (s->flags&CODEC_FLAG_QP_RD))
938                        && !s->fixed_qscale;
939     
940     s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
941     s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
942     s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
943
944     if(avctx->rc_max_rate && !avctx->rc_buffer_size){
945         av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
946         return -1;
947     }    
948
949     if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
950         av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
951     }
952     
953     if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
954         av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
955         return -1;
956     }
957     
958     if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
959         av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
960         return -1;
961     }
962         
963     if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate 
964        && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
965        && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
966         
967         av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
968     }
969        
970     if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
971        && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
972         av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
973         return -1;
974     }
975         
976     if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
977         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
978         return -1;
979     }
980     
981     if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
982         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
983         return -1;
984     }
985     
986     if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
987         av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
988         return -1;
989     }
990
991     if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
992         av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
993         return -1;
994     }
995     
996     if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
997         av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
998         return -1;
999     }
1000
1001     if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) 
1002        && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1003         av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1004         return -1;
1005     }
1006         
1007     if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1008         av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
1009         return -1;
1010     }
1011         
1012     if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1013         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1014         return -1;
1015     }
1016
1017     if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1018         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1019         return -1;
1020     }
1021     
1022     if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1023         av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1024         return -1;
1025     }
1026     
1027     if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 
1028        && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO 
1029        && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1030         av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1031         return -1;
1032     }
1033     
1034     if(s->avctx->thread_count > 1)
1035         s->rtp_mode= 1;
1036
1037     i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1038     if(i > 1){
1039         av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1040         avctx->frame_rate /= i;
1041         avctx->frame_rate_base /= i;
1042 //        return -1;
1043     }
1044     
1045     if(s->codec_id==CODEC_ID_MJPEG){
1046         s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1047         s->inter_quant_bias= 0;
1048     }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1049         s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1050         s->inter_quant_bias= 0;
1051     }else{
1052         s->intra_quant_bias=0;
1053         s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1054     }
1055     
1056     if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1057         s->intra_quant_bias= avctx->intra_quant_bias;
1058     if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1059         s->inter_quant_bias= avctx->inter_quant_bias;
1060         
1061     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1062
1063     av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1064     s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1065
1066     switch(avctx->codec->id) {
1067     case CODEC_ID_MPEG1VIDEO:
1068         s->out_format = FMT_MPEG1;
1069         s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1070         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1071         break;
1072     case CODEC_ID_MPEG2VIDEO:
1073         s->out_format = FMT_MPEG1;
1074         s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1075         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1076         s->rtp_mode= 1;
1077         break;
1078     case CODEC_ID_LJPEG:
1079     case CODEC_ID_MJPEG:
1080         s->out_format = FMT_MJPEG;
1081         s->intra_only = 1; /* force intra only for jpeg */
1082         s->mjpeg_write_tables = 1; /* write all tables */
1083         s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1084         s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1085         s->mjpeg_vsample[1] = 1;
1086         s->mjpeg_vsample[2] = 1; 
1087         s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1088         s->mjpeg_hsample[1] = 1; 
1089         s->mjpeg_hsample[2] = 1; 
1090         if (mjpeg_init(s) < 0)
1091             return -1;
1092         avctx->delay=0;
1093         s->low_delay=1;
1094         break;
1095 #ifdef CONFIG_RISKY
1096     case CODEC_ID_H261:
1097         s->out_format = FMT_H261;
1098         avctx->delay=0;
1099         s->low_delay=1;
1100         break;
1101     case CODEC_ID_H263:
1102         if (h263_get_picture_format(s->width, s->height) == 7) {
1103             av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1104             return -1;
1105         }
1106         s->out_format = FMT_H263;
1107         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1108         avctx->delay=0;
1109         s->low_delay=1;
1110         break;
1111     case CODEC_ID_H263P:
1112         s->out_format = FMT_H263;
1113         s->h263_plus = 1;
1114         /* Fx */
1115         s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1116         s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1117         s->modified_quant= s->h263_aic;
1118         s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1119         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1120         s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1121         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1122         s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1123
1124         /* /Fx */
1125         /* These are just to be sure */
1126         avctx->delay=0;
1127         s->low_delay=1;
1128         break;
1129     case CODEC_ID_FLV1:
1130         s->out_format = FMT_H263;
1131         s->h263_flv = 2; /* format = 1; 11-bit codes */
1132         s->unrestricted_mv = 1;
1133         s->rtp_mode=0; /* don't allow GOB */
1134         avctx->delay=0;
1135         s->low_delay=1;
1136         break;
1137     case CODEC_ID_RV10:
1138         s->out_format = FMT_H263;
1139         avctx->delay=0;
1140         s->low_delay=1;
1141         break;
1142     case CODEC_ID_RV20:
1143         s->out_format = FMT_H263;
1144         avctx->delay=0;
1145         s->low_delay=1;
1146         s->modified_quant=1;
1147         s->h263_aic=1;
1148         s->h263_plus=1;
1149         s->loop_filter=1;
1150         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1151         break;
1152     case CODEC_ID_MPEG4:
1153         s->out_format = FMT_H263;
1154         s->h263_pred = 1;
1155         s->unrestricted_mv = 1;
1156         s->low_delay= s->max_b_frames ? 0 : 1;
1157         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1158         break;
1159     case CODEC_ID_MSMPEG4V1:
1160         s->out_format = FMT_H263;
1161         s->h263_msmpeg4 = 1;
1162         s->h263_pred = 1;
1163         s->unrestricted_mv = 1;
1164         s->msmpeg4_version= 1;
1165         avctx->delay=0;
1166         s->low_delay=1;
1167         break;
1168     case CODEC_ID_MSMPEG4V2:
1169         s->out_format = FMT_H263;
1170         s->h263_msmpeg4 = 1;
1171         s->h263_pred = 1;
1172         s->unrestricted_mv = 1;
1173         s->msmpeg4_version= 2;
1174         avctx->delay=0;
1175         s->low_delay=1;
1176         break;
1177     case CODEC_ID_MSMPEG4V3:
1178         s->out_format = FMT_H263;
1179         s->h263_msmpeg4 = 1;
1180         s->h263_pred = 1;
1181         s->unrestricted_mv = 1;
1182         s->msmpeg4_version= 3;
1183         s->flipflop_rounding=1;
1184         avctx->delay=0;
1185         s->low_delay=1;
1186         break;
1187     case CODEC_ID_WMV1:
1188         s->out_format = FMT_H263;
1189         s->h263_msmpeg4 = 1;
1190         s->h263_pred = 1;
1191         s->unrestricted_mv = 1;
1192         s->msmpeg4_version= 4;
1193         s->flipflop_rounding=1;
1194         avctx->delay=0;
1195         s->low_delay=1;
1196         break;
1197     case CODEC_ID_WMV2:
1198         s->out_format = FMT_H263;
1199         s->h263_msmpeg4 = 1;
1200         s->h263_pred = 1;
1201         s->unrestricted_mv = 1;
1202         s->msmpeg4_version= 5;
1203         s->flipflop_rounding=1;
1204         avctx->delay=0;
1205         s->low_delay=1;
1206         break;
1207 #endif
1208     default:
1209         return -1;
1210     }
1211     
1212     avctx->has_b_frames= !s->low_delay;
1213
1214     s->encoding = 1;
1215
1216     /* init */
1217     if (MPV_common_init(s) < 0)
1218         return -1;
1219
1220     if(s->modified_quant)
1221         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1222     s->progressive_frame= 
1223     s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1224     s->quant_precision=5;
1225     
1226     ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1227     ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1228     
1229 #ifdef CONFIG_ENCODERS
1230 #ifdef CONFIG_RISKY
1231     if (s->out_format == FMT_H261)
1232         ff_h261_encode_init(s);
1233     if (s->out_format == FMT_H263)
1234         h263_encode_init(s);
1235     if(s->msmpeg4_version)
1236         ff_msmpeg4_encode_init(s);
1237 #endif
1238     if (s->out_format == FMT_MPEG1)
1239         ff_mpeg1_encode_init(s);
1240 #endif
1241
1242     /* init q matrix */
1243     for(i=0;i<64;i++) {
1244         int j= s->dsp.idct_permutation[i];
1245 #ifdef CONFIG_RISKY
1246         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1247             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1248             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1249         }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1250             s->intra_matrix[j] =
1251             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1252         }else
1253 #endif
1254         { /* mpeg1/2 */
1255             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1256             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1257         }
1258         if(s->avctx->intra_matrix)
1259             s->intra_matrix[j] = s->avctx->intra_matrix[i];
1260         if(s->avctx->inter_matrix)
1261             s->inter_matrix[j] = s->avctx->inter_matrix[i];
1262     }
1263
1264     /* precompute matrix */
1265     /* for mjpeg, we do include qscale in the matrix */
1266     if (s->out_format != FMT_MJPEG) {
1267         convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1268                        s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1269         convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1270                        s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1271     }
1272
1273     if(ff_rate_control_init(s) < 0)
1274         return -1;
1275     
1276     return 0;
1277 }
1278
1279 int MPV_encode_end(AVCodecContext *avctx)
1280 {
1281     MpegEncContext *s = avctx->priv_data;
1282
1283 #ifdef STATS
1284     print_stats();
1285 #endif
1286
1287     ff_rate_control_uninit(s);
1288
1289     MPV_common_end(s);
1290     if (s->out_format == FMT_MJPEG)
1291         mjpeg_close(s);
1292
1293     av_freep(&avctx->extradata);
1294       
1295     return 0;
1296 }
1297
1298 #endif //CONFIG_ENCODERS
1299
1300 void init_rl(RLTable *rl, int use_static)
1301 {
1302     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1303     uint8_t index_run[MAX_RUN+1];
1304     int last, run, level, start, end, i;
1305
1306     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1307     if(use_static && rl->max_level[0])
1308         return;
1309
1310     /* compute max_level[], max_run[] and index_run[] */
1311     for(last=0;last<2;last++) {
1312         if (last == 0) {
1313             start = 0;
1314             end = rl->last;
1315         } else {
1316             start = rl->last;
1317             end = rl->n;
1318         }
1319
1320         memset(max_level, 0, MAX_RUN + 1);
1321         memset(max_run, 0, MAX_LEVEL + 1);
1322         memset(index_run, rl->n, MAX_RUN + 1);
1323         for(i=start;i<end;i++) {
1324             run = rl->table_run[i];
1325             level = rl->table_level[i];
1326             if (index_run[run] == rl->n)
1327                 index_run[run] = i;
1328             if (level > max_level[run])
1329                 max_level[run] = level;
1330             if (run > max_run[level])
1331                 max_run[level] = run;
1332         }
1333         if(use_static)
1334             rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1335         else
1336             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1337         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1338         if(use_static)
1339             rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1340         else
1341             rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1342         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1343         if(use_static)
1344             rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1345         else
1346             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1347         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1348     }
1349 }
1350
1351 /* draw the edges of width 'w' of an image of size width, height */
1352 //FIXME check that this is ok for mpeg4 interlaced
1353 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1354 {
1355     uint8_t *ptr, *last_line;
1356     int i;
1357
1358     last_line = buf + (height - 1) * wrap;
1359     for(i=0;i<w;i++) {
1360         /* top and bottom */
1361         memcpy(buf - (i + 1) * wrap, buf, width);
1362         memcpy(last_line + (i + 1) * wrap, last_line, width);
1363     }
1364     /* left and right */
1365     ptr = buf;
1366     for(i=0;i<height;i++) {
1367         memset(ptr - w, ptr[0], w);
1368         memset(ptr + width, ptr[width-1], w);
1369         ptr += wrap;
1370     }
1371     /* corners */
1372     for(i=0;i<w;i++) {
1373         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1374         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1375         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1376         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1377     }
1378 }
1379
1380 int ff_find_unused_picture(MpegEncContext *s, int shared){
1381     int i;
1382     
1383     if(shared){
1384         for(i=0; i<MAX_PICTURE_COUNT; i++){
1385             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1386         }
1387     }else{
1388         for(i=0; i<MAX_PICTURE_COUNT; i++){
1389             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1390         }
1391         for(i=0; i<MAX_PICTURE_COUNT; i++){
1392             if(s->picture[i].data[0]==NULL) return i;
1393         }
1394     }
1395
1396     assert(0);
1397     return -1;
1398 }
1399
1400 static void update_noise_reduction(MpegEncContext *s){
1401     int intra, i;
1402
1403     for(intra=0; intra<2; intra++){
1404         if(s->dct_count[intra] > (1<<16)){
1405             for(i=0; i<64; i++){
1406                 s->dct_error_sum[intra][i] >>=1;
1407             }
1408             s->dct_count[intra] >>= 1;
1409         }
1410         
1411         for(i=0; i<64; i++){
1412             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);
1413         }
1414     }
1415 }
1416
1417 /**
1418  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1419  */
1420 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1421 {
1422     int i;
1423     AVFrame *pic;
1424     s->mb_skiped = 0;
1425
1426     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1427
1428     /* mark&release old frames */
1429     if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1430         avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1431
1432         /* release forgotten pictures */
1433         /* if(mpeg124/h263) */
1434         if(!s->encoding){
1435             for(i=0; i<MAX_PICTURE_COUNT; i++){
1436                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1437                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1438                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1439                 }
1440             }
1441         }
1442     }
1443 alloc:
1444     if(!s->encoding){
1445         /* release non refernce frames */
1446         for(i=0; i<MAX_PICTURE_COUNT; i++){
1447             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1448                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1449             }
1450         }
1451
1452         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1453             pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1454         else{
1455             i= ff_find_unused_picture(s, 0);
1456             pic= (AVFrame*)&s->picture[i];
1457         }
1458
1459         pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
1460
1461         pic->coded_picture_number= s->coded_picture_number++;
1462         
1463         if( alloc_picture(s, (Picture*)pic, 0) < 0)
1464             return -1;
1465
1466         s->current_picture_ptr= (Picture*)pic;
1467         s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1468         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1469     }
1470
1471     s->current_picture_ptr->pict_type= s->pict_type;
1472 //    if(s->flags && CODEC_FLAG_QSCALE) 
1473   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1474     s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1475
1476     copy_picture(&s->current_picture, s->current_picture_ptr);
1477   
1478   if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1479     if (s->pict_type != B_TYPE) {
1480         s->last_picture_ptr= s->next_picture_ptr;
1481         if(!s->dropable)
1482             s->next_picture_ptr= s->current_picture_ptr;
1483     }
1484 /*    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,
1485         s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1486         s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1487         s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1488         s->pict_type, s->dropable);*/
1489     
1490     if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1491     if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1492     
1493     if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1494         av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1495         assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1496         goto alloc;
1497     }
1498
1499     assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1500
1501     if(s->picture_structure!=PICT_FRAME){
1502         int i;
1503         for(i=0; i<4; i++){
1504             if(s->picture_structure == PICT_BOTTOM_FIELD){
1505                  s->current_picture.data[i] += s->current_picture.linesize[i];
1506             } 
1507             s->current_picture.linesize[i] *= 2;
1508             s->last_picture.linesize[i] *=2;
1509             s->next_picture.linesize[i] *=2;
1510         }
1511     }
1512   }
1513    
1514     s->hurry_up= s->avctx->hurry_up;
1515     s->error_resilience= avctx->error_resilience;
1516
1517     /* set dequantizer, we cant do it during init as it might change for mpeg4
1518        and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1519     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1520         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1521         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1522     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1523         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1524         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1525     }else{
1526         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1527         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1528     }
1529
1530     if(s->dct_error_sum){
1531         assert(s->avctx->noise_reduction && s->encoding);
1532
1533         update_noise_reduction(s);
1534     }
1535         
1536 #ifdef HAVE_XVMC
1537     if(s->avctx->xvmc_acceleration)
1538         return XVMC_field_start(s, avctx);
1539 #endif
1540     return 0;
1541 }
1542
1543 /* generic function for encode/decode called after a frame has been coded/decoded */
1544 void MPV_frame_end(MpegEncContext *s)
1545 {
1546     int i;
1547     /* draw edge for correct motion prediction if outside */
1548 #ifdef HAVE_XVMC
1549 //just to make sure that all data is rendered.
1550     if(s->avctx->xvmc_acceleration){
1551         XVMC_field_end(s);
1552     }else
1553 #endif
1554     if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1555             draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1556             draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1557             draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1558     }
1559     emms_c();
1560     
1561     s->last_pict_type    = s->pict_type;
1562     if(s->pict_type!=B_TYPE){
1563         s->last_non_b_pict_type= s->pict_type;
1564     }
1565 #if 0
1566         /* copy back current_picture variables */
1567     for(i=0; i<MAX_PICTURE_COUNT; i++){
1568         if(s->picture[i].data[0] == s->current_picture.data[0]){
1569             s->picture[i]= s->current_picture;
1570             break;
1571         }    
1572     }
1573     assert(i<MAX_PICTURE_COUNT);
1574 #endif    
1575
1576     if(s->encoding){
1577         /* release non refernce frames */
1578         for(i=0; i<MAX_PICTURE_COUNT; i++){
1579             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1580                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1581             }
1582         }
1583     }
1584     // clear copies, to avoid confusion
1585 #if 0
1586     memset(&s->last_picture, 0, sizeof(Picture));
1587     memset(&s->next_picture, 0, sizeof(Picture));
1588     memset(&s->current_picture, 0, sizeof(Picture));
1589 #endif
1590     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1591 }
1592
1593 /**
1594  * draws an line from (ex, ey) -> (sx, sy).
1595  * @param w width of the image
1596  * @param h height of the image
1597  * @param stride stride/linesize of the image
1598  * @param color color of the arrow
1599  */
1600 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1601     int t, x, y, fr, f;
1602     
1603     sx= clip(sx, 0, w-1);
1604     sy= clip(sy, 0, h-1);
1605     ex= clip(ex, 0, w-1);
1606     ey= clip(ey, 0, h-1);
1607     
1608     buf[sy*stride + sx]+= color;
1609     
1610     if(ABS(ex - sx) > ABS(ey - sy)){
1611         if(sx > ex){
1612             t=sx; sx=ex; ex=t;
1613             t=sy; sy=ey; ey=t;
1614         }
1615         buf+= sx + sy*stride;
1616         ex-= sx;
1617         f= ((ey-sy)<<16)/ex;
1618         for(x= 0; x <= ex; x++){
1619             y = (x*f)>>16;
1620             fr= (x*f)&0xFFFF;
1621             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1622             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1623         }
1624     }else{
1625         if(sy > ey){
1626             t=sx; sx=ex; ex=t;
1627             t=sy; sy=ey; ey=t;
1628         }
1629         buf+= sx + sy*stride;
1630         ey-= sy;
1631         if(ey) f= ((ex-sx)<<16)/ey;
1632         else   f= 0;
1633         for(y= 0; y <= ey; y++){
1634             x = (y*f)>>16;
1635             fr= (y*f)&0xFFFF;
1636             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1637             buf[y*stride + x+1]+= (color*         fr )>>16;;
1638         }
1639     }
1640 }
1641
1642 /**
1643  * draws an arrow from (ex, ey) -> (sx, sy).
1644  * @param w width of the image
1645  * @param h height of the image
1646  * @param stride stride/linesize of the image
1647  * @param color color of the arrow
1648  */
1649 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1650     int dx,dy;
1651
1652     sx= clip(sx, -100, w+100);
1653     sy= clip(sy, -100, h+100);
1654     ex= clip(ex, -100, w+100);
1655     ey= clip(ey, -100, h+100);
1656     
1657     dx= ex - sx;
1658     dy= ey - sy;
1659     
1660     if(dx*dx + dy*dy > 3*3){
1661         int rx=  dx + dy;
1662         int ry= -dx + dy;
1663         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1664         
1665         //FIXME subpixel accuracy
1666         rx= ROUNDED_DIV(rx*3<<4, length);
1667         ry= ROUNDED_DIV(ry*3<<4, length);
1668         
1669         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1670         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1671     }
1672     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1673 }
1674
1675 /**
1676  * prints debuging info for the given picture.
1677  */
1678 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1679
1680     if(!pict || !pict->mb_type) return;
1681
1682     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1683         int x,y;
1684         
1685         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1686         switch (pict->pict_type) {
1687             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1688             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1689             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1690             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1691             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1692             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1693         }
1694         for(y=0; y<s->mb_height; y++){
1695             for(x=0; x<s->mb_width; x++){
1696                 if(s->avctx->debug&FF_DEBUG_SKIP){
1697                     int count= s->mbskip_table[x + y*s->mb_stride];
1698                     if(count>9) count=9;
1699                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1700                 }
1701                 if(s->avctx->debug&FF_DEBUG_QP){
1702                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1703                 }
1704                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1705                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1706                     //Type & MV direction
1707                     if(IS_PCM(mb_type))
1708                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1709                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1710                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1711                     else if(IS_INTRA4x4(mb_type))
1712                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1713                     else if(IS_INTRA16x16(mb_type))
1714                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1715                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1716                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1717                     else if(IS_DIRECT(mb_type))
1718                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1719                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1720                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1721                     else if(IS_GMC(mb_type))
1722                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1723                     else if(IS_SKIP(mb_type))
1724                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1725                     else if(!USES_LIST(mb_type, 1))
1726                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1727                     else if(!USES_LIST(mb_type, 0))
1728                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1729                     else{
1730                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1731                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1732                     }
1733                     
1734                     //segmentation
1735                     if(IS_8X8(mb_type))
1736                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1737                     else if(IS_16X8(mb_type))
1738                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1739                     else if(IS_8X16(mb_type))
1740                         av_log(s->avctx, AV_LOG_DEBUG, "¦");
1741                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1742                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1743                     else
1744                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1745                     
1746                         
1747                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1748                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1749                     else
1750                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1751                 }
1752 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1753             }
1754             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1755         }
1756     }
1757
1758     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1759         const int shift= 1 + s->quarter_sample;
1760         int mb_y;
1761         uint8_t *ptr;
1762         int i;
1763         int h_chroma_shift, v_chroma_shift;
1764         const int width = s->avctx->width;
1765         const int height= s->avctx->height;
1766         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1767         const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1768         s->low_delay=0; //needed to see the vectors without trashing the buffers
1769
1770         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1771         for(i=0; i<3; i++){
1772             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1773             pict->data[i]= s->visualization_buffer[i];
1774         }
1775         pict->type= FF_BUFFER_TYPE_COPY;
1776         ptr= pict->data[0];
1777
1778         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1779             int mb_x;
1780             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1781                 const int mb_index= mb_x + mb_y*s->mb_stride;
1782                 if((s->avctx->debug_mv) && pict->motion_val){
1783                   int type;
1784                   for(type=0; type<3; type++){
1785                     int direction = 0;
1786                     switch (type) {
1787                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1788                                 continue;
1789                               direction = 0;
1790                               break;
1791                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1792                                 continue;
1793                               direction = 0;
1794                               break;
1795                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1796                                 continue;
1797                               direction = 1;
1798                               break;
1799                     }
1800                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1801                         continue;
1802
1803                     if(IS_8X8(pict->mb_type[mb_index])){
1804                       int i;
1805                       for(i=0; i<4; i++){
1806                         int sx= mb_x*16 + 4 + 8*(i&1);
1807                         int sy= mb_y*16 + 4 + 8*(i>>1);
1808                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << mv_sample_log2-1;
1809                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1810                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1811                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1812                       }
1813                     }else if(IS_16X8(pict->mb_type[mb_index])){
1814                       int i;
1815                       for(i=0; i<2; i++){
1816                         int sx=mb_x*16 + 8;
1817                         int sy=mb_y*16 + 4 + 8*i;
1818                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << mv_sample_log2-1;
1819                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1820                         int my=(pict->motion_val[direction][xy][1]>>shift);
1821                         
1822                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1823                             my*=2;
1824                         
1825                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1826                       }
1827                     }else if(IS_8X16(pict->mb_type[mb_index])){
1828                       int i;
1829                       for(i=0; i<2; i++){
1830                         int sx=mb_x*16 + 4 + 8*i;
1831                         int sy=mb_y*16 + 8;
1832                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << mv_sample_log2-1;
1833                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1834                         int my=(pict->motion_val[direction][xy][1]>>shift);
1835                         
1836                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1837                             my*=2;
1838                         
1839                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1840                       }
1841                     }else{
1842                       int sx= mb_x*16 + 8;
1843                       int sy= mb_y*16 + 8;
1844                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1845                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1846                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1847                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1848                     }
1849                   }                  
1850                 }
1851                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1852                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1853                     int y;
1854                     for(y=0; y<8; y++){
1855                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1856                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1857                     }
1858                 }
1859                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1860                     int mb_type= pict->mb_type[mb_index];
1861                     uint64_t u,v;
1862                     int y;
1863 #define COLOR(theta, r)\
1864 u= (int)(128 + r*cos(theta*3.141592/180));\
1865 v= (int)(128 + r*sin(theta*3.141592/180));
1866
1867                     
1868                     u=v=128;
1869                     if(IS_PCM(mb_type)){
1870                         COLOR(120,48)
1871                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1872                         COLOR(30,48)
1873                     }else if(IS_INTRA4x4(mb_type)){
1874                         COLOR(90,48)
1875                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1876 //                        COLOR(120,48)
1877                     }else if(IS_DIRECT(mb_type)){
1878                         COLOR(150,48)
1879                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1880                         COLOR(170,48)
1881                     }else if(IS_GMC(mb_type)){
1882                         COLOR(190,48)
1883                     }else if(IS_SKIP(mb_type)){
1884 //                        COLOR(180,48)
1885                     }else if(!USES_LIST(mb_type, 1)){
1886                         COLOR(240,48)
1887                     }else if(!USES_LIST(mb_type, 0)){
1888                         COLOR(0,48)
1889                     }else{
1890                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1891                         COLOR(300,48)
1892                     }
1893
1894                     u*= 0x0101010101010101ULL;
1895                     v*= 0x0101010101010101ULL;
1896                     for(y=0; y<8; y++){
1897                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1898                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1899                     }
1900
1901                     //segmentation
1902                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1903                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1904                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1905                     }
1906                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1907                         for(y=0; y<16; y++)
1908                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1909                     }
1910                         
1911                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1912                         // hmm
1913                     }
1914                 }
1915                 s->mbskip_table[mb_index]=0;
1916             }
1917         }
1918     }
1919 }
1920
1921 #ifdef CONFIG_ENCODERS
1922
1923 static int get_sae(uint8_t *src, int ref, int stride){
1924     int x,y;
1925     int acc=0;
1926     
1927     for(y=0; y<16; y++){
1928         for(x=0; x<16; x++){
1929             acc+= ABS(src[x+y*stride] - ref);
1930         }
1931     }
1932     
1933     return acc;
1934 }
1935
1936 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1937     int x, y, w, h;
1938     int acc=0;
1939     
1940     w= s->width &~15;
1941     h= s->height&~15;
1942     
1943     for(y=0; y<h; y+=16){
1944         for(x=0; x<w; x+=16){
1945             int offset= x + y*stride;
1946             int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1947             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1948             int sae = get_sae(src + offset, mean, stride);
1949             
1950             acc+= sae + 500 < sad;
1951         }
1952     }
1953     return acc;
1954 }
1955
1956
1957 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1958     AVFrame *pic=NULL;
1959     int64_t pts;
1960     int i;
1961     const int encoding_delay= s->max_b_frames;
1962     int direct=1;
1963     
1964     if(pic_arg){
1965         pts= pic_arg->pts;
1966         pic_arg->display_picture_number= s->input_picture_number++;
1967
1968         if(pts != AV_NOPTS_VALUE){ 
1969             if(s->user_specified_pts != AV_NOPTS_VALUE){
1970                 int64_t time= av_rescale(pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1971                 int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1972             
1973                 if(time <= last){            
1974                     av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pts, s->user_specified_pts);
1975                     return -1;
1976                 }
1977             }
1978             s->user_specified_pts= pts;
1979         }else{
1980             if(s->user_specified_pts != AV_NOPTS_VALUE){
1981                 s->user_specified_pts= 
1982                 pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
1983                 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pts);
1984             }else{
1985                 pts= av_rescale(pic_arg->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
1986             }
1987         }
1988     }
1989
1990   if(pic_arg){
1991     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1992     if(pic_arg->linesize[0] != s->linesize) direct=0;
1993     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1994     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1995   
1996 //    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1997     
1998     if(direct){
1999         i= ff_find_unused_picture(s, 1);
2000
2001         pic= (AVFrame*)&s->picture[i];
2002         pic->reference= 3;
2003     
2004         for(i=0; i<4; i++){
2005             pic->data[i]= pic_arg->data[i];
2006             pic->linesize[i]= pic_arg->linesize[i];
2007         }
2008         alloc_picture(s, (Picture*)pic, 1);
2009     }else{
2010         int offset= 16;
2011         i= ff_find_unused_picture(s, 0);
2012
2013         pic= (AVFrame*)&s->picture[i];
2014         pic->reference= 3;
2015
2016         alloc_picture(s, (Picture*)pic, 0);
2017
2018         if(   pic->data[0] + offset == pic_arg->data[0] 
2019            && pic->data[1] + offset == pic_arg->data[1]
2020            && pic->data[2] + offset == pic_arg->data[2]){
2021        // empty
2022         }else{
2023             int h_chroma_shift, v_chroma_shift;
2024             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2025         
2026             for(i=0; i<3; i++){
2027                 int src_stride= pic_arg->linesize[i];
2028                 int dst_stride= i ? s->uvlinesize : s->linesize;
2029                 int h_shift= i ? h_chroma_shift : 0;
2030                 int v_shift= i ? v_chroma_shift : 0;
2031                 int w= s->width >>h_shift;
2032                 int h= s->height>>v_shift;
2033                 uint8_t *src= pic_arg->data[i];
2034                 uint8_t *dst= pic->data[i] + offset;
2035             
2036                 if(src_stride==dst_stride)
2037                     memcpy(dst, src, src_stride*h);
2038                 else{
2039                     while(h--){
2040                         memcpy(dst, src, w);
2041                         dst += dst_stride;
2042                         src += src_stride;
2043                     }
2044                 }
2045             }
2046         }
2047     }
2048     copy_picture_attributes(s, pic, pic_arg);
2049     pic->pts= pts; //we set this here to avoid modifiying pic_arg
2050   }
2051   
2052     /* shift buffer entries */
2053     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2054         s->input_picture[i-1]= s->input_picture[i];
2055         
2056     s->input_picture[encoding_delay]= (Picture*)pic;
2057
2058     return 0;
2059 }
2060
2061 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2062     int x, y, plane;
2063     int score=0;
2064     int64_t score64=0;
2065     int64_t threshold;
2066
2067     for(plane=0; plane<3; plane++){
2068         const int stride= p->linesize[plane];
2069         const int bw= plane ? 1 : 2;
2070         for(y=0; y<s->mb_height*bw; y++){
2071             for(x=0; x<s->mb_width*bw; x++){
2072                 int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride), ref->data[plane] + 8*(x + y*stride), stride, 8);
2073                 
2074                 switch(s->avctx->frame_skip_exp){
2075                     case 0: score= FFMAX(score, v); break;
2076                     case 1: score+= ABS(v);break;
2077                     case 2: score+= v*v;break;
2078                     case 3: score64+= ABS(v*v*(int64_t)v);break;
2079                     case 4: score64+= v*v*(int64_t)(v*v);break;
2080                 }
2081             }
2082         }
2083     }
2084     
2085     if(score) score64= score;
2086
2087     if(score64 < s->avctx->frame_skip_threshold)
2088         return 1;
2089     if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2090         return 1;
2091     return 0;
2092 }
2093
2094 static void select_input_picture(MpegEncContext *s){
2095     int i;
2096
2097     for(i=1; i<MAX_PICTURE_COUNT; i++)
2098         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2099     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2100
2101     /* set next picture types & ordering */
2102     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2103         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2104             s->reordered_input_picture[0]= s->input_picture[0];
2105             s->reordered_input_picture[0]->pict_type= I_TYPE;
2106             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2107         }else{
2108             int b_frames;
2109
2110             if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2111                 if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2112 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2113                 
2114                     if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2115                         for(i=0; i<4; i++)
2116                             s->input_picture[0]->data[i]= NULL;
2117                         s->input_picture[0]->type= 0;            
2118                     }else{
2119                         assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER 
2120                                || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2121             
2122                         s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2123                     }
2124
2125                     goto no_output_pic;
2126                 }
2127             }
2128
2129             if(s->flags&CODEC_FLAG_PASS2){
2130                 for(i=0; i<s->max_b_frames+1; i++){
2131                     int pict_num= s->input_picture[0]->display_picture_number + i;
2132
2133                     if(pict_num >= s->rc_context.num_entries) 
2134                         break;
2135                     if(!s->input_picture[i]){
2136                         s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2137                         break;
2138                     }
2139
2140                     s->input_picture[i]->pict_type= 
2141                         s->rc_context.entry[pict_num].new_pict_type;
2142                 }
2143             }
2144
2145             if(s->avctx->b_frame_strategy==0){
2146                 b_frames= s->max_b_frames;
2147                 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2148             }else if(s->avctx->b_frame_strategy==1){
2149                 for(i=1; i<s->max_b_frames+1; i++){
2150                     if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2151                         s->input_picture[i]->b_frame_score= 
2152                             get_intra_count(s, s->input_picture[i  ]->data[0], 
2153                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
2154                     }
2155                 }
2156                 for(i=0; i<s->max_b_frames; i++){
2157                     if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2158                 }
2159                                 
2160                 b_frames= FFMAX(0, i-1);
2161                 
2162                 /* reset scores */
2163                 for(i=0; i<b_frames+1; i++){
2164                     s->input_picture[i]->b_frame_score=0;
2165                 }
2166             }else{
2167                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2168                 b_frames=0;
2169             }
2170
2171             emms_c();
2172 //static int b_count=0;
2173 //b_count+= b_frames;
2174 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2175
2176             for(i= b_frames - 1; i>=0; i--){
2177                 int type= s->input_picture[i]->pict_type;
2178                 if(type && type != B_TYPE)
2179                     b_frames= i;
2180             }
2181             if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2182                 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2183             }
2184
2185             if(s->picture_in_gop_number + b_frames >= s->gop_size){
2186               if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2187                     b_frames= s->gop_size - s->picture_in_gop_number - 1;
2188               }else{
2189                 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2190                     b_frames=0;
2191                 s->input_picture[b_frames]->pict_type= I_TYPE;
2192               }
2193             }
2194             
2195             if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2196                && b_frames
2197                && s->input_picture[b_frames]->pict_type== I_TYPE)
2198                 b_frames--;
2199
2200             s->reordered_input_picture[0]= s->input_picture[b_frames];
2201             if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2202                 s->reordered_input_picture[0]->pict_type= P_TYPE;
2203             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2204             for(i=0; i<b_frames; i++){
2205                 s->reordered_input_picture[i+1]= s->input_picture[i];
2206                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2207                 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2208             }
2209         }
2210     }
2211 no_output_pic:
2212     if(s->reordered_input_picture[0]){
2213         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2214
2215         copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2216
2217         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2218             // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2219         
2220             int i= ff_find_unused_picture(s, 0);
2221             Picture *pic= &s->picture[i];
2222
2223             /* mark us unused / free shared pic */
2224             for(i=0; i<4; i++)
2225                 s->reordered_input_picture[0]->data[i]= NULL;
2226             s->reordered_input_picture[0]->type= 0;
2227             
2228             pic->reference              = s->reordered_input_picture[0]->reference;
2229             
2230             alloc_picture(s, pic, 0);
2231
2232             copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2233
2234             s->current_picture_ptr= pic;
2235         }else{
2236             // input is not a shared pix -> reuse buffer for current_pix
2237
2238             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2239                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2240             
2241             s->current_picture_ptr= s->reordered_input_picture[0];
2242             for(i=0; i<4; i++){
2243                 s->new_picture.data[i]+=16;
2244             }
2245         }
2246         copy_picture(&s->current_picture, s->current_picture_ptr);
2247     
2248         s->picture_number= s->new_picture.display_picture_number;
2249 //printf("dpn:%d\n", s->picture_number);
2250     }else{
2251        memset(&s->new_picture, 0, sizeof(Picture));
2252     }
2253 }
2254
2255 int MPV_encode_picture(AVCodecContext *avctx,
2256                        unsigned char *buf, int buf_size, void *data)
2257 {
2258     MpegEncContext *s = avctx->priv_data;
2259     AVFrame *pic_arg = data;
2260     int i, stuffing_count;
2261
2262     if(avctx->pix_fmt != PIX_FMT_YUV420P){
2263         av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2264         return -1;
2265     }
2266     
2267     for(i=0; i<avctx->thread_count; i++){
2268         int start_y= s->thread_context[i]->start_mb_y;
2269         int   end_y= s->thread_context[i]->  end_mb_y;
2270         int h= s->mb_height;
2271         uint8_t *start= buf + buf_size*start_y/h;
2272         uint8_t *end  = buf + buf_size*  end_y/h;
2273
2274         init_put_bits(&s->thread_context[i]->pb, start, end - start);
2275     }
2276
2277     s->picture_in_gop_number++;
2278
2279     if(load_input_picture(s, pic_arg) < 0)
2280         return -1;
2281     
2282     select_input_picture(s);
2283     
2284     /* output? */
2285     if(s->new_picture.data[0]){
2286         s->pict_type= s->new_picture.pict_type;
2287 //emms_c();
2288 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2289         MPV_frame_start(s, avctx);
2290
2291         encode_picture(s, s->picture_number);
2292         
2293         avctx->real_pict_num  = s->picture_number;
2294         avctx->header_bits = s->header_bits;
2295         avctx->mv_bits     = s->mv_bits;
2296         avctx->misc_bits   = s->misc_bits;
2297         avctx->i_tex_bits  = s->i_tex_bits;
2298         avctx->p_tex_bits  = s->p_tex_bits;
2299         avctx->i_count     = s->i_count;
2300         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2301         avctx->skip_count  = s->skip_count;
2302
2303         MPV_frame_end(s);
2304
2305         if (s->out_format == FMT_MJPEG)
2306             mjpeg_picture_trailer(s);
2307         
2308         if(s->flags&CODEC_FLAG_PASS1)
2309             ff_write_pass1_stats(s);
2310
2311         for(i=0; i<4; i++){
2312             avctx->error[i] += s->current_picture_ptr->error[i];
2313         }
2314
2315         flush_put_bits(&s->pb);
2316         s->frame_bits  = put_bits_count(&s->pb);
2317
2318         stuffing_count= ff_vbv_update(s, s->frame_bits);
2319         if(stuffing_count){
2320             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2321                 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2322                 return -1;
2323             }
2324
2325             switch(s->codec_id){
2326             case CODEC_ID_MPEG1VIDEO:
2327             case CODEC_ID_MPEG2VIDEO:
2328                 while(stuffing_count--){
2329                     put_bits(&s->pb, 8, 0);
2330                 }
2331             break;
2332             case CODEC_ID_MPEG4:
2333                 put_bits(&s->pb, 16, 0);
2334                 put_bits(&s->pb, 16, 0x1C3);
2335                 stuffing_count -= 4;
2336                 while(stuffing_count--){
2337                     put_bits(&s->pb, 8, 0xFF);
2338                 }
2339             break;
2340             default:
2341                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2342             }
2343             flush_put_bits(&s->pb);
2344             s->frame_bits  = put_bits_count(&s->pb);
2345         }
2346
2347         /* update mpeg1/2 vbv_delay for CBR */    
2348         if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2349            && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2350             int vbv_delay;
2351
2352             assert(s->repeat_first_field==0);
2353             
2354             vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2355             assert(vbv_delay < 0xFFFF);
2356
2357             s->vbv_delay_ptr[0] &= 0xF8;
2358             s->vbv_delay_ptr[0] |= vbv_delay>>13;
2359             s->vbv_delay_ptr[1]  = vbv_delay>>5;
2360             s->vbv_delay_ptr[2] &= 0x07;
2361             s->vbv_delay_ptr[2] |= vbv_delay<<3;
2362         }
2363         s->total_bits += s->frame_bits;
2364         avctx->frame_bits  = s->frame_bits;
2365     }else{
2366         assert((pbBufPtr(&s->pb) == s->pb.buf));
2367         s->frame_bits=0;
2368     }
2369     assert((s->frame_bits&7)==0);
2370     
2371     return s->frame_bits/8;
2372 }
2373
2374 #endif //CONFIG_ENCODERS
2375
2376 static inline void gmc1_motion(MpegEncContext *s,
2377                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2378                                uint8_t **ref_picture)
2379 {
2380     uint8_t *ptr;
2381     int offset, src_x, src_y, linesize, uvlinesize;
2382     int motion_x, motion_y;
2383     int emu=0;
2384
2385     motion_x= s->sprite_offset[0][0];
2386     motion_y= s->sprite_offset[0][1];
2387     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2388     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2389     motion_x<<=(3-s->sprite_warping_accuracy);
2390     motion_y<<=(3-s->sprite_warping_accuracy);
2391     src_x = clip(src_x, -16, s->width);
2392     if (src_x == s->width)
2393         motion_x =0;
2394     src_y = clip(src_y, -16, s->height);
2395     if (src_y == s->height)
2396         motion_y =0;
2397
2398     linesize = s->linesize;
2399     uvlinesize = s->uvlinesize;
2400     
2401     ptr = ref_picture[0] + (src_y * linesize) + src_x;
2402
2403     if(s->flags&CODEC_FLAG_EMU_EDGE){
2404         if(   (unsigned)src_x >= s->h_edge_pos - 17
2405            || (unsigned)src_y >= s->v_edge_pos - 17){
2406             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2407             ptr= s->edge_emu_buffer;
2408         }
2409     }
2410     
2411     if((motion_x|motion_y)&7){
2412         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2413         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2414     }else{
2415         int dxy;
2416         
2417         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2418         if (s->no_rounding){
2419             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2420         }else{
2421             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2422         }
2423     }
2424     
2425     if(s->flags&CODEC_FLAG_GRAY) return;
2426
2427     motion_x= s->sprite_offset[1][0];
2428     motion_y= s->sprite_offset[1][1];
2429     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2430     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2431     motion_x<<=(3-s->sprite_warping_accuracy);
2432     motion_y<<=(3-s->sprite_warping_accuracy);
2433     src_x = clip(src_x, -8, s->width>>1);
2434     if (src_x == s->width>>1)
2435         motion_x =0;
2436     src_y = clip(src_y, -8, s->height>>1);
2437     if (src_y == s->height>>1)
2438         motion_y =0;
2439
2440     offset = (src_y * uvlinesize) + src_x;
2441     ptr = ref_picture[1] + offset;
2442     if(s->flags&CODEC_FLAG_EMU_EDGE){
2443         if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2444            || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2445             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2446             ptr= s->edge_emu_buffer;
2447             emu=1;
2448         }
2449     }
2450     s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2451     
2452     ptr = ref_picture[2] + offset;
2453     if(emu){
2454         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2455         ptr= s->edge_emu_buffer;
2456     }
2457     s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2458     
2459     return;
2460 }
2461
2462 static inline void gmc_motion(MpegEncContext *s,
2463                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2464                                uint8_t **ref_picture)
2465 {
2466     uint8_t *ptr;
2467     int linesize, uvlinesize;
2468     const int a= s->sprite_warping_accuracy;
2469     int ox, oy;
2470
2471     linesize = s->linesize;
2472     uvlinesize = s->uvlinesize;
2473
2474     ptr = ref_picture[0];
2475
2476     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2477     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2478
2479     s->dsp.gmc(dest_y, ptr, linesize, 16,
2480            ox, 
2481            oy, 
2482            s->sprite_delta[0][0], s->sprite_delta[0][1],
2483            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2484            a+1, (1<<(2*a+1)) - s->no_rounding,
2485            s->h_edge_pos, s->v_edge_pos);
2486     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2487            ox + s->sprite_delta[0][0]*8, 
2488            oy + s->sprite_delta[1][0]*8, 
2489            s->sprite_delta[0][0], s->sprite_delta[0][1],
2490            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2491            a+1, (1<<(2*a+1)) - s->no_rounding,
2492            s->h_edge_pos, s->v_edge_pos);
2493
2494     if(s->flags&CODEC_FLAG_GRAY) return;
2495
2496     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2497     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2498
2499     ptr = ref_picture[1];
2500     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2501            ox, 
2502            oy, 
2503            s->sprite_delta[0][0], s->sprite_delta[0][1],
2504            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2505            a+1, (1<<(2*a+1)) - s->no_rounding,
2506            s->h_edge_pos>>1, s->v_edge_pos>>1);
2507     
2508     ptr = ref_picture[2];
2509     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2510            ox, 
2511            oy, 
2512            s->sprite_delta[0][0], s->sprite_delta[0][1],
2513            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2514            a+1, (1<<(2*a+1)) - s->no_rounding,
2515            s->h_edge_pos>>1, s->v_edge_pos>>1);
2516 }
2517
2518 /**
2519  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2520  * @param buf destination buffer
2521  * @param src source buffer
2522  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2523  * @param block_w width of block
2524  * @param block_h height of block
2525  * @param src_x x coordinate of the top left sample of the block in the source buffer
2526  * @param src_y y coordinate of the top left sample of the block in the source buffer
2527  * @param w width of the source buffer
2528  * @param h height of the source buffer
2529  */
2530 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2531                                     int src_x, int src_y, int w, int h){
2532     int x, y;
2533     int start_y, start_x, end_y, end_x;
2534
2535     if(src_y>= h){
2536         src+= (h-1-src_y)*linesize;
2537         src_y=h-1;
2538     }else if(src_y<=-block_h){
2539         src+= (1-block_h-src_y)*linesize;
2540         src_y=1-block_h;
2541     }
2542     if(src_x>= w){
2543         src+= (w-1-src_x);
2544         src_x=w-1;
2545     }else if(src_x<=-block_w){
2546         src+= (1-block_w-src_x);
2547         src_x=1-block_w;
2548     }
2549
2550     start_y= FFMAX(0, -src_y);
2551     start_x= FFMAX(0, -src_x);
2552     end_y= FFMIN(block_h, h-src_y);
2553     end_x= FFMIN(block_w, w-src_x);
2554
2555     // copy existing part
2556     for(y=start_y; y<end_y; y++){
2557         for(x=start_x; x<end_x; x++){
2558             buf[x + y*linesize]= src[x + y*linesize];
2559         }
2560     }
2561
2562     //top
2563     for(y=0; y<start_y; y++){
2564         for(x=start_x; x<end_x; x++){
2565             buf[x + y*linesize]= buf[x + start_y*linesize];
2566         }
2567     }
2568
2569     //bottom
2570     for(y=end_y; y<block_h; y++){
2571         for(x=start_x; x<end_x; x++){
2572             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2573         }
2574     }
2575                                     
2576     for(y=0; y<block_h; y++){
2577        //left
2578         for(x=0; x<start_x; x++){
2579             buf[x + y*linesize]= buf[start_x + y*linesize];
2580         }
2581        
2582        //right
2583         for(x=end_x; x<block_w; x++){
2584             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2585         }
2586     }
2587 }
2588
2589 static inline int hpel_motion(MpegEncContext *s, 
2590                                   uint8_t *dest, uint8_t *src,
2591                                   int field_based, int field_select,
2592                                   int src_x, int src_y,
2593                                   int width, int height, int stride,
2594                                   int h_edge_pos, int v_edge_pos,
2595                                   int w, int h, op_pixels_func *pix_op,
2596                                   int motion_x, int motion_y)
2597 {
2598     int dxy;
2599     int emu=0;
2600
2601     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2602     src_x += motion_x >> 1;
2603     src_y += motion_y >> 1;
2604                 
2605     /* WARNING: do no forget half pels */
2606     src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2607     if (src_x == width)
2608         dxy &= ~1;
2609     src_y = clip(src_y, -16, height);
2610     if (src_y == height)
2611         dxy &= ~2;
2612     src += src_y * stride + src_x;
2613
2614     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2615         if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2616            || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2617             ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2618                              src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2619             src= s->edge_emu_buffer;
2620             emu=1;
2621         }
2622     }
2623     if(field_select)
2624         src += s->linesize;
2625     pix_op[dxy](dest, src, stride, h);
2626     return emu;
2627 }
2628
2629 static inline int hpel_motion_lowres(MpegEncContext *s, 
2630                                   uint8_t *dest, uint8_t *src,
2631                                   int field_based, int field_select,
2632                                   int src_x, int src_y,
2633                                   int width, int height, int stride,
2634                                   int h_edge_pos, int v_edge_pos,
2635                                   int w, int h, h264_chroma_mc_func *pix_op,
2636                                   int motion_x, int motion_y)
2637 {
2638     const int lowres= s->avctx->lowres;
2639     const int s_mask= (2<<lowres)-1;
2640     int emu=0;
2641     int sx, sy;
2642
2643     if(s->quarter_sample){
2644         motion_x/=2;
2645         motion_y/=2;
2646     }
2647
2648     sx= motion_x & s_mask;
2649     sy= motion_y & s_mask;
2650     src_x += motion_x >> (lowres+1);
2651     src_y += motion_y >> (lowres+1);
2652                 
2653     src += src_y * stride + src_x;
2654
2655     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2656        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2657         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2658                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2659         src= s->edge_emu_buffer;
2660         emu=1;
2661     }
2662
2663     sx <<= 2 - lowres;
2664     sy <<= 2 - lowres;
2665     if(field_select)
2666         src += s->linesize;
2667     pix_op[lowres](dest, src, stride, h, sx, sy);
2668     return emu;
2669 }
2670
2671 /* apply one mpeg motion vector to the three components */
2672 static always_inline void mpeg_motion(MpegEncContext *s,
2673                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2674                                int field_based, int bottom_field, int field_select,
2675                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2676                                int motion_x, int motion_y, int h)
2677 {
2678     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2679     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2680     
2681 #if 0    
2682 if(s->quarter_sample)
2683 {
2684     motion_x>>=1;
2685     motion_y>>=1;
2686 }
2687 #endif
2688
2689     v_edge_pos = s->v_edge_pos >> field_based;
2690     linesize   = s->current_picture.linesize[0] << field_based;
2691     uvlinesize = s->current_picture.linesize[1] << field_based;
2692
2693     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2694     src_x = s->mb_x* 16               + (motion_x >> 1);
2695     src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2696
2697     if (s->out_format == FMT_H263) {
2698         if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2699             mx = (motion_x>>1)|(motion_x&1);
2700             my = motion_y >>1;
2701             uvdxy = ((my & 1) << 1) | (mx & 1);
2702             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2703             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2704         }else{
2705             uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2706             uvsrc_x = src_x>>1;
2707             uvsrc_y = src_y>>1;
2708         }
2709     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2710         mx = motion_x / 4;
2711         my = motion_y / 4;
2712         uvdxy = 0;
2713         uvsrc_x = s->mb_x*8 + mx;
2714         uvsrc_y = s->mb_y*8 + my;
2715     } else {
2716         if(s->chroma_y_shift){
2717             mx = motion_x / 2;
2718             my = motion_y / 2;
2719             uvdxy = ((my & 1) << 1) | (mx & 1);
2720             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2721             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2722         } else {
2723             if(s->chroma_x_shift){
2724             //Chroma422
2725                 mx = motion_x / 2;
2726                 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2727                 uvsrc_x = s->mb_x* 8           + (mx >> 1);
2728                 uvsrc_y = src_y;
2729             } else {
2730             //Chroma444
2731                 uvdxy = dxy;
2732                 uvsrc_x = src_x;
2733                 uvsrc_y = src_y;
2734             }
2735         }
2736     }
2737
2738     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2739     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2740     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2741
2742     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2743        || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2744             if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2745                s->codec_id == CODEC_ID_MPEG1VIDEO){
2746                 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2747                 return ;
2748             }
2749             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2750                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2751             ptr_y = s->edge_emu_buffer;
2752             if(!(s->flags&CODEC_FLAG_GRAY)){
2753                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2754                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2755                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2756                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2757                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2758                 ptr_cb= uvbuf;
2759                 ptr_cr= uvbuf+16;
2760             }
2761     }
2762
2763     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2764         dest_y += s->linesize;
2765         dest_cb+= s->uvlinesize;
2766         dest_cr+= s->uvlinesize;
2767     }
2768
2769     if(field_select){
2770         ptr_y += s->linesize;
2771         ptr_cb+= s->uvlinesize;
2772         ptr_cr+= s->uvlinesize;
2773     }
2774
2775     pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2776     
2777     if(!(s->flags&CODEC_FLAG_GRAY)){
2778         pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2779         pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2780     }
2781     if(s->out_format == FMT_H261){
2782         ff_h261_loop_filter(s);
2783     }
2784 }
2785
2786 /* apply one mpeg motion vector to the three components */
2787 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2788                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2789                                int field_based, int bottom_field, int field_select,
2790                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2791                                int motion_x, int motion_y, int h)
2792 {
2793     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2794     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2795     const int lowres= s->avctx->lowres;
2796     const int block_s= 8>>lowres;
2797     const int s_mask= (2<<lowres)-1;
2798     const int h_edge_pos = s->h_edge_pos >> lowres;
2799     const int v_edge_pos = s->v_edge_pos >> lowres;
2800     linesize   = s->current_picture.linesize[0] << field_based;
2801     uvlinesize = s->current_picture.linesize[1] << field_based;
2802
2803     if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2804         motion_x/=2;
2805         motion_y/=2;
2806     }
2807     
2808     if(field_based){
2809         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2810     }
2811
2812     sx= motion_x & s_mask;
2813     sy= motion_y & s_mask;
2814     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2815     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2816     
2817     if (s->out_format == FMT_H263) {
2818         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2819         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2820         uvsrc_x = src_x>>1;
2821         uvsrc_y = src_y>>1;
2822     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2823         mx = motion_x / 4;
2824         my = motion_y / 4;
2825         uvsx = (2*mx) & s_mask;
2826         uvsy = (2*my) & s_mask;
2827         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2828         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2829     } else {
2830         mx = motion_x / 2;
2831         my = motion_y / 2;
2832         uvsx = mx & s_mask;
2833         uvsy = my & s_mask;
2834         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2835         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2836     }
2837
2838     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2839     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2840     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2841
2842     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2843        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2844             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2845                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2846             ptr_y = s->edge_emu_buffer;
2847             if(!(s->flags&CODEC_FLAG_GRAY)){
2848                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2849                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2850                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2851                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2852                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2853                 ptr_cb= uvbuf;
2854                 ptr_cr= uvbuf+16;
2855             }
2856     }
2857
2858     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2859         dest_y += s->linesize;
2860         dest_cb+= s->uvlinesize;
2861         dest_cr+= s->uvlinesize;
2862     }
2863
2864     if(field_select){
2865         ptr_y += s->linesize;
2866         ptr_cb+= s->uvlinesize;
2867         ptr_cr+= s->uvlinesize;
2868     }
2869
2870     sx <<= 2 - lowres;
2871     sy <<= 2 - lowres;
2872     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2873     
2874     if(!(s->flags&CODEC_FLAG_GRAY)){
2875         uvsx <<= 2 - lowres;
2876         uvsy <<= 2 - lowres;
2877         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2878         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2879     }
2880     //FIXME h261 lowres loop filter
2881 }
2882
2883 //FIXME move to dsputil, avg variant, 16x16 version
2884 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2885     int x;
2886     uint8_t * const top   = src[1];
2887     uint8_t * const left  = src[2];
2888     uint8_t * const mid   = src[0];
2889     uint8_t * const right = src[3];
2890     uint8_t * const bottom= src[4];
2891 #define OBMC_FILTER(x, t, l, m, r, b)\
2892     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2893 #define OBMC_FILTER4(x, t, l, m, r, b)\
2894     OBMC_FILTER(x         , t, l, m, r, b);\
2895     OBMC_FILTER(x+1       , t, l, m, r, b);\
2896     OBMC_FILTER(x  +stride, t, l, m, r, b);\
2897     OBMC_FILTER(x+1+stride, t, l, m, r, b);
2898     
2899     x=0;
2900     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2901     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2902     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2903     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2904     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2905     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2906     x+= stride;
2907     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2908     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2909     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2910     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2911     x+= stride;
2912     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2913     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2914     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2915     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2916     x+= 2*stride;
2917     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2918     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2919     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2920     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2921     x+= 2*stride;
2922     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2923     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2924     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2925     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2926     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2927     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2928     x+= stride;
2929     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2930     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2931     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2932     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2933 }
2934
2935 /* obmc for 1 8x8 luma block */
2936 static inline void obmc_motion(MpegEncContext *s,
2937                                uint8_t *dest, uint8_t *src,
2938                                int src_x, int src_y,
2939                                op_pixels_func *pix_op,
2940                                int16_t mv[5][2]/* mid top left right bottom*/)
2941 #define MID    0
2942 {
2943     int i;
2944     uint8_t *ptr[5];
2945     
2946     assert(s->quarter_sample==0);
2947     
2948     for(i=0; i<5; i++){
2949         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2950             ptr[i]= ptr[MID];
2951         }else{
2952             ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2953             hpel_motion(s, ptr[i], src, 0, 0,
2954                         src_x, src_y,
2955                         s->width, s->height, s->linesize,
2956                         s->h_edge_pos, s->v_edge_pos,
2957                         8, 8, pix_op,
2958                         mv[i][0], mv[i][1]);
2959         }
2960     }
2961
2962     put_obmc(dest, ptr, s->linesize);                
2963 }
2964
2965 static inline void qpel_motion(MpegEncContext *s,
2966                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2967                                int field_based, int bottom_field, int field_select,
2968                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2969                                qpel_mc_func (*qpix_op)[16],
2970                                int motion_x, int motion_y, int h)
2971 {
2972     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2973     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2974
2975     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2976     src_x = s->mb_x *  16                 + (motion_x >> 2);
2977     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2978
2979     v_edge_pos = s->v_edge_pos >> field_based;
2980     linesize = s->linesize << field_based;
2981     uvlinesize = s->uvlinesize << field_based;
2982     
2983     if(field_based){
2984         mx= motion_x/2;
2985         my= motion_y>>1;
2986     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2987         static const int rtab[8]= {0,0,1,1,0,0,0,1};
2988         mx= (motion_x>>1) + rtab[motion_x&7];
2989         my= (motion_y>>1) + rtab[motion_y&7];
2990     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2991         mx= (motion_x>>1)|(motion_x&1);
2992         my= (motion_y>>1)|(motion_y&1);
2993     }else{
2994         mx= motion_x/2;
2995         my= motion_y/2;
2996     }
2997     mx= (mx>>1)|(mx&1);
2998     my= (my>>1)|(my&1);
2999
3000     uvdxy= (mx&1) | ((my&1)<<1);
3001     mx>>=1;
3002     my>>=1;
3003
3004     uvsrc_x = s->mb_x *  8                 + mx;
3005     uvsrc_y = s->mb_y * (8 >> field_based) + my;
3006
3007     ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3008     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3009     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3010
3011     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
3012        || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3013         ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
3014                          src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3015         ptr_y= s->edge_emu_buffer;
3016         if(!(s->flags&CODEC_FLAG_GRAY)){
3017             uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3018             ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
3019                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3020             ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
3021                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3022             ptr_cb= uvbuf;
3023             ptr_cr= uvbuf + 16;
3024         }
3025     }
3026
3027     if(!field_based)
3028         qpix_op[0][dxy](dest_y, ptr_y, linesize);
3029     else{
3030         if(bottom_field){
3031             dest_y += s->linesize;
3032             dest_cb+= s->uvlinesize;
3033             dest_cr+= s->uvlinesize;
3034         }
3035
3036         if(field_select){
3037             ptr_y  += s->linesize;
3038             ptr_cb += s->uvlinesize;
3039             ptr_cr += s->uvlinesize;
3040         }
3041         //damn interlaced mode
3042         //FIXME boundary mirroring is not exactly correct here
3043         qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3044         qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3045     }
3046     if(!(s->flags&CODEC_FLAG_GRAY)){
3047         pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3048         pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3049     }
3050 }
3051
3052 inline int ff_h263_round_chroma(int x){
3053     if (x >= 0)
3054         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3055     else {
3056         x = -x;
3057         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3058     }
3059 }
3060
3061 /**
3062  * h263 chorma 4mv motion compensation.
3063  */
3064 static inline void chroma_4mv_motion(MpegEncContext *s,
3065                                      uint8_t *dest_cb, uint8_t *dest_cr,
3066                                      uint8_t **ref_picture,
3067                                      op_pixels_func *pix_op,
3068                                      int mx, int my){
3069     int dxy, emu=0, src_x, src_y, offset;
3070     uint8_t *ptr;
3071     
3072     /* In case of 8X8, we construct a single chroma motion vector
3073        with a special rounding */
3074     mx= ff_h263_round_chroma(mx);
3075     my= ff_h263_round_chroma(my);
3076     
3077     dxy = ((my & 1) << 1) | (mx & 1);
3078     mx >>= 1;
3079     my >>= 1;
3080
3081     src_x = s->mb_x * 8 + mx;
3082     src_y = s->mb_y * 8 + my;
3083     src_x = clip(src_x, -8, s->width/2);
3084     if (src_x == s->width/2)
3085         dxy &= ~1;
3086     src_y = clip(src_y, -8, s->height/2);
3087     if (src_y == s->height/2)
3088         dxy &= ~2;
3089     
3090     offset = (src_y * (s->uvlinesize)) + src_x;
3091     ptr = ref_picture[1] + offset;
3092     if(s->flags&CODEC_FLAG_EMU_EDGE){
3093         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3094            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3095             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
3096             ptr= s->edge_emu_buffer;
3097             emu=1;
3098         }
3099     }
3100     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3101
3102     ptr = ref_picture[2] + offset;
3103     if(emu){
3104         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
3105         ptr= s->edge_emu_buffer;
3106     }
3107     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3108 }
3109
3110 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3111                                      uint8_t *dest_cb, uint8_t *dest_cr,
3112                                      uint8_t **ref_picture,
3113                                      h264_chroma_mc_func *pix_op,
3114                                      int mx, int my){
3115     const int lowres= s->avctx->lowres;
3116     const int block_s= 8>>lowres;
3117     const int s_mask= (2<<lowres)-1;
3118     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3119     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3120     int emu=0, src_x, src_y, offset, sx, sy;
3121     uint8_t *ptr;
3122     
3123     if(s->quarter_sample){
3124         mx/=2;
3125         my/=2;
3126     }
3127
3128     /* In case of 8X8, we construct a single chroma motion vector
3129        with a special rounding */
3130     mx= ff_h263_round_chroma(mx);
3131     my= ff_h263_round_chroma(my);
3132     
3133     sx= mx & s_mask;
3134     sy= my & s_mask;
3135     src_x = s->mb_x*block_s + (mx >> (lowres+1));
3136     src_y = s->mb_y*block_s + (my >> (lowres+1));
3137     
3138     offset = src_y * s->uvlinesize + src_x;
3139     ptr = ref_picture[1] + offset;
3140     if(s->flags&CODEC_FLAG_EMU_EDGE){
3141         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3142            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3143             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3144             ptr= s->edge_emu_buffer;
3145             emu=1;
3146         }
3147     }     
3148     sx <<= 2 - lowres;
3149     sy <<= 2 - lowres;
3150     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3151           
3152     ptr = ref_picture[2] + offset;
3153     if(emu){
3154         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3155         ptr= s->edge_emu_buffer;
3156     }
3157     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3158 }
3159
3160 /**
3161  * motion compesation of a single macroblock
3162  * @param s context
3163  * @param dest_y luma destination pointer
3164  * @param dest_cb chroma cb/u destination pointer
3165  * @param dest_cr chroma cr/v destination pointer
3166  * @param dir direction (0->forward, 1->backward)
3167  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3168  * @param pic_op halfpel motion compensation function (average or put normally)
3169  * @param pic_op qpel motion compensation function (average or put normally)
3170  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3171  */
3172 static inline void MPV_motion(MpegEncContext *s, 
3173                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3174                               int dir, uint8_t **ref_picture, 
3175                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3176 {
3177     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3178     int mb_x, mb_y, i;
3179     uint8_t *ptr, *dest;
3180
3181     mb_x = s->mb_x;
3182     mb_y = s->mb_y;
3183
3184     if(s->obmc && s->pict_type != B_TYPE){
3185         int16_t mv_cache[4][4][2];
3186         const int xy= s->mb_x + s->mb_y*s->mb_stride;
3187         const int mot_stride= s->b8_stride;
3188         const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3189
3190         assert(!s->mb_skiped);
3191                 
3192         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3193         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3194         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3195
3196         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3197             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3198         }else{
3199             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3200         }
3201
3202         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3203             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3204             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3205         }else{
3206             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3207             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3208         }
3209
3210         if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3211             *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3212             *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3213         }else{
3214             *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3215             *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3216         }
3217         
3218         mx = 0;
3219         my = 0;
3220         for(i=0;i<4;i++) {
3221             const int x= (i&1)+1;
3222             const int y= (i>>1)+1;
3223             int16_t mv[5][2]= {
3224                 {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3225                 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3226                 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3227                 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3228                 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3229             //FIXME cleanup
3230             obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3231                         ref_picture[0],
3232                         mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3233                         pix_op[1],
3234                         mv);
3235
3236             mx += mv[0][0];
3237             my += mv[0][1];
3238         }
3239         if(!(s->flags&CODEC_FLAG_GRAY))
3240             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3241
3242         return;
3243     }
3244    
3245     switch(s->mv_type) {
3246     case MV_TYPE_16X16:
3247 #ifdef CONFIG_RISKY
3248         if(s->mcsel){
3249             if(s->real_sprite_warping_points==1){
3250                 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3251                             ref_picture);
3252             }else{
3253                 gmc_motion(s, dest_y, dest_cb, dest_cr,
3254                             ref_picture);
3255             }
3256         }else if(s->quarter_sample){
3257             qpel_motion(s, dest_y, dest_cb, dest_cr, 
3258                         0, 0, 0,
3259                         ref_picture, pix_op, qpix_op,
3260                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3261         }else if(s->mspel){
3262             ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3263                         ref_picture, pix_op,
3264                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3265         }else
3266 #endif
3267         {
3268             mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3269                         0, 0, 0,
3270                         ref_picture, pix_op,
3271                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3272         }           
3273         break;
3274     case MV_TYPE_8X8:
3275         mx = 0;
3276         my = 0;
3277         if(s->quarter_sample){
3278             for(i=0;i<4;i++) {
3279                 motion_x = s->mv[dir][i][0];
3280                 motion_y = s->mv[dir][i][1];
3281
3282                 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3283                 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3284                 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3285                     
3286                 /* WARNING: do no forget half pels */
3287                 src_x = clip(src_x, -16, s->width);
3288                 if (src_x == s->width)
3289                     dxy &= ~3;
3290                 src_y = clip(src_y, -16, s->height);
3291                 if (src_y == s->height)
3292                     dxy &= ~12;
3293                     
3294                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3295                 if(s->flags&CODEC_FLAG_EMU_EDGE){
3296                     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
3297                        || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3298                         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
3299                         ptr= s->edge_emu_buffer;
3300                     }
3301                 }
3302                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3303                 qpix_op[1][dxy](dest, ptr, s->linesize);
3304
3305                 mx += s->mv[dir][i][0]/2;
3306                 my += s->mv[dir][i][1]/2;
3307             }
3308         }else{
3309             for(i=0;i<4;i++) {
3310                 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3311                             ref_picture[0], 0, 0,
3312                             mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3313                             s->width, s->height, s->linesize,
3314                             s->h_edge_pos, s->v_edge_pos,
3315                             8, 8, pix_op[1],
3316                             s->mv[dir][i][0], s->mv[dir][i][1]);
3317
3318                 mx += s->mv[dir][i][0];
3319                 my += s->mv[dir][i][1];
3320             }
3321         }
3322
3323         if(!(s->flags&CODEC_FLAG_GRAY))
3324             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3325         break;
3326     case MV_TYPE_FIELD:
3327         if (s->picture_structure == PICT_FRAME) {
3328             if(s->quarter_sample){
3329                 for(i=0; i<2; i++){
3330                     qpel_motion(s, dest_y, dest_cb, dest_cr,
3331                                 1, i, s->field_select[dir][i],
3332                                 ref_picture, pix_op, qpix_op,
3333                                 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3334                 }
3335             }else{
3336                 /* top field */       
3337                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3338                             1, 0, s->field_select[dir][0],
3339                             ref_picture, pix_op,
3340                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
3341                 /* bottom field */
3342                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3343                             1, 1, s->field_select[dir][1],
3344                             ref_picture, pix_op,
3345                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
3346             }
3347         } else {
3348             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3349                 ref_picture= s->current_picture_ptr->data;
3350             } 
3351
3352             mpeg_motion(s, dest_y, dest_cb, dest_cr,
3353                         0, 0, s->field_select[dir][0],
3354                         ref_picture, pix_op,
3355                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3356         }
3357         break;
3358     case MV_TYPE_16X8:
3359         for(i=0; i<2; i++){
3360             uint8_t ** ref2picture;
3361
3362             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3363                 ref2picture= ref_picture;
3364             }else{
3365                 ref2picture= s->current_picture_ptr->data;
3366             } 
3367
3368             mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3369                         0, 0, s->field_select[dir][i],
3370                         ref2picture, pix_op,
3371                         s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3372                 
3373             dest_y += 16*s->linesize;
3374             dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3375             dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3376         }        
3377         break;
3378     case MV_TYPE_DMV:
3379         if(s->picture_structure == PICT_FRAME){
3380             for(i=0; i<2; i++){
3381                 int j;
3382                 for(j=0; j<2; j++){
3383                     mpeg_motion(s, dest_y, dest_cb, dest_cr,
3384                                 1, j, j^i,
3385                                 ref_picture, pix_op,
3386                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3387                 }
3388                 pix_op = s->dsp.avg_pixels_tab; 
3389             }
3390         }else{
3391             for(i=0; i<2; i++){
3392                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3393                             0, 0, s->picture_structure != i+1,
3394                             ref_picture, pix_op,
3395                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3396
3397                 // after put we make avg of the same block
3398                 pix_op=s->dsp.avg_pixels_tab; 
3399
3400                 //opposite parity is always in the same frame if this is second field
3401                 if(!s->first_field){
3402                     ref_picture = s->current_picture_ptr->data;    
3403                 }
3404             }
3405         }
3406     break;
3407     default: assert(0);
3408     }
3409 }
3410
3411 /**
3412  * motion compesation of a single macroblock
3413  * @param s context
3414  * @param dest_y luma destination pointer
3415  * @param dest_cb chroma cb/u destination pointer
3416  * @param dest_cr chroma cr/v destination pointer
3417  * @param dir direction (0->forward, 1->backward)
3418  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3419  * @param pic_op halfpel motion compensation function (average or put normally)
3420  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3421  */
3422 static inline void MPV_motion_lowres(MpegEncContext *s, 
3423                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3424                               int dir, uint8_t **ref_picture, 
3425                               h264_chroma_mc_func *pix_op)
3426 {
3427     int mx, my;
3428     int mb_x, mb_y, i;
3429     const int lowres= s->avctx->lowres;
3430     const int block_s= 8>>lowres;    
3431
3432     mb_x = s->mb_x;
3433     mb_y = s->mb_y;
3434
3435     switch(s->mv_type) {
3436     case MV_TYPE_16X16:
3437         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3438                     0, 0, 0,
3439                     ref_picture, pix_op,
3440                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3441         break;
3442     case MV_TYPE_8X8:
3443         mx = 0;
3444         my = 0;
3445             for(i=0;i<4;i++) {
3446                 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3447                             ref_picture[0], 0, 0,
3448                             (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3449                             s->width, s->height, s->linesize,
3450                             s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3451                             block_s, block_s, pix_op,
3452                             s->mv[dir][i][0], s->mv[dir][i][1]);
3453
3454                 mx += s->mv[dir][i][0];
3455                 my += s->mv[dir][i][1];
3456             }
3457
3458         if(!(s->flags&CODEC_FLAG_GRAY))
3459             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3460         break;
3461     case MV_TYPE_FIELD:
3462         if (s->picture_structure == PICT_FRAME) {
3463             /* top field */       
3464             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3465                         1, 0, s->field_select[dir][0],
3466                         ref_picture, pix_op,
3467                         s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3468             /* bottom field */
3469             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3470                         1, 1, s->field_select[dir][1],
3471                         ref_picture, pix_op,
3472                         s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3473         } else {
3474             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3475                 ref_picture= s->current_picture_ptr->data;
3476             } 
3477
3478             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3479                         0, 0, s->field_select[dir][0],
3480                         ref_picture, pix_op,
3481                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3482         }
3483         break;
3484     case MV_TYPE_16X8:
3485         for(i=0; i<2; i++){
3486             uint8_t ** ref2picture;
3487
3488             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3489                 ref2picture= ref_picture;
3490             }else{
3491                 ref2picture= s->current_picture_ptr->data;
3492             } 
3493
3494             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3495                         0, 0, s->field_select[dir][i],
3496                         ref2picture, pix_op,
3497                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3498                 
3499             dest_y += 2*block_s*s->linesize;
3500             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3501             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3502         }        
3503         break;
3504     case MV_TYPE_DMV:
3505         if(s->picture_structure == PICT_FRAME){
3506             for(i=0; i<2; i++){
3507                 int j;
3508                 for(j=0; j<2; j++){
3509                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3510                                 1, j, j^i,
3511                                 ref_picture, pix_op,
3512                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3513                 }
3514                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3515             }
3516         }else{
3517             for(i=0; i<2; i++){
3518                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3519                             0, 0, s->picture_structure != i+1,
3520                             ref_picture, pix_op,
3521                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3522
3523                 // after put we make avg of the same block
3524                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3525
3526                 //opposite parity is always in the same frame if this is second field
3527                 if(!s->first_field){
3528                     ref_picture = s->current_picture_ptr->data;    
3529                 }
3530             }
3531         }
3532     break;
3533     default: assert(0);
3534     }
3535 }
3536
3537 /* put block[] to dest[] */
3538 static inline void put_dct(MpegEncContext *s, 
3539                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3540 {
3541     s->dct_unquantize_intra(s, block, i, qscale);
3542     s->dsp.idct_put (dest, line_size, block);
3543 }
3544
3545 /* add block[] to dest[] */
3546 static inline void add_dct(MpegEncContext *s, 
3547                            DCTELEM *block, int i, uint8_t *dest, int line_size)
3548 {
3549     if (s->block_last_index[i] >= 0) {
3550         s->dsp.idct_add (dest, line_size, block);
3551     }
3552 }
3553
3554 static inline void add_dequant_dct(MpegEncContext *s, 
3555                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3556 {
3557     if (s->block_last_index[i] >= 0) {
3558         s->dct_unquantize_inter(s, block, i, qscale);
3559
3560         s->dsp.idct_add (dest, line_size, block);
3561     }
3562 }
3563
3564 /**
3565  * cleans dc, ac, coded_block for the current non intra MB
3566  */
3567 void ff_clean_intra_table_entries(MpegEncContext *s)
3568 {
3569     int wrap = s->b8_stride;
3570     int xy = s->block_index[0];
3571     
3572     s->dc_val[0][xy           ] = 
3573     s->dc_val[0][xy + 1       ] = 
3574     s->dc_val[0][xy     + wrap] =
3575     s->dc_val[0][xy + 1 + wrap] = 1024;
3576     /* ac pred */
3577     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3578     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3579     if (s->msmpeg4_version>=3) {
3580         s->coded_block[xy           ] =
3581         s->coded_block[xy + 1       ] =
3582         s->coded_block[xy     + wrap] =
3583         s->coded_block[xy + 1 + wrap] = 0;
3584     }
3585     /* chroma */
3586     wrap = s->mb_stride;
3587     xy = s->mb_x + s->mb_y * wrap;
3588     s->dc_val[1][xy] =
3589     s->dc_val[2][xy] = 1024;
3590     /* ac pred */
3591     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3592     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3593     
3594     s->mbintra_table[xy]= 0;
3595 }
3596
3597 /* generic function called after a macroblock has been parsed by the
3598    decoder or after it has been encoded by the encoder.
3599
3600    Important variables used:
3601    s->mb_intra : true if intra macroblock
3602    s->mv_dir   : motion vector direction
3603    s->mv_type  : motion vector type
3604    s->mv       : motion vector
3605    s->interlaced_dct : true if interlaced dct used (mpeg2)
3606  */
3607 static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3608 {
3609     int mb_x, mb_y;
3610     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3611 #ifdef HAVE_XVMC
3612     if(s->avctx->xvmc_acceleration){
3613         XVMC_decode_mb(s);//xvmc uses pblocks
3614         return;
3615     }
3616 #endif
3617
3618     mb_x = s->mb_x;
3619     mb_y = s->mb_y;
3620
3621     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3622        /* save DCT coefficients */
3623        int i,j;
3624        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3625        for(i=0; i<6; i++)
3626            for(j=0; j<64; j++)
3627                *dct++ = block[i][s->dsp.idct_permutation[j]];
3628     }
3629
3630     s->current_picture.qscale_table[mb_xy]= s->qscale;
3631
3632     /* update DC predictors for P macroblocks */
3633     if (!s->mb_intra) {
3634         if (s->h263_pred || s->h263_aic) {
3635             if(s->mbintra_table[mb_xy])
3636                 ff_clean_intra_table_entries(s);
3637         } else {
3638             s->last_dc[0] =
3639             s->last_dc[1] =
3640             s->last_dc[2] = 128 << s->intra_dc_precision;
3641         }
3642     }
3643     else if (s->h263_pred || s->h263_aic)
3644         s->mbintra_table[mb_xy]=1;
3645
3646     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3647         uint8_t *dest_y, *dest_cb, *dest_cr;
3648         int dct_linesize, dct_offset;
3649         op_pixels_func (*op_pix)[4];
3650         qpel_mc_func (*op_qpix)[16];
3651         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3652         const int uvlinesize= s->current_picture.linesize[1];
3653         const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3654         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3655
3656         /* avoid copy if macroblock skipped in last frame too */
3657         /* skip only during decoding as we might trash the buffers during encoding a bit */
3658         if(!s->encoding){
3659             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3660             const int age= s->current_picture.age;
3661
3662             assert(age);
3663
3664             if (s->mb_skiped) {
3665                 s->mb_skiped= 0;
3666                 assert(s->pict_type!=I_TYPE);
3667  
3668                 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3669                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3670
3671                 /* if previous was skipped too, then nothing to do !  */
3672                 if (*mbskip_ptr >= age && s->current_picture.reference){
3673                     return;
3674                 }
3675             } else if(!s->current_picture.reference){
3676                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3677                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3678             } else{
3679                 *mbskip_ptr = 0; /* not skipped */
3680             }
3681         }
3682         
3683         dct_linesize = linesize << s->interlaced_dct;
3684         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3685         
3686         if(readable){
3687             dest_y=  s->dest[0];
3688             dest_cb= s->dest[1];
3689             dest_cr= s->dest[2];
3690         }else{
3691             dest_y = s->b_scratchpad;
3692             dest_cb= s->b_scratchpad+16*linesize;
3693             dest_cr= s->b_scratchpad+32*linesize;
3694         }
3695
3696         if (!s->mb_intra) {
3697             /* motion handling */
3698             /* decoding or more than one mb_type (MC was allready done otherwise) */
3699             if(!s->encoding){
3700                 if(lowres_flag){
3701                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3702
3703                     if (s->mv_dir & MV_DIR_FORWARD) {
3704                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3705                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3706                     }
3707                     if (s->mv_dir & MV_DIR_BACKWARD) {
3708                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3709                     }
3710                 }else{
3711                     if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3712                         op_pix = s->dsp.put_pixels_tab;
3713                         op_qpix= s->dsp.put_qpel_pixels_tab;
3714                     }else{
3715                         op_pix = s->dsp.put_no_rnd_pixels_tab;
3716                         op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3717                     }
3718                     if (s->mv_dir & MV_DIR_FORWARD) {
3719                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3720                         op_pix = s->dsp.avg_pixels_tab;
3721                         op_qpix= s->dsp.avg_qpel_pixels_tab;
3722                     }
3723                     if (s->mv_dir & MV_DIR_BACKWARD) {
3724                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3725                     }
3726                 }
3727             }
3728
3729             /* skip dequant / idct if we are really late ;) */
3730             if(s->hurry_up>1) return;
3731
3732             /* add dct residue */
3733             if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3734                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3735                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3736                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3737                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3738                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3739
3740                 if(!(s->flags&CODEC_FLAG_GRAY)){
3741                     add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3742                     add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3743                 }
3744             } else if(s->codec_id != CODEC_ID_WMV2){
3745                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3746                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3747                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3748                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3749
3750                 if(!(s->flags&CODEC_FLAG_GRAY)){
3751                     if(s->chroma_y_shift){//Chroma420
3752                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
3753                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
3754                     }else{
3755                         //chroma422
3756                         dct_linesize = uvlinesize << s->interlaced_dct;
3757                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3758
3759                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
3760                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
3761                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3762                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3763                         if(!s->chroma_x_shift){//Chroma444
3764                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3765                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3766                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3767                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3768                         }
3769                     }
3770                 }//fi gray
3771             }
3772 #ifdef CONFIG_RISKY
3773             else{
3774                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3775             }
3776 #endif
3777         } else {
3778             /* dct only in intra block */
3779             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3780                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3781                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3782                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3783                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3784
3785                 if(!(s->flags&CODEC_FLAG_GRAY)){
3786                     put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3787                     put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3788                 }
3789             }else{
3790                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3791                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3792                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3793                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3794
3795                 if(!(s->flags&CODEC_FLAG_GRAY)){
3796                     if(s->chroma_y_shift){
3797                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3798                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3799                     }else{
3800
3801                         dct_linesize = uvlinesize << s->interlaced_dct;
3802                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3803
3804                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3805                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3806                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3807                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3808                         if(!s->chroma_x_shift){//Chroma444
3809                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3810                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3811                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3812                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3813                         }
3814                     }
3815                 }//gray
3816             }
3817         }
3818         if(!readable){
3819             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3820             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3821             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3822         }
3823     }
3824 }
3825
3826 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3827     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3828     else                  MPV_decode_mb_internal(s, block, 0);
3829 }
3830
3831 #ifdef CONFIG_ENCODERS
3832
3833 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3834 {
3835     static const char tab[64]=
3836         {3,2,2,1,1,1,1,1,
3837          1,1,1,1,1,1,1,1,
3838          1,1,1,1,1,1,1,1,
3839          0,0,0,0,0,0,0,0,
3840          0,0,0,0,0,0,0,0,
3841          0,0,0,0,0,0,0,0,
3842          0,0,0,0,0,0,0,0,
3843          0,0,0,0,0,0,0,0};
3844     int score=0;
3845     int run=0;
3846     int i;
3847     DCTELEM *block= s->block[n];
3848     const int last_index= s->block_last_index[n];
3849     int skip_dc;
3850
3851     if(threshold<0){
3852         skip_dc=0;
3853         threshold= -threshold;
3854     }else
3855         skip_dc=1;
3856
3857     /* are all which we could set to zero are allready zero? */
3858     if(last_index<=skip_dc - 1) return;
3859
3860     for(i=0; i<=last_index; i++){
3861         const int j = s->intra_scantable.permutated[i];
3862         const int level = ABS(block[j]);
3863         if(level==1){
3864             if(skip_dc && i==0) continue;
3865             score+= tab[run];
3866             run=0;
3867         }else if(level>1){
3868             return;
3869         }else{
3870             run++;
3871         }
3872     }
3873     if(score >= threshold) return;
3874     for(i=skip_dc; i<=last_index; i++){
3875         const int j = s->intra_scantable.permutated[i];
3876         block[j]=0;
3877     }
3878     if(block[0]) s->block_last_index[n]= 0;
3879     else         s->block_last_index[n]= -1;
3880 }
3881
3882 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3883 {
3884     int i;
3885     const int maxlevel= s->max_qcoeff;
3886     const int minlevel= s->min_qcoeff;
3887     int overflow=0;
3888     
3889     if(s->mb_intra){
3890         i=1; //skip clipping of intra dc
3891     }else
3892         i=0;
3893     
3894     for(;i<=last_index; i++){
3895         const int j= s->intra_scantable.permutated[i];
3896         int level = block[j];
3897        
3898         if     (level>maxlevel){
3899             level=maxlevel;
3900             overflow++;
3901         }else if(level<minlevel){
3902             level=minlevel;
3903             overflow++;
3904         }
3905         
3906         block[j]= level;
3907     }
3908     
3909     if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3910         av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3911 }
3912
3913 #endif //CONFIG_ENCODERS
3914
3915 /**
3916  *
3917  * @param h is the normal height, this will be reduced automatically if needed for the last row
3918  */
3919 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3920     if (s->avctx->draw_horiz_band) {
3921         AVFrame *src;
3922         int offset[4];
3923         
3924         if(s->picture_structure != PICT_FRAME){
3925             h <<= 1;
3926             y <<= 1;
3927             if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3928         }
3929
3930         h= FFMIN(h, s->avctx->height - y);
3931
3932         if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3933             src= (AVFrame*)s->current_picture_ptr;
3934         else if(s->last_picture_ptr)
3935             src= (AVFrame*)s->last_picture_ptr;
3936         else
3937             return;
3938             
3939         if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3940             offset[0]=
3941             offset[1]=
3942             offset[2]=
3943             offset[3]= 0;
3944         }else{
3945             offset[0]= y * s->linesize;;
3946             offset[1]= 
3947             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3948             offset[3]= 0;
3949         }
3950
3951         emms_c();
3952
3953         s->avctx->draw_horiz_band(s->avctx, src, offset,
3954                                   y, s->picture_structure, h);
3955     }
3956 }
3957
3958 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3959     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3960     const int uvlinesize= s->current_picture.linesize[1];
3961     const int mb_size= 4 - s->avctx->lowres;
3962         
3963     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3964     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3965     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3966     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3967     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3968     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;
3969     //block_index is not used by mpeg2, so it is not affected by chroma_format
3970
3971     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
3972     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3973     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3974
3975     if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3976     {
3977         s->dest[0] += s->mb_y *   linesize << mb_size;
3978         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3979         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3980     }
3981 }
3982
3983 #ifdef CONFIG_ENCODERS
3984
3985 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3986     int x, y;
3987 //FIXME optimize
3988     for(y=0; y<8; y++){
3989         for(x=0; x<8; x++){
3990             int x2, y2;
3991             int sum=0;
3992             int sqr=0;
3993             int count=0;
3994
3995             for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3996                 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3997                     int v= ptr[x2 + y2*stride];
3998                     sum += v;
3999                     sqr += v*v;
4000                     count++;
4001                 }
4002             }
4003             weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4004         }
4005     }
4006 }
4007
4008 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4009 {
4010     int16_t weight[6][64];
4011     DCTELEM orig[6][64];
4012     const int mb_x= s->mb_x;
4013     const int mb_y= s->mb_y;
4014     int i;
4015     int skip_dct[6];
4016     int dct_offset   = s->linesize*8; //default for progressive frames
4017     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4018     int wrap_y, wrap_c;
4019     
4020     for(i=0; i<6; i++) skip_dct[i]=0;
4021     
4022     if(s->adaptive_quant){
4023         const int last_qp= s->qscale;
4024    &n