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