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