remove superfluous CONFIG_ENCODERS (entire function is already wrapped)
[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 //CONFIG_ENCODERS
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+4)  * sizeof(int16_t))
389                 pic->motion_val[i]= pic->motion_val_base[i]+4;
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+4) * sizeof(int16_t))
396                 pic->motion_val[i]= pic->motion_val_base[i]+4;
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     if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUV420P){
896         av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
897         return -1;
898     }
899
900     if(avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG){
901         if(avctx->strict_std_compliance>=0 && avctx->pix_fmt != PIX_FMT_YUVJ420P){
902             av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
903             return -1;
904         }
905     }else{
906         if(avctx->strict_std_compliance>=0 && avctx->pix_fmt != PIX_FMT_YUV420P){
907             av_log(avctx, AV_LOG_ERROR, "colorspace not supported\n");
908             return -1;
909         }
910     }
911
912     s->bit_rate = avctx->bit_rate;
913     s->width = avctx->width;
914     s->height = avctx->height;
915     if(avctx->gop_size > 600){
916         av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
917         avctx->gop_size=600;
918     }
919     s->gop_size = avctx->gop_size;
920     s->avctx = avctx;
921     s->flags= avctx->flags;
922     s->flags2= avctx->flags2;
923     s->max_b_frames= avctx->max_b_frames;
924     s->codec_id= avctx->codec->id;
925     s->luma_elim_threshold  = avctx->luma_elim_threshold;
926     s->chroma_elim_threshold= avctx->chroma_elim_threshold;
927     s->strict_std_compliance= avctx->strict_std_compliance;
928     s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
929     s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
930     s->mpeg_quant= avctx->mpeg_quant;
931     s->rtp_mode= !!avctx->rtp_payload_size;
932     s->intra_dc_precision= avctx->intra_dc_precision;
933     s->user_specified_pts = AV_NOPTS_VALUE;
934
935     if (s->gop_size <= 1) {
936         s->intra_only = 1;
937         s->gop_size = 12;
938     } else {
939         s->intra_only = 0;
940     }
941
942     s->me_method = avctx->me_method;
943
944     /* Fixed QSCALE */
945     s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
946     
947     s->adaptive_quant= (   s->avctx->lumi_masking
948                         || s->avctx->dark_masking
949                         || s->avctx->temporal_cplx_masking 
950                         || s->avctx->spatial_cplx_masking
951                         || s->avctx->p_masking
952                         || s->avctx->border_masking
953                         || (s->flags&CODEC_FLAG_QP_RD))
954                        && !s->fixed_qscale;
955     
956     s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
957     s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
958     s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
959
960     if(avctx->rc_max_rate && !avctx->rc_buffer_size){
961         av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
962         return -1;
963     }    
964
965     if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
966         av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
967     }
968     
969     if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
970         av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
971         return -1;
972     }
973     
974     if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
975         av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
976         return -1;
977     }
978         
979     if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate 
980        && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
981        && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
982         
983         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");
984     }
985        
986     if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
987        && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
988         av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
989         return -1;
990     }
991         
992     if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
993         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
994         return -1;
995     }
996     
997     if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
998         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
999         return -1;
1000     }
1001     
1002     if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1003         av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1004         return -1;
1005     }
1006
1007     if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1008         av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1009         return -1;
1010     }
1011     
1012     if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1013         av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1014         return -1;
1015     }
1016
1017     if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) 
1018        && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1019         av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1020         return -1;
1021     }
1022         
1023     if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1024         av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
1025         return -1;
1026     }
1027         
1028     if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1029         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1030         return -1;
1031     }
1032
1033     if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1034         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1035         return -1;
1036     }
1037     
1038     if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1039         av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1040         return -1;
1041     }
1042     
1043     if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 
1044        && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO 
1045        && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1046         av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1047         return -1;
1048     }
1049     
1050     if(s->avctx->thread_count > 1)
1051         s->rtp_mode= 1;
1052
1053     if(!avctx->frame_rate || !avctx->frame_rate_base){
1054         av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1055         return -1;
1056     }
1057     
1058     i= (INT_MAX/2+128)>>8;
1059     if(avctx->me_threshold >= i){
1060         av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1061         return -1;
1062     }
1063     if(avctx->mb_threshold >= i){
1064         av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1065         return -1;
1066     }
1067         
1068     i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1069     if(i > 1){
1070         av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1071         avctx->frame_rate /= i;
1072         avctx->frame_rate_base /= i;
1073 //        return -1;
1074     }
1075     
1076     if(s->codec_id==CODEC_ID_MJPEG){
1077         s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1078         s->inter_quant_bias= 0;
1079     }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1080         s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1081         s->inter_quant_bias= 0;
1082     }else{
1083         s->intra_quant_bias=0;
1084         s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1085     }
1086     
1087     if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1088         s->intra_quant_bias= avctx->intra_quant_bias;
1089     if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1090         s->inter_quant_bias= avctx->inter_quant_bias;
1091         
1092     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1093
1094     av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1095     s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1096
1097     switch(avctx->codec->id) {
1098     case CODEC_ID_MPEG1VIDEO:
1099         s->out_format = FMT_MPEG1;
1100         s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1101         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1102         break;
1103     case CODEC_ID_MPEG2VIDEO:
1104         s->out_format = FMT_MPEG1;
1105         s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1106         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1107         s->rtp_mode= 1;
1108         break;
1109     case CODEC_ID_LJPEG:
1110     case CODEC_ID_MJPEG:
1111         s->out_format = FMT_MJPEG;
1112         s->intra_only = 1; /* force intra only for jpeg */
1113         s->mjpeg_write_tables = 1; /* write all tables */
1114         s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1115         s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1116         s->mjpeg_vsample[1] = 1;
1117         s->mjpeg_vsample[2] = 1; 
1118         s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1119         s->mjpeg_hsample[1] = 1; 
1120         s->mjpeg_hsample[2] = 1; 
1121         if (mjpeg_init(s) < 0)
1122             return -1;
1123         avctx->delay=0;
1124         s->low_delay=1;
1125         break;
1126     case CODEC_ID_H261:
1127         s->out_format = FMT_H261;
1128         avctx->delay=0;
1129         s->low_delay=1;
1130         break;
1131     case CODEC_ID_H263:
1132         if (h263_get_picture_format(s->width, s->height) == 7) {
1133             av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1134             return -1;
1135         }
1136         s->out_format = FMT_H263;
1137         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1138         avctx->delay=0;
1139         s->low_delay=1;
1140         break;
1141     case CODEC_ID_H263P:
1142         s->out_format = FMT_H263;
1143         s->h263_plus = 1;
1144         /* Fx */
1145         s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1146         s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1147         s->modified_quant= s->h263_aic;
1148         s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1149         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1150         s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1151         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1152         s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1153
1154         /* /Fx */
1155         /* These are just to be sure */
1156         avctx->delay=0;
1157         s->low_delay=1;
1158         break;
1159     case CODEC_ID_FLV1:
1160         s->out_format = FMT_H263;
1161         s->h263_flv = 2; /* format = 1; 11-bit codes */
1162         s->unrestricted_mv = 1;
1163         s->rtp_mode=0; /* don't allow GOB */
1164         avctx->delay=0;
1165         s->low_delay=1;
1166         break;
1167     case CODEC_ID_RV10:
1168         s->out_format = FMT_H263;
1169         avctx->delay=0;
1170         s->low_delay=1;
1171         break;
1172     case CODEC_ID_RV20:
1173         s->out_format = FMT_H263;
1174         avctx->delay=0;
1175         s->low_delay=1;
1176         s->modified_quant=1;
1177         s->h263_aic=1;
1178         s->h263_plus=1;
1179         s->loop_filter=1;
1180         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1181         break;
1182     case CODEC_ID_MPEG4:
1183         s->out_format = FMT_H263;
1184         s->h263_pred = 1;
1185         s->unrestricted_mv = 1;
1186         s->low_delay= s->max_b_frames ? 0 : 1;
1187         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1188         break;
1189     case CODEC_ID_MSMPEG4V1:
1190         s->out_format = FMT_H263;
1191         s->h263_msmpeg4 = 1;
1192         s->h263_pred = 1;
1193         s->unrestricted_mv = 1;
1194         s->msmpeg4_version= 1;
1195         avctx->delay=0;
1196         s->low_delay=1;
1197         break;
1198     case CODEC_ID_MSMPEG4V2:
1199         s->out_format = FMT_H263;
1200         s->h263_msmpeg4 = 1;
1201         s->h263_pred = 1;
1202         s->unrestricted_mv = 1;
1203         s->msmpeg4_version= 2;
1204         avctx->delay=0;
1205         s->low_delay=1;
1206         break;
1207     case CODEC_ID_MSMPEG4V3:
1208         s->out_format = FMT_H263;
1209         s->h263_msmpeg4 = 1;
1210         s->h263_pred = 1;
1211         s->unrestricted_mv = 1;
1212         s->msmpeg4_version= 3;
1213         s->flipflop_rounding=1;
1214         avctx->delay=0;
1215         s->low_delay=1;
1216         break;
1217     case CODEC_ID_WMV1:
1218         s->out_format = FMT_H263;
1219         s->h263_msmpeg4 = 1;
1220         s->h263_pred = 1;
1221         s->unrestricted_mv = 1;
1222         s->msmpeg4_version= 4;
1223         s->flipflop_rounding=1;
1224         avctx->delay=0;
1225         s->low_delay=1;
1226         break;
1227     case CODEC_ID_WMV2:
1228         s->out_format = FMT_H263;
1229         s->h263_msmpeg4 = 1;
1230         s->h263_pred = 1;
1231         s->unrestricted_mv = 1;
1232         s->msmpeg4_version= 5;
1233         s->flipflop_rounding=1;
1234         avctx->delay=0;
1235         s->low_delay=1;
1236         break;
1237     default:
1238         return -1;
1239     }
1240     
1241     avctx->has_b_frames= !s->low_delay;
1242
1243     s->encoding = 1;
1244
1245     /* init */
1246     if (MPV_common_init(s) < 0)
1247         return -1;
1248
1249     if(s->modified_quant)
1250         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1251     s->progressive_frame= 
1252     s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1253     s->quant_precision=5;
1254     
1255     ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1256     ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1257     
1258     if (s->out_format == FMT_H261)
1259         ff_h261_encode_init(s);
1260     if (s->out_format == FMT_H263)
1261         h263_encode_init(s);
1262     if(s->msmpeg4_version)
1263         ff_msmpeg4_encode_init(s);
1264     if (s->out_format == FMT_MPEG1)
1265         ff_mpeg1_encode_init(s);
1266
1267     /* init q matrix */
1268     for(i=0;i<64;i++) {
1269         int j= s->dsp.idct_permutation[i];
1270         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1271             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1272             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1273         }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1274             s->intra_matrix[j] =
1275             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1276         }else
1277         { /* mpeg1/2 */
1278             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1279             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1280         }
1281         if(s->avctx->intra_matrix)
1282             s->intra_matrix[j] = s->avctx->intra_matrix[i];
1283         if(s->avctx->inter_matrix)
1284             s->inter_matrix[j] = s->avctx->inter_matrix[i];
1285     }
1286
1287     /* precompute matrix */
1288     /* for mjpeg, we do include qscale in the matrix */
1289     if (s->out_format != FMT_MJPEG) {
1290         convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1291                        s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1292         convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1293                        s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1294     }
1295
1296     if(ff_rate_control_init(s) < 0)
1297         return -1;
1298     
1299     return 0;
1300 }
1301
1302 int MPV_encode_end(AVCodecContext *avctx)
1303 {
1304     MpegEncContext *s = avctx->priv_data;
1305
1306 #ifdef STATS
1307     print_stats();
1308 #endif
1309
1310     ff_rate_control_uninit(s);
1311
1312     MPV_common_end(s);
1313     if (s->out_format == FMT_MJPEG)
1314         mjpeg_close(s);
1315
1316     av_freep(&avctx->extradata);
1317       
1318     return 0;
1319 }
1320
1321 #endif //CONFIG_ENCODERS
1322
1323 void init_rl(RLTable *rl, int use_static)
1324 {
1325     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1326     uint8_t index_run[MAX_RUN+1];
1327     int last, run, level, start, end, i;
1328
1329     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1330     if(use_static && rl->max_level[0])
1331         return;
1332
1333     /* compute max_level[], max_run[] and index_run[] */
1334     for(last=0;last<2;last++) {
1335         if (last == 0) {
1336             start = 0;
1337             end = rl->last;
1338         } else {
1339             start = rl->last;
1340             end = rl->n;
1341         }
1342
1343         memset(max_level, 0, MAX_RUN + 1);
1344         memset(max_run, 0, MAX_LEVEL + 1);
1345         memset(index_run, rl->n, MAX_RUN + 1);
1346         for(i=start;i<end;i++) {
1347             run = rl->table_run[i];
1348             level = rl->table_level[i];
1349             if (index_run[run] == rl->n)
1350                 index_run[run] = i;
1351             if (level > max_level[run])
1352                 max_level[run] = level;
1353             if (run > max_run[level])
1354                 max_run[level] = run;
1355         }
1356         if(use_static)
1357             rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1358         else
1359             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1360         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1361         if(use_static)
1362             rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1363         else
1364             rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1365         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1366         if(use_static)
1367             rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1368         else
1369             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1370         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1371     }
1372 }
1373
1374 /* draw the edges of width 'w' of an image of size width, height */
1375 //FIXME check that this is ok for mpeg4 interlaced
1376 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1377 {
1378     uint8_t *ptr, *last_line;
1379     int i;
1380
1381     last_line = buf + (height - 1) * wrap;
1382     for(i=0;i<w;i++) {
1383         /* top and bottom */
1384         memcpy(buf - (i + 1) * wrap, buf, width);
1385         memcpy(last_line + (i + 1) * wrap, last_line, width);
1386     }
1387     /* left and right */
1388     ptr = buf;
1389     for(i=0;i<height;i++) {
1390         memset(ptr - w, ptr[0], w);
1391         memset(ptr + width, ptr[width-1], w);
1392         ptr += wrap;
1393     }
1394     /* corners */
1395     for(i=0;i<w;i++) {
1396         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1397         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1398         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1399         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1400     }
1401 }
1402
1403 int ff_find_unused_picture(MpegEncContext *s, int shared){
1404     int i;
1405     
1406     if(shared){
1407         for(i=0; i<MAX_PICTURE_COUNT; i++){
1408             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1409         }
1410     }else{
1411         for(i=0; i<MAX_PICTURE_COUNT; i++){
1412             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1413         }
1414         for(i=0; i<MAX_PICTURE_COUNT; i++){
1415             if(s->picture[i].data[0]==NULL) return i;
1416         }
1417     }
1418
1419     assert(0);
1420     return -1;
1421 }
1422
1423 static void update_noise_reduction(MpegEncContext *s){
1424     int intra, i;
1425
1426     for(intra=0; intra<2; intra++){
1427         if(s->dct_count[intra] > (1<<16)){
1428             for(i=0; i<64; i++){
1429                 s->dct_error_sum[intra][i] >>=1;
1430             }
1431             s->dct_count[intra] >>= 1;
1432         }
1433         
1434         for(i=0; i<64; i++){
1435             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);
1436         }
1437     }
1438 }
1439
1440 /**
1441  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1442  */
1443 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1444 {
1445     int i;
1446     AVFrame *pic;
1447     s->mb_skiped = 0;
1448
1449     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1450
1451     /* mark&release old frames */
1452     if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1453         avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1454
1455         /* release forgotten pictures */
1456         /* if(mpeg124/h263) */
1457         if(!s->encoding){
1458             for(i=0; i<MAX_PICTURE_COUNT; i++){
1459                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1460                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1461                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1462                 }
1463             }
1464         }
1465     }
1466 alloc:
1467     if(!s->encoding){
1468         /* release non refernce frames */
1469         for(i=0; i<MAX_PICTURE_COUNT; i++){
1470             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1471                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1472             }
1473         }
1474
1475         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1476             pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1477         else{
1478             i= ff_find_unused_picture(s, 0);
1479             pic= (AVFrame*)&s->picture[i];
1480         }
1481
1482         pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1483                         && !s->dropable ? 3 : 0;
1484
1485         pic->coded_picture_number= s->coded_picture_number++;
1486         
1487         if( alloc_picture(s, (Picture*)pic, 0) < 0)
1488             return -1;
1489
1490         s->current_picture_ptr= (Picture*)pic;
1491         s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1492         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1493     }
1494
1495     s->current_picture_ptr->pict_type= s->pict_type;
1496 //    if(s->flags && CODEC_FLAG_QSCALE) 
1497   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1498     s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1499
1500     copy_picture(&s->current_picture, s->current_picture_ptr);
1501   
1502   if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1503     if (s->pict_type != B_TYPE) {
1504         s->last_picture_ptr= s->next_picture_ptr;
1505         if(!s->dropable)
1506             s->next_picture_ptr= s->current_picture_ptr;
1507     }
1508 /*    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,
1509         s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1510         s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1511         s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1512         s->pict_type, s->dropable);*/
1513     
1514     if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1515     if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1516     
1517     if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1518         av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1519         assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1520         goto alloc;
1521     }
1522
1523     assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1524
1525     if(s->picture_structure!=PICT_FRAME){
1526         int i;
1527         for(i=0; i<4; i++){
1528             if(s->picture_structure == PICT_BOTTOM_FIELD){
1529                  s->current_picture.data[i] += s->current_picture.linesize[i];
1530             } 
1531             s->current_picture.linesize[i] *= 2;
1532             s->last_picture.linesize[i] *=2;
1533             s->next_picture.linesize[i] *=2;
1534         }
1535     }
1536   }
1537    
1538     s->hurry_up= s->avctx->hurry_up;
1539     s->error_resilience= avctx->error_resilience;
1540
1541     /* set dequantizer, we cant do it during init as it might change for mpeg4
1542        and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1543     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1544         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1545         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1546     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1547         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1548         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1549     }else{
1550         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1551         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1552     }
1553
1554     if(s->dct_error_sum){
1555         assert(s->avctx->noise_reduction && s->encoding);
1556
1557         update_noise_reduction(s);
1558     }
1559         
1560 #ifdef HAVE_XVMC
1561     if(s->avctx->xvmc_acceleration)
1562         return XVMC_field_start(s, avctx);
1563 #endif
1564     return 0;
1565 }
1566
1567 /* generic function for encode/decode called after a frame has been coded/decoded */
1568 void MPV_frame_end(MpegEncContext *s)
1569 {
1570     int i;
1571     /* draw edge for correct motion prediction if outside */
1572 #ifdef HAVE_XVMC
1573 //just to make sure that all data is rendered.
1574     if(s->avctx->xvmc_acceleration){
1575         XVMC_field_end(s);
1576     }else
1577 #endif
1578     if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1579             draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1580             draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1581             draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1582     }
1583     emms_c();
1584     
1585     s->last_pict_type    = s->pict_type;
1586     if(s->pict_type!=B_TYPE){
1587         s->last_non_b_pict_type= s->pict_type;
1588     }
1589 #if 0
1590         /* copy back current_picture variables */
1591     for(i=0; i<MAX_PICTURE_COUNT; i++){
1592         if(s->picture[i].data[0] == s->current_picture.data[0]){
1593             s->picture[i]= s->current_picture;
1594             break;
1595         }    
1596     }
1597     assert(i<MAX_PICTURE_COUNT);
1598 #endif    
1599
1600     if(s->encoding){
1601         /* release non refernce frames */
1602         for(i=0; i<MAX_PICTURE_COUNT; i++){
1603             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1604                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1605             }
1606         }
1607     }
1608     // clear copies, to avoid confusion
1609 #if 0
1610     memset(&s->last_picture, 0, sizeof(Picture));
1611     memset(&s->next_picture, 0, sizeof(Picture));
1612     memset(&s->current_picture, 0, sizeof(Picture));
1613 #endif
1614     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1615 }
1616
1617 /**
1618  * draws an line from (ex, ey) -> (sx, sy).
1619  * @param w width of the image
1620  * @param h height of the image
1621  * @param stride stride/linesize of the image
1622  * @param color color of the arrow
1623  */
1624 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1625     int t, x, y, fr, f;
1626     
1627     sx= clip(sx, 0, w-1);
1628     sy= clip(sy, 0, h-1);
1629     ex= clip(ex, 0, w-1);
1630     ey= clip(ey, 0, h-1);
1631     
1632     buf[sy*stride + sx]+= color;
1633     
1634     if(ABS(ex - sx) > ABS(ey - sy)){
1635         if(sx > ex){
1636             t=sx; sx=ex; ex=t;
1637             t=sy; sy=ey; ey=t;
1638         }
1639         buf+= sx + sy*stride;
1640         ex-= sx;
1641         f= ((ey-sy)<<16)/ex;
1642         for(x= 0; x <= ex; x++){
1643             y = (x*f)>>16;
1644             fr= (x*f)&0xFFFF;
1645             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1646             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1647         }
1648     }else{
1649         if(sy > ey){
1650             t=sx; sx=ex; ex=t;
1651             t=sy; sy=ey; ey=t;
1652         }
1653         buf+= sx + sy*stride;
1654         ey-= sy;
1655         if(ey) f= ((ex-sx)<<16)/ey;
1656         else   f= 0;
1657         for(y= 0; y <= ey; y++){
1658             x = (y*f)>>16;
1659             fr= (y*f)&0xFFFF;
1660             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1661             buf[y*stride + x+1]+= (color*         fr )>>16;;
1662         }
1663     }
1664 }
1665
1666 /**
1667  * draws an arrow from (ex, ey) -> (sx, sy).
1668  * @param w width of the image
1669  * @param h height of the image
1670  * @param stride stride/linesize of the image
1671  * @param color color of the arrow
1672  */
1673 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1674     int dx,dy;
1675
1676     sx= clip(sx, -100, w+100);
1677     sy= clip(sy, -100, h+100);
1678     ex= clip(ex, -100, w+100);
1679     ey= clip(ey, -100, h+100);
1680     
1681     dx= ex - sx;
1682     dy= ey - sy;
1683     
1684     if(dx*dx + dy*dy > 3*3){
1685         int rx=  dx + dy;
1686         int ry= -dx + dy;
1687         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1688         
1689         //FIXME subpixel accuracy
1690         rx= ROUNDED_DIV(rx*3<<4, length);
1691         ry= ROUNDED_DIV(ry*3<<4, length);
1692         
1693         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1694         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1695     }
1696     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1697 }
1698
1699 /**
1700  * prints debuging info for the given picture.
1701  */
1702 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1703
1704     if(!pict || !pict->mb_type) return;
1705
1706     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1707         int x,y;
1708         
1709         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1710         switch (pict->pict_type) {
1711             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1712             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1713             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1714             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1715             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1716             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1717         }
1718         for(y=0; y<s->mb_height; y++){
1719             for(x=0; x<s->mb_width; x++){
1720                 if(s->avctx->debug&FF_DEBUG_SKIP){
1721                     int count= s->mbskip_table[x + y*s->mb_stride];
1722                     if(count>9) count=9;
1723                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1724                 }
1725                 if(s->avctx->debug&FF_DEBUG_QP){
1726                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1727                 }
1728                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1729                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1730                     //Type & MV direction
1731                     if(IS_PCM(mb_type))
1732                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1733                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1734                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1735                     else if(IS_INTRA4x4(mb_type))
1736                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1737                     else if(IS_INTRA16x16(mb_type))
1738                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1739                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1740                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1741                     else if(IS_DIRECT(mb_type))
1742                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1743                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1744                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1745                     else if(IS_GMC(mb_type))
1746                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1747                     else if(IS_SKIP(mb_type))
1748                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1749                     else if(!USES_LIST(mb_type, 1))
1750                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1751                     else if(!USES_LIST(mb_type, 0))
1752                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1753                     else{
1754                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1755                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1756                     }
1757                     
1758                     //segmentation
1759                     if(IS_8X8(mb_type))
1760                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1761                     else if(IS_16X8(mb_type))
1762                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1763                     else if(IS_8X16(mb_type))
1764                         av_log(s->avctx, AV_LOG_DEBUG, "¦");
1765                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1766                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1767                     else
1768                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1769                     
1770                         
1771                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1772                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1773                     else
1774                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1775                 }
1776 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1777             }
1778             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1779         }
1780     }
1781
1782     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1783         const int shift= 1 + s->quarter_sample;
1784         int mb_y;
1785         uint8_t *ptr;
1786         int i;
1787         int h_chroma_shift, v_chroma_shift;
1788         const int width = s->avctx->width;
1789         const int height= s->avctx->height;
1790         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1791         const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1792         s->low_delay=0; //needed to see the vectors without trashing the buffers
1793
1794         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1795         for(i=0; i<3; i++){
1796             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1797             pict->data[i]= s->visualization_buffer[i];
1798         }
1799         pict->type= FF_BUFFER_TYPE_COPY;
1800         ptr= pict->data[0];
1801
1802         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1803             int mb_x;
1804             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1805                 const int mb_index= mb_x + mb_y*s->mb_stride;
1806                 if((s->avctx->debug_mv) && pict->motion_val){
1807                   int type;
1808                   for(type=0; type<3; type++){
1809                     int direction = 0;
1810                     switch (type) {
1811                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1812                                 continue;
1813                               direction = 0;
1814                               break;
1815                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1816                                 continue;
1817                               direction = 0;
1818                               break;
1819                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1820                                 continue;
1821                               direction = 1;
1822                               break;
1823                     }
1824                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1825                         continue;
1826
1827                     if(IS_8X8(pict->mb_type[mb_index])){
1828                       int i;
1829                       for(i=0; i<4; i++){
1830                         int sx= mb_x*16 + 4 + 8*(i&1);
1831                         int sy= mb_y*16 + 4 + 8*(i>>1);
1832                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1833                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1834                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1835                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1836                       }
1837                     }else if(IS_16X8(pict->mb_type[mb_index])){
1838                       int i;
1839                       for(i=0; i<2; i++){
1840                         int sx=mb_x*16 + 8;
1841                         int sy=mb_y*16 + 4 + 8*i;
1842                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1843                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1844                         int my=(pict->motion_val[direction][xy][1]>>shift);
1845                         
1846                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1847                             my*=2;
1848                         
1849                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1850                       }
1851                     }else if(IS_8X16(pict->mb_type[mb_index])){
1852                       int i;
1853                       for(i=0; i<2; i++){
1854                         int sx=mb_x*16 + 4 + 8*i;
1855                         int sy=mb_y*16 + 8;
1856                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1857                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1858                         int my=(pict->motion_val[direction][xy][1]>>shift);
1859                         
1860                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1861                             my*=2;
1862                         
1863                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1864                       }
1865                     }else{
1866                       int sx= mb_x*16 + 8;
1867                       int sy= mb_y*16 + 8;
1868                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1869                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1870                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1871                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1872                     }
1873                   }                  
1874                 }
1875                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1876                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1877                     int y;
1878                     for(y=0; y<8; y++){
1879                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1880                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1881                     }
1882                 }
1883                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1884                     int mb_type= pict->mb_type[mb_index];
1885                     uint64_t u,v;
1886                     int y;
1887 #define COLOR(theta, r)\
1888 u= (int)(128 + r*cos(theta*3.141592/180));\
1889 v= (int)(128 + r*sin(theta*3.141592/180));
1890
1891                     
1892                     u=v=128;
1893                     if(IS_PCM(mb_type)){
1894                         COLOR(120,48)
1895                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1896                         COLOR(30,48)
1897                     }else if(IS_INTRA4x4(mb_type)){
1898                         COLOR(90,48)
1899                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1900 //                        COLOR(120,48)
1901                     }else if(IS_DIRECT(mb_type)){
1902                         COLOR(150,48)
1903                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1904                         COLOR(170,48)
1905                     }else if(IS_GMC(mb_type)){
1906                         COLOR(190,48)
1907                     }else if(IS_SKIP(mb_type)){
1908 //                        COLOR(180,48)
1909                     }else if(!USES_LIST(mb_type, 1)){
1910                         COLOR(240,48)
1911                     }else if(!USES_LIST(mb_type, 0)){
1912                         COLOR(0,48)
1913                     }else{
1914                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1915                         COLOR(300,48)
1916                     }
1917
1918                     u*= 0x0101010101010101ULL;
1919                     v*= 0x0101010101010101ULL;
1920                     for(y=0; y<8; y++){
1921                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1922                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1923                     }
1924
1925                     //segmentation
1926                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1927                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1928                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1929                     }
1930                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1931                         for(y=0; y<16; y++)
1932                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1933                     }
1934                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1935                         int dm= 1 << (mv_sample_log2-2);
1936                         for(i=0; i<4; i++){
1937                             int sx= mb_x*16 + 8*(i&1);
1938                             int sy= mb_y*16 + 8*(i>>1);
1939                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1940                             //FIXME bidir
1941                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1942                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1943                                 for(y=0; y<8; y++)
1944                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1945                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1946                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1947                         }
1948                     }
1949                         
1950                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1951                         // hmm
1952                     }
1953                 }
1954                 s->mbskip_table[mb_index]=0;
1955             }
1956         }
1957     }
1958 }
1959
1960 #ifdef CONFIG_ENCODERS
1961
1962 static int get_sae(uint8_t *src, int ref, int stride){
1963     int x,y;
1964     int acc=0;
1965     
1966     for(y=0; y<16; y++){
1967         for(x=0; x<16; x++){
1968             acc+= ABS(src[x+y*stride] - ref);
1969         }
1970     }
1971     
1972     return acc;
1973 }
1974
1975 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1976     int x, y, w, h;
1977     int acc=0;
1978     
1979     w= s->width &~15;
1980     h= s->height&~15;
1981     
1982     for(y=0; y<h; y+=16){
1983         for(x=0; x<w; x+=16){
1984             int offset= x + y*stride;
1985             int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1986             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1987             int sae = get_sae(src + offset, mean, stride);
1988             
1989             acc+= sae + 500 < sad;
1990         }
1991     }
1992     return acc;
1993 }
1994
1995
1996 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1997     AVFrame *pic=NULL;
1998     int64_t pts;
1999     int i;
2000     const int encoding_delay= s->max_b_frames;
2001     int direct=1;
2002     
2003     if(pic_arg){
2004         pts= pic_arg->pts;
2005         pic_arg->display_picture_number= s->input_picture_number++;
2006
2007         if(pts != AV_NOPTS_VALUE){ 
2008             if(s->user_specified_pts != AV_NOPTS_VALUE){
2009                 int64_t time= av_rescale(pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2010                 int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2011             
2012                 if(time <= last){            
2013                     av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pts, s->user_specified_pts);
2014                     return -1;
2015                 }
2016             }
2017             s->user_specified_pts= pts;
2018         }else{
2019             if(s->user_specified_pts != AV_NOPTS_VALUE){
2020                 s->user_specified_pts= 
2021                 pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
2022                 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pts);
2023             }else{
2024                 pts= av_rescale(pic_arg->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
2025             }
2026         }
2027     }
2028
2029   if(pic_arg){
2030     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2031     if(pic_arg->linesize[0] != s->linesize) direct=0;
2032     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2033     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2034   
2035 //    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2036     
2037     if(direct){
2038         i= ff_find_unused_picture(s, 1);
2039
2040         pic= (AVFrame*)&s->picture[i];
2041         pic->reference= 3;
2042     
2043         for(i=0; i<4; i++){
2044             pic->data[i]= pic_arg->data[i];
2045             pic->linesize[i]= pic_arg->linesize[i];
2046         }
2047         alloc_picture(s, (Picture*)pic, 1);
2048     }else{
2049         int offset= 16;
2050         i= ff_find_unused_picture(s, 0);
2051
2052         pic= (AVFrame*)&s->picture[i];
2053         pic->reference= 3;
2054
2055         alloc_picture(s, (Picture*)pic, 0);
2056
2057         if(   pic->data[0] + offset == pic_arg->data[0] 
2058            && pic->data[1] + offset == pic_arg->data[1]
2059            && pic->data[2] + offset == pic_arg->data[2]){
2060        // empty
2061         }else{
2062             int h_chroma_shift, v_chroma_shift;
2063             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2064         
2065             for(i=0; i<3; i++){
2066                 int src_stride= pic_arg->linesize[i];
2067                 int dst_stride= i ? s->uvlinesize : s->linesize;
2068                 int h_shift= i ? h_chroma_shift : 0;
2069                 int v_shift= i ? v_chroma_shift : 0;
2070                 int w= s->width >>h_shift;
2071                 int h= s->height>>v_shift;
2072                 uint8_t *src= pic_arg->data[i];
2073                 uint8_t *dst= pic->data[i] + offset;
2074             
2075                 if(src_stride==dst_stride)
2076                     memcpy(dst, src, src_stride*h);
2077                 else{
2078                     while(h--){
2079                         memcpy(dst, src, w);
2080                         dst += dst_stride;
2081                         src += src_stride;
2082                     }
2083                 }
2084             }
2085         }
2086     }
2087     copy_picture_attributes(s, pic, pic_arg);
2088     pic->pts= pts; //we set this here to avoid modifiying pic_arg
2089   }
2090   
2091     /* shift buffer entries */
2092     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2093         s->input_picture[i-1]= s->input_picture[i];
2094         
2095     s->input_picture[encoding_delay]= (Picture*)pic;
2096
2097     return 0;
2098 }
2099
2100 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2101     int x, y, plane;
2102     int score=0;
2103     int64_t score64=0;
2104
2105     for(plane=0; plane<3; plane++){
2106         const int stride= p->linesize[plane];
2107         const int bw= plane ? 1 : 2;
2108         for(y=0; y<s->mb_height*bw; y++){
2109             for(x=0; x<s->mb_width*bw; x++){
2110                 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);
2111                 
2112                 switch(s->avctx->frame_skip_exp){
2113                     case 0: score= FFMAX(score, v); break;
2114                     case 1: score+= ABS(v);break;
2115                     case 2: score+= v*v;break;
2116                     case 3: score64+= ABS(v*v*(int64_t)v);break;
2117                     case 4: score64+= v*v*(int64_t)(v*v);break;
2118                 }
2119             }
2120         }
2121     }
2122     
2123     if(score) score64= score;
2124
2125     if(score64 < s->avctx->frame_skip_threshold)
2126         return 1;
2127     if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2128         return 1;
2129     return 0;
2130 }
2131
2132 static void select_input_picture(MpegEncContext *s){
2133     int i;
2134
2135     for(i=1; i<MAX_PICTURE_COUNT; i++)
2136         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2137     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2138
2139     /* set next picture types & ordering */
2140     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2141         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2142             s->reordered_input_picture[0]= s->input_picture[0];
2143             s->reordered_input_picture[0]->pict_type= I_TYPE;
2144             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2145         }else{
2146             int b_frames;
2147
2148             if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2149                 if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2150 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2151                 
2152                     if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2153                         for(i=0; i<4; i++)
2154                             s->input_picture[0]->data[i]= NULL;
2155                         s->input_picture[0]->type= 0;            
2156                     }else{
2157                         assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER 
2158                                || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2159             
2160                         s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2161                     }
2162
2163                     goto no_output_pic;
2164                 }
2165             }
2166
2167             if(s->flags&CODEC_FLAG_PASS2){
2168                 for(i=0; i<s->max_b_frames+1; i++){
2169                     int pict_num= s->input_picture[0]->display_picture_number + i;
2170
2171                     if(pict_num >= s->rc_context.num_entries) 
2172                         break;
2173                     if(!s->input_picture[i]){
2174                         s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2175                         break;
2176                     }
2177
2178                     s->input_picture[i]->pict_type= 
2179                         s->rc_context.entry[pict_num].new_pict_type;
2180                 }
2181             }
2182
2183             if(s->avctx->b_frame_strategy==0){
2184                 b_frames= s->max_b_frames;
2185                 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2186             }else if(s->avctx->b_frame_strategy==1){
2187                 for(i=1; i<s->max_b_frames+1; i++){
2188                     if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2189                         s->input_picture[i]->b_frame_score= 
2190                             get_intra_count(s, s->input_picture[i  ]->data[0], 
2191                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
2192                     }
2193                 }
2194                 for(i=0; i<s->max_b_frames; i++){
2195                     if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2196                 }
2197                                 
2198                 b_frames= FFMAX(0, i-1);
2199                 
2200                 /* reset scores */
2201                 for(i=0; i<b_frames+1; i++){
2202                     s->input_picture[i]->b_frame_score=0;
2203                 }
2204             }else{
2205                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2206                 b_frames=0;
2207             }
2208
2209             emms_c();
2210 //static int b_count=0;
2211 //b_count+= b_frames;
2212 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2213
2214             for(i= b_frames - 1; i>=0; i--){
2215                 int type= s->input_picture[i]->pict_type;
2216                 if(type && type != B_TYPE)
2217                     b_frames= i;
2218             }
2219             if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2220                 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2221             }
2222
2223             if(s->picture_in_gop_number + b_frames >= s->gop_size){
2224               if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2225                     b_frames= s->gop_size - s->picture_in_gop_number - 1;
2226               }else{
2227                 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2228                     b_frames=0;
2229                 s->input_picture[b_frames]->pict_type= I_TYPE;
2230               }
2231             }
2232             
2233             if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2234                && b_frames
2235                && s->input_picture[b_frames]->pict_type== I_TYPE)
2236                 b_frames--;
2237
2238             s->reordered_input_picture[0]= s->input_picture[b_frames];
2239             if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2240                 s->reordered_input_picture[0]->pict_type= P_TYPE;
2241             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2242             for(i=0; i<b_frames; i++){
2243                 s->reordered_input_picture[i+1]= s->input_picture[i];
2244                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2245                 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2246             }
2247         }
2248     }
2249 no_output_pic:
2250     if(s->reordered_input_picture[0]){
2251         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2252
2253         copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2254
2255         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2256             // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2257         
2258             int i= ff_find_unused_picture(s, 0);
2259             Picture *pic= &s->picture[i];
2260
2261             /* mark us unused / free shared pic */
2262             for(i=0; i<4; i++)
2263                 s->reordered_input_picture[0]->data[i]= NULL;
2264             s->reordered_input_picture[0]->type= 0;
2265             
2266             pic->reference              = s->reordered_input_picture[0]->reference;
2267             
2268             alloc_picture(s, pic, 0);
2269
2270             copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2271
2272             s->current_picture_ptr= pic;
2273         }else{
2274             // input is not a shared pix -> reuse buffer for current_pix
2275
2276             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2277                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2278             
2279             s->current_picture_ptr= s->reordered_input_picture[0];
2280             for(i=0; i<4; i++){
2281                 s->new_picture.data[i]+=16;
2282             }
2283         }
2284         copy_picture(&s->current_picture, s->current_picture_ptr);
2285     
2286         s->picture_number= s->new_picture.display_picture_number;
2287 //printf("dpn:%d\n", s->picture_number);
2288     }else{
2289        memset(&s->new_picture, 0, sizeof(Picture));
2290     }
2291 }
2292
2293 int MPV_encode_picture(AVCodecContext *avctx,
2294                        unsigned char *buf, int buf_size, void *data)
2295 {
2296     MpegEncContext *s = avctx->priv_data;
2297     AVFrame *pic_arg = data;
2298     int i, stuffing_count;
2299
2300     if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2301         av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2302         return -1;
2303     }
2304     
2305     for(i=0; i<avctx->thread_count; i++){
2306         int start_y= s->thread_context[i]->start_mb_y;
2307         int   end_y= s->thread_context[i]->  end_mb_y;
2308         int h= s->mb_height;
2309         uint8_t *start= buf + buf_size*start_y/h;
2310         uint8_t *end  = buf + buf_size*  end_y/h;
2311
2312         init_put_bits(&s->thread_context[i]->pb, start, end - start);
2313     }
2314
2315     s->picture_in_gop_number++;
2316
2317     if(load_input_picture(s, pic_arg) < 0)
2318         return -1;
2319     
2320     select_input_picture(s);
2321     
2322     /* output? */
2323     if(s->new_picture.data[0]){
2324         s->pict_type= s->new_picture.pict_type;
2325 //emms_c();
2326 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2327         MPV_frame_start(s, avctx);
2328
2329         encode_picture(s, s->picture_number);
2330         
2331         avctx->real_pict_num  = s->picture_number;
2332         avctx->header_bits = s->header_bits;
2333         avctx->mv_bits     = s->mv_bits;
2334         avctx->misc_bits   = s->misc_bits;
2335         avctx->i_tex_bits  = s->i_tex_bits;
2336         avctx->p_tex_bits  = s->p_tex_bits;
2337         avctx->i_count     = s->i_count;
2338         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2339         avctx->skip_count  = s->skip_count;
2340
2341         MPV_frame_end(s);
2342
2343         if (s->out_format == FMT_MJPEG)
2344             mjpeg_picture_trailer(s);
2345         
2346         if(s->flags&CODEC_FLAG_PASS1)
2347             ff_write_pass1_stats(s);
2348
2349         for(i=0; i<4; i++){
2350             avctx->error[i] += s->current_picture_ptr->error[i];
2351         }
2352
2353         if(s->flags&CODEC_FLAG_PASS1)
2354             assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2355         flush_put_bits(&s->pb);
2356         s->frame_bits  = put_bits_count(&s->pb);
2357
2358         stuffing_count= ff_vbv_update(s, s->frame_bits);
2359         if(stuffing_count){
2360             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2361                 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2362                 return -1;
2363             }
2364
2365             switch(s->codec_id){
2366             case CODEC_ID_MPEG1VIDEO:
2367             case CODEC_ID_MPEG2VIDEO:
2368                 while(stuffing_count--){
2369                     put_bits(&s->pb, 8, 0);
2370                 }
2371             break;
2372             case CODEC_ID_MPEG4:
2373                 put_bits(&s->pb, 16, 0);
2374                 put_bits(&s->pb, 16, 0x1C3);
2375                 stuffing_count -= 4;
2376                 while(stuffing_count--){
2377                     put_bits(&s->pb, 8, 0xFF);
2378                 }
2379             break;
2380             default:
2381                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2382             }
2383             flush_put_bits(&s->pb);
2384             s->frame_bits  = put_bits_count(&s->pb);
2385         }
2386
2387         /* update mpeg1/2 vbv_delay for CBR */    
2388         if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2389            && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2390             int vbv_delay;
2391
2392             assert(s->repeat_first_field==0);
2393             
2394             vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2395             assert(vbv_delay < 0xFFFF);
2396
2397             s->vbv_delay_ptr[0] &= 0xF8;
2398             s->vbv_delay_ptr[0] |= vbv_delay>>13;
2399             s->vbv_delay_ptr[1]  = vbv_delay>>5;
2400             s->vbv_delay_ptr[2] &= 0x07;
2401             s->vbv_delay_ptr[2] |= vbv_delay<<3;
2402         }
2403         s->total_bits += s->frame_bits;
2404         avctx->frame_bits  = s->frame_bits;
2405     }else{
2406         assert((pbBufPtr(&s->pb) == s->pb.buf));
2407         s->frame_bits=0;
2408     }
2409     assert((s->frame_bits&7)==0);
2410     
2411     return s->frame_bits/8;
2412 }
2413
2414 #endif //CONFIG_ENCODERS
2415
2416 static inline void gmc1_motion(MpegEncContext *s,
2417                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2418                                uint8_t **ref_picture)
2419 {
2420     uint8_t *ptr;
2421     int offset, src_x, src_y, linesize, uvlinesize;
2422     int motion_x, motion_y;
2423     int emu=0;
2424
2425     motion_x= s->sprite_offset[0][0];
2426     motion_y= s->sprite_offset[0][1];
2427     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2428     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2429     motion_x<<=(3-s->sprite_warping_accuracy);
2430     motion_y<<=(3-s->sprite_warping_accuracy);
2431     src_x = clip(src_x, -16, s->width);
2432     if (src_x == s->width)
2433         motion_x =0;
2434     src_y = clip(src_y, -16, s->height);
2435     if (src_y == s->height)
2436         motion_y =0;
2437
2438     linesize = s->linesize;
2439     uvlinesize = s->uvlinesize;
2440     
2441     ptr = ref_picture[0] + (src_y * linesize) + src_x;
2442
2443     if(s->flags&CODEC_FLAG_EMU_EDGE){
2444         if(   (unsigned)src_x >= s->h_edge_pos - 17
2445            || (unsigned)src_y >= s->v_edge_pos - 17){
2446             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2447             ptr= s->edge_emu_buffer;
2448         }
2449     }
2450     
2451     if((motion_x|motion_y)&7){
2452         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2453         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2454     }else{
2455         int dxy;
2456         
2457         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2458         if (s->no_rounding){
2459             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2460         }else{
2461             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2462         }
2463     }
2464     
2465     if(s->flags&CODEC_FLAG_GRAY) return;
2466
2467     motion_x= s->sprite_offset[1][0];
2468     motion_y= s->sprite_offset[1][1];
2469     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2470     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2471     motion_x<<=(3-s->sprite_warping_accuracy);
2472     motion_y<<=(3-s->sprite_warping_accuracy);
2473     src_x = clip(src_x, -8, s->width>>1);
2474     if (src_x == s->width>>1)
2475         motion_x =0;
2476     src_y = clip(src_y, -8, s->height>>1);
2477     if (src_y == s->height>>1)
2478         motion_y =0;
2479
2480     offset = (src_y * uvlinesize) + src_x;
2481     ptr = ref_picture[1] + offset;
2482     if(s->flags&CODEC_FLAG_EMU_EDGE){
2483         if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2484            || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2485             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);
2486             ptr= s->edge_emu_buffer;
2487             emu=1;
2488         }
2489     }
2490     s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2491     
2492     ptr = ref_picture[2] + offset;
2493     if(emu){
2494         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);
2495         ptr= s->edge_emu_buffer;
2496     }
2497     s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2498     
2499     return;
2500 }
2501
2502 static inline void gmc_motion(MpegEncContext *s,
2503                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2504                                uint8_t **ref_picture)
2505 {
2506     uint8_t *ptr;
2507     int linesize, uvlinesize;
2508     const int a= s->sprite_warping_accuracy;
2509     int ox, oy;
2510
2511     linesize = s->linesize;
2512     uvlinesize = s->uvlinesize;
2513
2514     ptr = ref_picture[0];
2515
2516     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2517     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2518
2519     s->dsp.gmc(dest_y, ptr, linesize, 16,
2520            ox, 
2521            oy, 
2522            s->sprite_delta[0][0], s->sprite_delta[0][1],
2523            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2524            a+1, (1<<(2*a+1)) - s->no_rounding,
2525            s->h_edge_pos, s->v_edge_pos);
2526     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2527            ox + s->sprite_delta[0][0]*8, 
2528            oy + s->sprite_delta[1][0]*8, 
2529            s->sprite_delta[0][0], s->sprite_delta[0][1],
2530            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2531            a+1, (1<<(2*a+1)) - s->no_rounding,
2532            s->h_edge_pos, s->v_edge_pos);
2533
2534     if(s->flags&CODEC_FLAG_GRAY) return;
2535
2536     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2537     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2538
2539     ptr = ref_picture[1];
2540     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2541            ox, 
2542            oy, 
2543            s->sprite_delta[0][0], s->sprite_delta[0][1],
2544            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2545            a+1, (1<<(2*a+1)) - s->no_rounding,
2546            s->h_edge_pos>>1, s->v_edge_pos>>1);
2547     
2548     ptr = ref_picture[2];
2549     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2550            ox, 
2551            oy, 
2552            s->sprite_delta[0][0], s->sprite_delta[0][1],
2553            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2554            a+1, (1<<(2*a+1)) - s->no_rounding,
2555            s->h_edge_pos>>1, s->v_edge_pos>>1);
2556 }
2557
2558 /**
2559  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2560  * @param buf destination buffer
2561  * @param src source buffer
2562  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2563  * @param block_w width of block
2564  * @param block_h height of block
2565  * @param src_x x coordinate of the top left sample of the block in the source buffer
2566  * @param src_y y coordinate of the top left sample of the block in the source buffer
2567  * @param w width of the source buffer
2568  * @param h height of the source buffer
2569  */
2570 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2571                                     int src_x, int src_y, int w, int h){
2572     int x, y;
2573     int start_y, start_x, end_y, end_x;
2574
2575     if(src_y>= h){
2576         src+= (h-1-src_y)*linesize;
2577         src_y=h-1;
2578     }else if(src_y<=-block_h){
2579         src+= (1-block_h-src_y)*linesize;
2580         src_y=1-block_h;
2581     }
2582     if(src_x>= w){
2583         src+= (w-1-src_x);
2584         src_x=w-1;
2585     }else if(src_x<=-block_w){
2586         src+= (1-block_w-src_x);
2587         src_x=1-block_w;
2588     }
2589
2590     start_y= FFMAX(0, -src_y);
2591     start_x= FFMAX(0, -src_x);
2592     end_y= FFMIN(block_h, h-src_y);
2593     end_x= FFMIN(block_w, w-src_x);
2594
2595     // copy existing part
2596     for(y=start_y; y<end_y; y++){
2597         for(x=start_x; x<end_x; x++){
2598             buf[x + y*linesize]= src[x + y*linesize];
2599         }
2600     }
2601
2602     //top
2603     for(y=0; y<start_y; y++){
2604         for(x=start_x; x<end_x; x++){
2605             buf[x + y*linesize]= buf[x + start_y*linesize];
2606         }
2607     }
2608
2609     //bottom
2610     for(y=end_y; y<block_h; y++){
2611         for(x=start_x; x<end_x; x++){
2612             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2613         }
2614     }
2615                                     
2616     for(y=0; y<block_h; y++){
2617        //left
2618         for(x=0; x<start_x; x++){
2619             buf[x + y*linesize]= buf[start_x + y*linesize];
2620         }
2621        
2622        //right
2623         for(x=end_x; x<block_w; x++){
2624             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2625         }
2626     }
2627 }
2628
2629 static inline int hpel_motion(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, op_pixels_func *pix_op,
2636                                   int motion_x, int motion_y)
2637 {
2638     int dxy;
2639     int emu=0;
2640
2641     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2642     src_x += motion_x >> 1;
2643     src_y += motion_y >> 1;
2644                 
2645     /* WARNING: do no forget half pels */
2646     src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2647     if (src_x == width)
2648         dxy &= ~1;
2649     src_y = clip(src_y, -16, height);
2650     if (src_y == height)
2651         dxy &= ~2;
2652     src += src_y * stride + src_x;
2653
2654     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2655         if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2656            || (unsigned)src_y > v_edge_pos - (motion_y&1) - 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, s->v_edge_pos);
2659             src= s->edge_emu_buffer;
2660             emu=1;
2661         }
2662     }
2663     if(field_select)
2664         src += s->linesize;
2665     pix_op[dxy](dest, src, stride, h);
2666     return emu;
2667 }
2668
2669 static inline int hpel_motion_lowres(MpegEncContext *s, 
2670                                   uint8_t *dest, uint8_t *src,
2671                                   int field_based, int field_select,
2672                                   int src_x, int src_y,
2673                                   int width, int height, int stride,
2674                                   int h_edge_pos, int v_edge_pos,
2675                                   int w, int h, h264_chroma_mc_func *pix_op,
2676                                   int motion_x, int motion_y)
2677 {
2678     const int lowres= s->avctx->lowres;
2679     const int s_mask= (2<<lowres)-1;
2680     int emu=0;
2681     int sx, sy;
2682
2683     if(s->quarter_sample){
2684         motion_x/=2;
2685         motion_y/=2;
2686     }
2687
2688     sx= motion_x & s_mask;
2689     sy= motion_y & s_mask;
2690     src_x += motion_x >> (lowres+1);
2691     src_y += motion_y >> (lowres+1);
2692                 
2693     src += src_y * stride + src_x;
2694
2695     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2696        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2697         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2698                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2699         src= s->edge_emu_buffer;
2700         emu=1;
2701     }
2702
2703     sx <<= 2 - lowres;
2704     sy <<= 2 - lowres;
2705     if(field_select)
2706         src += s->linesize;
2707     pix_op[lowres](dest, src, stride, h, sx, sy);
2708     return emu;
2709 }
2710
2711 /* apply one mpeg motion vector to the three components */
2712 static always_inline void mpeg_motion(MpegEncContext *s,
2713                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2714                                int field_based, int bottom_field, int field_select,
2715                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2716                                int motion_x, int motion_y, int h)
2717 {
2718     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2719     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2720     
2721 #if 0    
2722 if(s->quarter_sample)
2723 {
2724     motion_x>>=1;
2725     motion_y>>=1;
2726 }
2727 #endif
2728
2729     v_edge_pos = s->v_edge_pos >> field_based;
2730     linesize   = s->current_picture.linesize[0] << field_based;
2731     uvlinesize = s->current_picture.linesize[1] << field_based;
2732
2733     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2734     src_x = s->mb_x* 16               + (motion_x >> 1);
2735     src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2736
2737     if (s->out_format == FMT_H263) {
2738         if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2739             mx = (motion_x>>1)|(motion_x&1);
2740             my = motion_y >>1;
2741             uvdxy = ((my & 1) << 1) | (mx & 1);
2742             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2743             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2744         }else{
2745             uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2746             uvsrc_x = src_x>>1;
2747             uvsrc_y = src_y>>1;
2748         }
2749     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2750         mx = motion_x / 4;
2751         my = motion_y / 4;
2752         uvdxy = 0;
2753         uvsrc_x = s->mb_x*8 + mx;
2754         uvsrc_y = s->mb_y*8 + my;
2755     } else {
2756         if(s->chroma_y_shift){
2757             mx = motion_x / 2;
2758             my = motion_y / 2;
2759             uvdxy = ((my & 1) << 1) | (mx & 1);
2760             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2761             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2762         } else {
2763             if(s->chroma_x_shift){
2764             //Chroma422
2765                 mx = motion_x / 2;
2766                 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2767                 uvsrc_x = s->mb_x* 8           + (mx >> 1);
2768                 uvsrc_y = src_y;
2769             } else {
2770             //Chroma444
2771                 uvdxy = dxy;
2772                 uvsrc_x = src_x;
2773                 uvsrc_y = src_y;
2774             }
2775         }
2776     }
2777
2778     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2779     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2780     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2781
2782     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2783        || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2784             if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2785                s->codec_id == CODEC_ID_MPEG1VIDEO){
2786                 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2787                 return ;
2788             }
2789             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2790                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2791             ptr_y = s->edge_emu_buffer;
2792             if(!(s->flags&CODEC_FLAG_GRAY)){
2793                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2794                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2795                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2796                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2797                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2798                 ptr_cb= uvbuf;
2799                 ptr_cr= uvbuf+16;
2800             }
2801     }
2802
2803     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2804         dest_y += s->linesize;
2805         dest_cb+= s->uvlinesize;
2806         dest_cr+= s->uvlinesize;
2807     }
2808
2809     if(field_select){
2810         ptr_y += s->linesize;
2811         ptr_cb+= s->uvlinesize;
2812         ptr_cr+= s->uvlinesize;
2813     }
2814
2815     pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2816     
2817     if(!(s->flags&CODEC_FLAG_GRAY)){
2818         pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2819         pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2820     }
2821     if(s->out_format == FMT_H261){
2822         ff_h261_loop_filter(s);
2823     }
2824 }
2825
2826 /* apply one mpeg motion vector to the three components */
2827 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2828                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2829                                int field_based, int bottom_field, int field_select,
2830                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2831                                int motion_x, int motion_y, int h)
2832 {
2833     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2834     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2835     const int lowres= s->avctx->lowres;
2836     const int block_s= 8>>lowres;
2837     const int s_mask= (2<<lowres)-1;
2838     const int h_edge_pos = s->h_edge_pos >> lowres;
2839     const int v_edge_pos = s->v_edge_pos >> lowres;
2840     linesize   = s->current_picture.linesize[0] << field_based;
2841     uvlinesize = s->current_picture.linesize[1] << field_based;
2842
2843     if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2844         motion_x/=2;
2845         motion_y/=2;
2846     }
2847     
2848     if(field_based){
2849         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2850     }
2851
2852     sx= motion_x & s_mask;
2853     sy= motion_y & s_mask;
2854     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2855     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2856     
2857     if (s->out_format == FMT_H263) {
2858         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2859         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2860         uvsrc_x = src_x>>1;
2861         uvsrc_y = src_y>>1;
2862     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2863         mx = motion_x / 4;
2864         my = motion_y / 4;
2865         uvsx = (2*mx) & s_mask;
2866         uvsy = (2*my) & s_mask;
2867         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2868         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2869     } else {
2870         mx = motion_x / 2;
2871         my = motion_y / 2;
2872         uvsx = mx & s_mask;
2873         uvsy = my & s_mask;
2874         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2875         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2876     }
2877
2878     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2879     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2880     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2881
2882     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2883        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2884             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2885                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2886             ptr_y = s->edge_emu_buffer;
2887             if(!(s->flags&CODEC_FLAG_GRAY)){
2888                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2889                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2890                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2891                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2892                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2893                 ptr_cb= uvbuf;
2894                 ptr_cr= uvbuf+16;
2895             }
2896     }
2897
2898     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2899         dest_y += s->linesize;
2900         dest_cb+= s->uvlinesize;
2901         dest_cr+= s->uvlinesize;
2902     }
2903
2904     if(field_select){
2905         ptr_y += s->linesize;
2906         ptr_cb+= s->uvlinesize;
2907         ptr_cr+= s->uvlinesize;
2908     }
2909
2910     sx <<= 2 - lowres;
2911     sy <<= 2 - lowres;
2912     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2913     
2914     if(!(s->flags&CODEC_FLAG_GRAY)){
2915         uvsx <<= 2 - lowres;
2916         uvsy <<= 2 - lowres;
2917         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2918         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2919     }
2920     //FIXME h261 lowres loop filter
2921 }
2922
2923 //FIXME move to dsputil, avg variant, 16x16 version
2924 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2925     int x;
2926     uint8_t * const top   = src[1];
2927     uint8_t * const left  = src[2];
2928     uint8_t * const mid   = src[0];
2929     uint8_t * const right = src[3];
2930     uint8_t * const bottom= src[4];
2931 #define OBMC_FILTER(x, t, l, m, r, b)\
2932     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2933 #define OBMC_FILTER4(x, t, l, m, r, b)\
2934     OBMC_FILTER(x         , t, l, m, r, b);\
2935     OBMC_FILTER(x+1       , t, l, m, r, b);\
2936     OBMC_FILTER(x  +stride, t, l, m, r, b);\
2937     OBMC_FILTER(x+1+stride, t, l, m, r, b);
2938     
2939     x=0;
2940     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2941     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2942     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2943     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2944     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2945     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2946     x+= stride;
2947     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2948     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2949     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2950     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2951     x+= stride;
2952     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2953     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2954     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2955     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2956     x+= 2*stride;
2957     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2958     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2959     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2960     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2961     x+= 2*stride;
2962     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2963     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2964     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2965     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2966     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2967     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2968     x+= stride;
2969     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2970     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2971     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2972     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2973 }
2974
2975 /* obmc for 1 8x8 luma block */
2976 static inline void obmc_motion(MpegEncContext *s,
2977                                uint8_t *dest, uint8_t *src,
2978                                int src_x, int src_y,
2979                                op_pixels_func *pix_op,
2980                                int16_t mv[5][2]/* mid top left right bottom*/)
2981 #define MID    0
2982 {
2983     int i;
2984     uint8_t *ptr[5];
2985     
2986     assert(s->quarter_sample==0);
2987     
2988     for(i=0; i<5; i++){
2989         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2990             ptr[i]= ptr[MID];
2991         }else{
2992             ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2993             hpel_motion(s, ptr[i], src, 0, 0,
2994                         src_x, src_y,
2995                         s->width, s->height, s->linesize,
2996                         s->h_edge_pos, s->v_edge_pos,
2997                         8, 8, pix_op,
2998                         mv[i][0], mv[i][1]);
2999         }
3000     }
3001
3002     put_obmc(dest, ptr, s->linesize);                
3003 }
3004
3005 static inline void qpel_motion(MpegEncContext *s,
3006                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3007                                int field_based, int bottom_field, int field_select,
3008                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3009                                qpel_mc_func (*qpix_op)[16],
3010                                int motion_x, int motion_y, int h)
3011 {
3012     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3013     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3014
3015     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3016     src_x = s->mb_x *  16                 + (motion_x >> 2);
3017     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3018
3019     v_edge_pos = s->v_edge_pos >> field_based;
3020     linesize = s->linesize << field_based;
3021     uvlinesize = s->uvlinesize << field_based;
3022     
3023     if(field_based){
3024         mx= motion_x/2;
3025         my= motion_y>>1;
3026     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3027         static const int rtab[8]= {0,0,1,1,0,0,0,1};
3028         mx= (motion_x>>1) + rtab[motion_x&7];
3029         my= (motion_y>>1) + rtab[motion_y&7];
3030     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3031         mx= (motion_x>>1)|(motion_x&1);
3032         my= (motion_y>>1)|(motion_y&1);
3033     }else{
3034         mx= motion_x/2;
3035         my= motion_y/2;
3036     }
3037     mx= (mx>>1)|(mx&1);
3038     my= (my>>1)|(my&1);
3039
3040     uvdxy= (mx&1) | ((my&1)<<1);
3041     mx>>=1;
3042     my>>=1;
3043
3044     uvsrc_x = s->mb_x *  8                 + mx;
3045     uvsrc_y = s->mb_y * (8 >> field_based) + my;
3046
3047     ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3048     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3049     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3050
3051     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
3052        || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3053         ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
3054                          src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3055         ptr_y= s->edge_emu_buffer;
3056         if(!(s->flags&CODEC_FLAG_GRAY)){
3057             uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3058             ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
3059                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3060             ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
3061                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3062             ptr_cb= uvbuf;
3063             ptr_cr= uvbuf + 16;
3064         }
3065     }
3066
3067     if(!field_based)
3068         qpix_op[0][dxy](dest_y, ptr_y, linesize);
3069     else{
3070         if(bottom_field){
3071             dest_y += s->linesize;
3072             dest_cb+= s->uvlinesize;
3073             dest_cr+= s->uvlinesize;
3074         }
3075
3076         if(field_select){
3077             ptr_y  += s->linesize;
3078             ptr_cb += s->uvlinesize;
3079             ptr_cr += s->uvlinesize;
3080         }
3081         //damn interlaced mode
3082         //FIXME boundary mirroring is not exactly correct here
3083         qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3084         qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3085     }
3086     if(!(s->flags&CODEC_FLAG_GRAY)){
3087         pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3088         pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3089     }
3090 }
3091
3092 inline int ff_h263_round_chroma(int x){
3093     if (x >= 0)
3094         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3095     else {
3096         x = -x;
3097         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3098     }
3099 }
3100
3101 /**
3102  * h263 chorma 4mv motion compensation.
3103  */
3104 static inline void chroma_4mv_motion(MpegEncContext *s,
3105                                      uint8_t *dest_cb, uint8_t *dest_cr,
3106                                      uint8_t **ref_picture,
3107                                      op_pixels_func *pix_op,
3108                                      int mx, int my){
3109     int dxy, emu=0, src_x, src_y, offset;
3110     uint8_t *ptr;
3111     
3112     /* In case of 8X8, we construct a single chroma motion vector
3113        with a special rounding */
3114     mx= ff_h263_round_chroma(mx);
3115     my= ff_h263_round_chroma(my);
3116     
3117     dxy = ((my & 1) << 1) | (mx & 1);
3118     mx >>= 1;
3119     my >>= 1;
3120
3121     src_x = s->mb_x * 8 + mx;
3122     src_y = s->mb_y * 8 + my;
3123     src_x = clip(src_x, -8, s->width/2);
3124     if (src_x == s->width/2)
3125         dxy &= ~1;
3126     src_y = clip(src_y, -8, s->height/2);
3127     if (src_y == s->height/2)
3128         dxy &= ~2;
3129     
3130     offset = (src_y * (s->uvlinesize)) + src_x;
3131     ptr = ref_picture[1] + offset;
3132     if(s->flags&CODEC_FLAG_EMU_EDGE){
3133         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3134            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3135             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);
3136             ptr= s->edge_emu_buffer;
3137             emu=1;
3138         }
3139     }
3140     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3141
3142     ptr = ref_picture[2] + offset;
3143     if(emu){
3144         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);
3145         ptr= s->edge_emu_buffer;
3146     }
3147     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3148 }
3149
3150 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3151                                      uint8_t *dest_cb, uint8_t *dest_cr,
3152                                      uint8_t **ref_picture,
3153                                      h264_chroma_mc_func *pix_op,
3154                                      int mx, int my){
3155     const int lowres= s->avctx->lowres;
3156     const int block_s= 8>>lowres;
3157     const int s_mask= (2<<lowres)-1;
3158     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3159     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3160     int emu=0, src_x, src_y, offset, sx, sy;
3161     uint8_t *ptr;
3162     
3163     if(s->quarter_sample){
3164         mx/=2;
3165         my/=2;
3166     }
3167
3168     /* In case of 8X8, we construct a single chroma motion vector
3169        with a special rounding */
3170     mx= ff_h263_round_chroma(mx);
3171     my= ff_h263_round_chroma(my);
3172     
3173     sx= mx & s_mask;
3174     sy= my & s_mask;
3175     src_x = s->mb_x*block_s + (mx >> (lowres+1));
3176     src_y = s->mb_y*block_s + (my >> (lowres+1));
3177     
3178     offset = src_y * s->uvlinesize + src_x;
3179     ptr = ref_picture[1] + offset;
3180     if(s->flags&CODEC_FLAG_EMU_EDGE){
3181         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3182            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3183             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3184             ptr= s->edge_emu_buffer;
3185             emu=1;
3186         }
3187     }     
3188     sx <<= 2 - lowres;
3189     sy <<= 2 - lowres;
3190     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3191           
3192     ptr = ref_picture[2] + offset;
3193     if(emu){
3194         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3195         ptr= s->edge_emu_buffer;
3196     }
3197     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3198 }
3199
3200 /**
3201  * motion compesation of a single macroblock
3202  * @param s context
3203  * @param dest_y luma destination pointer
3204  * @param dest_cb chroma cb/u destination pointer
3205  * @param dest_cr chroma cr/v destination pointer
3206  * @param dir direction (0->forward, 1->backward)
3207  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3208  * @param pic_op halfpel motion compensation function (average or put normally)
3209  * @param pic_op qpel motion compensation function (average or put normally)
3210  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3211  */
3212 static inline void MPV_motion(MpegEncContext *s, 
3213                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3214                               int dir, uint8_t **ref_picture, 
3215                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3216 {
3217     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3218     int mb_x, mb_y, i;
3219     uint8_t *ptr, *dest;
3220
3221     mb_x = s->mb_x;
3222     mb_y = s->mb_y;
3223
3224     if(s->obmc && s->pict_type != B_TYPE){
3225         int16_t mv_cache[4][4][2];
3226         const int xy= s->mb_x + s->mb_y*s->mb_stride;
3227         const int mot_stride= s->b8_stride;
3228         const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3229
3230         assert(!s->mb_skiped);
3231                 
3232         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3233         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3234         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3235
3236         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3237             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3238         }else{
3239             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3240         }
3241
3242         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3243             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3244             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3245         }else{
3246             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3247             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.moti