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