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