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