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