H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
[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_H261:
1084         s->out_format = FMT_H261;
1085         avctx->delay=0;
1086         s->low_delay=1;
1087         break;
1088     case CODEC_ID_H263:
1089         if (h263_get_picture_format(s->width, s->height) == 7) {
1090             av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1091             return -1;
1092         }
1093         s->out_format = FMT_H263;
1094         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1095         avctx->delay=0;
1096         s->low_delay=1;
1097         break;
1098     case CODEC_ID_H263P:
1099         s->out_format = FMT_H263;
1100         s->h263_plus = 1;
1101         /* Fx */
1102         s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1103         s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1104         s->modified_quant= s->h263_aic;
1105         s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1106         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1107         s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1108         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1109         s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1110
1111         /* /Fx */
1112         /* These are just to be sure */
1113         avctx->delay=0;
1114         s->low_delay=1;
1115         break;
1116     case CODEC_ID_FLV1:
1117         s->out_format = FMT_H263;
1118         s->h263_flv = 2; /* format = 1; 11-bit codes */
1119         s->unrestricted_mv = 1;
1120         s->rtp_mode=0; /* don't allow GOB */
1121         avctx->delay=0;
1122         s->low_delay=1;
1123         break;
1124     case CODEC_ID_RV10:
1125         s->out_format = FMT_H263;
1126         avctx->delay=0;
1127         s->low_delay=1;
1128         break;
1129     case CODEC_ID_MPEG4:
1130         s->out_format = FMT_H263;
1131         s->h263_pred = 1;
1132         s->unrestricted_mv = 1;
1133         s->low_delay= s->max_b_frames ? 0 : 1;
1134         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1135         break;
1136     case CODEC_ID_MSMPEG4V1:
1137         s->out_format = FMT_H263;
1138         s->h263_msmpeg4 = 1;
1139         s->h263_pred = 1;
1140         s->unrestricted_mv = 1;
1141         s->msmpeg4_version= 1;
1142         avctx->delay=0;
1143         s->low_delay=1;
1144         break;
1145     case CODEC_ID_MSMPEG4V2:
1146         s->out_format = FMT_H263;
1147         s->h263_msmpeg4 = 1;
1148         s->h263_pred = 1;
1149         s->unrestricted_mv = 1;
1150         s->msmpeg4_version= 2;
1151         avctx->delay=0;
1152         s->low_delay=1;
1153         break;
1154     case CODEC_ID_MSMPEG4V3:
1155         s->out_format = FMT_H263;
1156         s->h263_msmpeg4 = 1;
1157         s->h263_pred = 1;
1158         s->unrestricted_mv = 1;
1159         s->msmpeg4_version= 3;
1160         s->flipflop_rounding=1;
1161         avctx->delay=0;
1162         s->low_delay=1;
1163         break;
1164     case CODEC_ID_WMV1:
1165         s->out_format = FMT_H263;
1166         s->h263_msmpeg4 = 1;
1167         s->h263_pred = 1;
1168         s->unrestricted_mv = 1;
1169         s->msmpeg4_version= 4;
1170         s->flipflop_rounding=1;
1171         avctx->delay=0;
1172         s->low_delay=1;
1173         break;
1174     case CODEC_ID_WMV2:
1175         s->out_format = FMT_H263;
1176         s->h263_msmpeg4 = 1;
1177         s->h263_pred = 1;
1178         s->unrestricted_mv = 1;
1179         s->msmpeg4_version= 5;
1180         s->flipflop_rounding=1;
1181         avctx->delay=0;
1182         s->low_delay=1;
1183         break;
1184 #endif
1185     default:
1186         return -1;
1187     }
1188     
1189     avctx->has_b_frames= !s->low_delay;
1190
1191     s->encoding = 1;
1192
1193     /* init */
1194     if (MPV_common_init(s) < 0)
1195         return -1;
1196
1197     if(s->modified_quant)
1198         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1199     s->progressive_frame= 
1200     s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1201     s->quant_precision=5;
1202     
1203     ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1204     
1205 #ifdef CONFIG_ENCODERS
1206 #ifdef CONFIG_RISKY
1207     if (s->out_format == FMT_H261)
1208         ff_h261_encode_init(s);
1209     if (s->out_format == FMT_H263)
1210         h263_encode_init(s);
1211     if(s->msmpeg4_version)
1212         ff_msmpeg4_encode_init(s);
1213 #endif
1214     if (s->out_format == FMT_MPEG1)
1215         ff_mpeg1_encode_init(s);
1216 #endif
1217
1218     /* init q matrix */
1219     for(i=0;i<64;i++) {
1220         int j= s->dsp.idct_permutation[i];
1221 #ifdef CONFIG_RISKY
1222         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1223             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1224             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1225         }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1226             s->intra_matrix[j] =
1227             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1228         }else
1229 #endif
1230         { /* mpeg1/2 */
1231             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1232             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1233         }
1234         if(s->avctx->intra_matrix)
1235             s->intra_matrix[j] = s->avctx->intra_matrix[i];
1236         if(s->avctx->inter_matrix)
1237             s->inter_matrix[j] = s->avctx->inter_matrix[i];
1238     }
1239
1240     /* precompute matrix */
1241     /* for mjpeg, we do include qscale in the matrix */
1242     if (s->out_format != FMT_MJPEG) {
1243         convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1244                        s->intra_matrix, s->intra_quant_bias, 1, 31);
1245         convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1246                        s->inter_matrix, s->inter_quant_bias, 1, 31);
1247     }
1248
1249     if(ff_rate_control_init(s) < 0)
1250         return -1;
1251     
1252     return 0;
1253 }
1254
1255 int MPV_encode_end(AVCodecContext *avctx)
1256 {
1257     MpegEncContext *s = avctx->priv_data;
1258
1259 #ifdef STATS
1260     print_stats();
1261 #endif
1262
1263     ff_rate_control_uninit(s);
1264
1265     MPV_common_end(s);
1266     if (s->out_format == FMT_MJPEG)
1267         mjpeg_close(s);
1268
1269     av_freep(&avctx->extradata);
1270       
1271     return 0;
1272 }
1273
1274 #endif //CONFIG_ENCODERS
1275
1276 void init_rl(RLTable *rl)
1277 {
1278     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1279     uint8_t index_run[MAX_RUN+1];
1280     int last, run, level, start, end, i;
1281
1282     /* compute max_level[], max_run[] and index_run[] */
1283     for(last=0;last<2;last++) {
1284         if (last == 0) {
1285             start = 0;
1286             end = rl->last;
1287         } else {
1288             start = rl->last;
1289             end = rl->n;
1290         }
1291
1292         memset(max_level, 0, MAX_RUN + 1);
1293         memset(max_run, 0, MAX_LEVEL + 1);
1294         memset(index_run, rl->n, MAX_RUN + 1);
1295         for(i=start;i<end;i++) {
1296             run = rl->table_run[i];
1297             level = rl->table_level[i];
1298             if (index_run[run] == rl->n)
1299                 index_run[run] = i;
1300             if (level > max_level[run])
1301                 max_level[run] = level;
1302             if (run > max_run[level])
1303                 max_run[level] = run;
1304         }
1305         rl->max_level[last] = av_malloc(MAX_RUN + 1);
1306         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1307         rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1308         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1309         rl->index_run[last] = av_malloc(MAX_RUN + 1);
1310         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1311     }
1312 }
1313
1314 /* draw the edges of width 'w' of an image of size width, height */
1315 //FIXME check that this is ok for mpeg4 interlaced
1316 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1317 {
1318     uint8_t *ptr, *last_line;
1319     int i;
1320
1321     last_line = buf + (height - 1) * wrap;
1322     for(i=0;i<w;i++) {
1323         /* top and bottom */
1324         memcpy(buf - (i + 1) * wrap, buf, width);
1325         memcpy(last_line + (i + 1) * wrap, last_line, width);
1326     }
1327     /* left and right */
1328     ptr = buf;
1329     for(i=0;i<height;i++) {
1330         memset(ptr - w, ptr[0], w);
1331         memset(ptr + width, ptr[width-1], w);
1332         ptr += wrap;
1333     }
1334     /* corners */
1335     for(i=0;i<w;i++) {
1336         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1337         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1338         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1339         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1340     }
1341 }
1342
1343 int ff_find_unused_picture(MpegEncContext *s, int shared){
1344     int i;
1345     
1346     if(shared){
1347         for(i=0; i<MAX_PICTURE_COUNT; i++){
1348             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1349         }
1350     }else{
1351         for(i=0; i<MAX_PICTURE_COUNT; i++){
1352             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1353         }
1354         for(i=0; i<MAX_PICTURE_COUNT; i++){
1355             if(s->picture[i].data[0]==NULL) return i;
1356         }
1357     }
1358
1359     assert(0);
1360     return -1;
1361 }
1362
1363 static void update_noise_reduction(MpegEncContext *s){
1364     int intra, i;
1365
1366     for(intra=0; intra<2; intra++){
1367         if(s->dct_count[intra] > (1<<16)){
1368             for(i=0; i<64; i++){
1369                 s->dct_error_sum[intra][i] >>=1;
1370             }
1371             s->dct_count[intra] >>= 1;
1372         }
1373         
1374         for(i=0; i<64; i++){
1375             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);
1376         }
1377     }
1378 }
1379
1380 /**
1381  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1382  */
1383 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1384 {
1385     int i;
1386     AVFrame *pic;
1387     s->mb_skiped = 0;
1388
1389     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1390
1391     /* mark&release old frames */
1392     if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1393         avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1394
1395         /* release forgotten pictures */
1396         /* if(mpeg124/h263) */
1397         if(!s->encoding){
1398             for(i=0; i<MAX_PICTURE_COUNT; i++){
1399                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1400                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1401                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1402                 }
1403             }
1404         }
1405     }
1406 alloc:
1407     if(!s->encoding){
1408         /* release non refernce frames */
1409         for(i=0; i<MAX_PICTURE_COUNT; i++){
1410             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1411                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1412             }
1413         }
1414
1415         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1416             pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1417         else{
1418             i= ff_find_unused_picture(s, 0);
1419             pic= (AVFrame*)&s->picture[i];
1420         }
1421
1422         pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
1423
1424         pic->coded_picture_number= s->coded_picture_number++;
1425         
1426         if( alloc_picture(s, (Picture*)pic, 0) < 0)
1427             return -1;
1428
1429         s->current_picture_ptr= (Picture*)pic;
1430         s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1431         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1432     }
1433
1434     s->current_picture_ptr->pict_type= s->pict_type;
1435 //    if(s->flags && CODEC_FLAG_QSCALE) 
1436   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1437     s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1438
1439     copy_picture(&s->current_picture, s->current_picture_ptr);
1440   
1441   if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1442     if (s->pict_type != B_TYPE) {
1443         s->last_picture_ptr= s->next_picture_ptr;
1444         if(!s->dropable)
1445             s->next_picture_ptr= s->current_picture_ptr;
1446     }
1447 /*    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,
1448         s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1449         s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1450         s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1451         s->pict_type, s->dropable);*/
1452     
1453     if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1454     if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1455     
1456     if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1457         av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1458         assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1459         goto alloc;
1460     }
1461
1462     assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1463
1464     if(s->picture_structure!=PICT_FRAME){
1465         int i;
1466         for(i=0; i<4; i++){
1467             if(s->picture_structure == PICT_BOTTOM_FIELD){
1468                  s->current_picture.data[i] += s->current_picture.linesize[i];
1469             } 
1470             s->current_picture.linesize[i] *= 2;
1471             s->last_picture.linesize[i] *=2;
1472             s->next_picture.linesize[i] *=2;
1473         }
1474     }
1475   }
1476    
1477     s->hurry_up= s->avctx->hurry_up;
1478     s->error_resilience= avctx->error_resilience;
1479
1480     /* set dequantizer, we cant do it during init as it might change for mpeg4
1481        and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1482     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1483         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1484         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1485     }else if(s->out_format == FMT_H263){
1486         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1487         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1488     }else if(s->out_format == FMT_H261){
1489         s->dct_unquantize_intra = s->dct_unquantize_h261_intra;
1490         s->dct_unquantize_inter = s->dct_unquantize_h261_inter;
1491     }else{
1492         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1493         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1494     }
1495
1496     if(s->dct_error_sum){
1497         assert(s->avctx->noise_reduction && s->encoding);
1498
1499         update_noise_reduction(s);
1500     }
1501         
1502 #ifdef HAVE_XVMC
1503     if(s->avctx->xvmc_acceleration)
1504         return XVMC_field_start(s, avctx);
1505 #endif
1506     return 0;
1507 }
1508
1509 /* generic function for encode/decode called after a frame has been coded/decoded */
1510 void MPV_frame_end(MpegEncContext *s)
1511 {
1512     int i;
1513     /* draw edge for correct motion prediction if outside */
1514 #ifdef HAVE_XVMC
1515 //just to make sure that all data is rendered.
1516     if(s->avctx->xvmc_acceleration){
1517         XVMC_field_end(s);
1518     }else
1519 #endif
1520     if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1521             draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1522             draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1523             draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1524     }
1525     emms_c();
1526     
1527     s->last_pict_type    = s->pict_type;
1528     if(s->pict_type!=B_TYPE){
1529         s->last_non_b_pict_type= s->pict_type;
1530     }
1531 #if 0
1532         /* copy back current_picture variables */
1533     for(i=0; i<MAX_PICTURE_COUNT; i++){
1534         if(s->picture[i].data[0] == s->current_picture.data[0]){
1535             s->picture[i]= s->current_picture;
1536             break;
1537         }    
1538     }
1539     assert(i<MAX_PICTURE_COUNT);
1540 #endif    
1541
1542     if(s->encoding){
1543         /* release non refernce frames */
1544         for(i=0; i<MAX_PICTURE_COUNT; i++){
1545             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1546                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1547             }
1548         }
1549     }
1550     // clear copies, to avoid confusion
1551 #if 0
1552     memset(&s->last_picture, 0, sizeof(Picture));
1553     memset(&s->next_picture, 0, sizeof(Picture));
1554     memset(&s->current_picture, 0, sizeof(Picture));
1555 #endif
1556     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1557 }
1558
1559 /**
1560  * draws an line from (ex, ey) -> (sx, sy).
1561  * @param w width of the image
1562  * @param h height of the image
1563  * @param stride stride/linesize of the image
1564  * @param color color of the arrow
1565  */
1566 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1567     int t, x, y, fr, f;
1568     
1569     sx= clip(sx, 0, w-1);
1570     sy= clip(sy, 0, h-1);
1571     ex= clip(ex, 0, w-1);
1572     ey= clip(ey, 0, h-1);
1573     
1574     buf[sy*stride + sx]+= color;
1575     
1576     if(ABS(ex - sx) > ABS(ey - sy)){
1577         if(sx > ex){
1578             t=sx; sx=ex; ex=t;
1579             t=sy; sy=ey; ey=t;
1580         }
1581         buf+= sx + sy*stride;
1582         ex-= sx;
1583         f= ((ey-sy)<<16)/ex;
1584         for(x= 0; x <= ex; x++){
1585             y = (x*f)>>16;
1586             fr= (x*f)&0xFFFF;
1587             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1588             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1589         }
1590     }else{
1591         if(sy > ey){
1592             t=sx; sx=ex; ex=t;
1593             t=sy; sy=ey; ey=t;
1594         }
1595         buf+= sx + sy*stride;
1596         ey-= sy;
1597         if(ey) f= ((ex-sx)<<16)/ey;
1598         else   f= 0;
1599         for(y= 0; y <= ey; y++){
1600             x = (y*f)>>16;
1601             fr= (y*f)&0xFFFF;
1602             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1603             buf[y*stride + x+1]+= (color*         fr )>>16;;
1604         }
1605     }
1606 }
1607
1608 /**
1609  * draws an arrow from (ex, ey) -> (sx, sy).
1610  * @param w width of the image
1611  * @param h height of the image
1612  * @param stride stride/linesize of the image
1613  * @param color color of the arrow
1614  */
1615 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1616     int dx,dy;
1617
1618     sx= clip(sx, -100, w+100);
1619     sy= clip(sy, -100, h+100);
1620     ex= clip(ex, -100, w+100);
1621     ey= clip(ey, -100, h+100);
1622     
1623     dx= ex - sx;
1624     dy= ey - sy;
1625     
1626     if(dx*dx + dy*dy > 3*3){
1627         int rx=  dx + dy;
1628         int ry= -dx + dy;
1629         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1630         
1631         //FIXME subpixel accuracy
1632         rx= ROUNDED_DIV(rx*3<<4, length);
1633         ry= ROUNDED_DIV(ry*3<<4, length);
1634         
1635         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1636         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1637     }
1638     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1639 }
1640
1641 /**
1642  * prints debuging info for the given picture.
1643  */
1644 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1645
1646     if(!pict || !pict->mb_type) return;
1647
1648     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1649         int x,y;
1650         
1651         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1652         switch (pict->pict_type) {
1653             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1654             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1655             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1656             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1657             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1658             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1659         }
1660         for(y=0; y<s->mb_height; y++){
1661             for(x=0; x<s->mb_width; x++){
1662                 if(s->avctx->debug&FF_DEBUG_SKIP){
1663                     int count= s->mbskip_table[x + y*s->mb_stride];
1664                     if(count>9) count=9;
1665                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1666                 }
1667                 if(s->avctx->debug&FF_DEBUG_QP){
1668                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1669                 }
1670                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1671                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1672                     //Type & MV direction
1673                     if(IS_PCM(mb_type))
1674                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1675                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1676                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1677                     else if(IS_INTRA4x4(mb_type))
1678                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1679                     else if(IS_INTRA16x16(mb_type))
1680                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1681                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1682                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1683                     else if(IS_DIRECT(mb_type))
1684                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1685                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1686                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1687                     else if(IS_GMC(mb_type))
1688                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1689                     else if(IS_SKIP(mb_type))
1690                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1691                     else if(!USES_LIST(mb_type, 1))
1692                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1693                     else if(!USES_LIST(mb_type, 0))
1694                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1695                     else{
1696                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1697                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1698                     }
1699                     
1700                     //segmentation
1701                     if(IS_8X8(mb_type))
1702                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1703                     else if(IS_16X8(mb_type))
1704                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1705                     else if(IS_8X16(mb_type))
1706                         av_log(s->avctx, AV_LOG_DEBUG, "¦");
1707                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1708                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1709                     else
1710                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1711                     
1712                         
1713                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1714                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1715                     else
1716                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1717                 }
1718 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1719             }
1720             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1721         }
1722     }
1723
1724     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1725         const int shift= 1 + s->quarter_sample;
1726         int mb_y;
1727         uint8_t *ptr;
1728         int i;
1729         int h_chroma_shift, v_chroma_shift;
1730         const int width = s->avctx->width;
1731         const int height= s->avctx->height;
1732         s->low_delay=0; //needed to see the vectors without trashing the buffers
1733
1734         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1735         for(i=0; i<3; i++){
1736             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1737             pict->data[i]= s->visualization_buffer[i];
1738         }
1739         pict->type= FF_BUFFER_TYPE_COPY;
1740         ptr= pict->data[0];
1741
1742         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1743             int mb_x;
1744             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1745                 const int mb_index= mb_x + mb_y*s->mb_stride;
1746                 if((s->avctx->debug_mv) && pict->motion_val){
1747                   int type;
1748                   for(type=0; type<3; type++){
1749                     int direction = 0;
1750                     switch (type) {
1751                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1752                                 continue;
1753                               direction = 0;
1754                               break;
1755                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1756                                 continue;
1757                               direction = 0;
1758                               break;
1759                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1760                                 continue;
1761                               direction = 1;
1762                               break;
1763                     }
1764                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1765                         continue;
1766
1767                     //FIXME for h264
1768                     if(IS_8X8(pict->mb_type[mb_index])){
1769                       int i;
1770                       for(i=0; i<4; i++){
1771                         int sx= mb_x*16 + 4 + 8*(i&1);
1772                         int sy= mb_y*16 + 4 + 8*(i>>1);
1773                         int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1774                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1775                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1776                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1777                       }
1778                     }else if(IS_16X8(pict->mb_type[mb_index])){
1779                       int i;
1780                       for(i=0; i<2; i++){
1781                         int sx=mb_x*16 + 8;
1782                         int sy=mb_y*16 + 4 + 8*i;
1783                         int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1784                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1785                         int my=(pict->motion_val[direction][xy][1]>>shift);
1786                         
1787                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1788                             my*=2;
1789                         
1790                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1791                       }
1792                     }else{
1793                       int sx= mb_x*16 + 8;
1794                       int sy= mb_y*16 + 8;
1795                       int xy= mb_x*2 + mb_y*2*s->b8_stride;
1796                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1797                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1798                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1799                     }
1800                   }                  
1801                 }
1802                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1803                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1804                     int y;
1805                     for(y=0; y<8; y++){
1806                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1807                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1808                     }
1809                 }
1810                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1811                     int mb_type= pict->mb_type[mb_index];
1812                     uint64_t u,v;
1813                     int y;
1814 #define COLOR(theta, r)\
1815 u= (int)(128 + r*cos(theta*3.141592/180));\
1816 v= (int)(128 + r*sin(theta*3.141592/180));
1817
1818                     
1819                     u=v=128;
1820                     if(IS_PCM(mb_type)){
1821                         COLOR(120,48)
1822                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1823                         COLOR(30,48)
1824                     }else if(IS_INTRA4x4(mb_type)){
1825                         COLOR(90,48)
1826                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1827 //                        COLOR(120,48)
1828                     }else if(IS_DIRECT(mb_type)){
1829                         COLOR(150,48)
1830                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1831                         COLOR(170,48)
1832                     }else if(IS_GMC(mb_type)){
1833                         COLOR(190,48)
1834                     }else if(IS_SKIP(mb_type)){
1835 //                        COLOR(180,48)
1836                     }else if(!USES_LIST(mb_type, 1)){
1837                         COLOR(240,48)
1838                     }else if(!USES_LIST(mb_type, 0)){
1839                         COLOR(0,48)
1840                     }else{
1841                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1842                         COLOR(300,48)
1843                     }
1844
1845                     u*= 0x0101010101010101ULL;
1846                     v*= 0x0101010101010101ULL;
1847                     for(y=0; y<8; y++){
1848                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1849                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1850                     }
1851
1852                     //segmentation
1853                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1854                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1855                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1856                     }
1857                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1858                         for(y=0; y<16; y++)
1859                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1860                     }
1861                         
1862                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1863                         // hmm
1864                     }
1865                 }
1866                 s->mbskip_table[mb_index]=0;
1867             }
1868         }
1869     }
1870 }
1871
1872 #ifdef CONFIG_ENCODERS
1873
1874 static int get_sae(uint8_t *src, int ref, int stride){
1875     int x,y;
1876     int acc=0;
1877     
1878     for(y=0; y<16; y++){
1879         for(x=0; x<16; x++){
1880             acc+= ABS(src[x+y*stride] - ref);
1881         }
1882     }
1883     
1884     return acc;
1885 }
1886
1887 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1888     int x, y, w, h;
1889     int acc=0;
1890     
1891     w= s->width &~15;
1892     h= s->height&~15;
1893     
1894     for(y=0; y<h; y+=16){
1895         for(x=0; x<w; x+=16){
1896             int offset= x + y*stride;
1897             int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1898             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1899             int sae = get_sae(src + offset, mean, stride);
1900             
1901             acc+= sae + 500 < sad;
1902         }
1903     }
1904     return acc;
1905 }
1906
1907
1908 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1909     AVFrame *pic=NULL;
1910     int i;
1911     const int encoding_delay= s->max_b_frames;
1912     int direct=1;
1913     
1914   if(pic_arg){
1915     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1916     if(pic_arg->linesize[0] != s->linesize) direct=0;
1917     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1918     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1919   
1920 //    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1921     
1922     if(direct){
1923         i= ff_find_unused_picture(s, 1);
1924
1925         pic= (AVFrame*)&s->picture[i];
1926         pic->reference= 3;
1927     
1928         for(i=0; i<4; i++){
1929             pic->data[i]= pic_arg->data[i];
1930             pic->linesize[i]= pic_arg->linesize[i];
1931         }
1932         alloc_picture(s, (Picture*)pic, 1);
1933     }else{
1934         int offset= 16;
1935         i= ff_find_unused_picture(s, 0);
1936
1937         pic= (AVFrame*)&s->picture[i];
1938         pic->reference= 3;
1939
1940         alloc_picture(s, (Picture*)pic, 0);
1941
1942         if(   pic->data[0] + offset == pic_arg->data[0] 
1943            && pic->data[1] + offset == pic_arg->data[1]
1944            && pic->data[2] + offset == pic_arg->data[2]){
1945        // empty
1946         }else{
1947             int h_chroma_shift, v_chroma_shift;
1948             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1949         
1950             for(i=0; i<3; i++){
1951                 int src_stride= pic_arg->linesize[i];
1952                 int dst_stride= i ? s->uvlinesize : s->linesize;
1953                 int h_shift= i ? h_chroma_shift : 0;
1954                 int v_shift= i ? v_chroma_shift : 0;
1955                 int w= s->width >>h_shift;
1956                 int h= s->height>>v_shift;
1957                 uint8_t *src= pic_arg->data[i];
1958                 uint8_t *dst= pic->data[i] + offset;
1959             
1960                 if(src_stride==dst_stride)
1961                     memcpy(dst, src, src_stride*h);
1962                 else{
1963                     while(h--){
1964                         memcpy(dst, src, w);
1965                         dst += dst_stride;
1966                         src += src_stride;
1967                     }
1968                 }
1969             }
1970         }
1971     }
1972     copy_picture_attributes(s, pic, pic_arg);
1973     
1974     pic->display_picture_number= s->input_picture_number++;
1975  
1976     if(pic->pts != AV_NOPTS_VALUE){ 
1977         if(s->user_specified_pts != AV_NOPTS_VALUE){
1978             int64_t time= av_rescale(pic->pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1979             int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1980         
1981             if(time <= last){            
1982                 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pic->pts, s->user_specified_pts);
1983                 return -1;
1984             }
1985         }
1986         s->user_specified_pts= pic->pts;
1987     }else{
1988         if(s->user_specified_pts != AV_NOPTS_VALUE){
1989             s->user_specified_pts= 
1990             pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
1991             av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
1992         }else{
1993             pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
1994         }
1995     }
1996   }
1997   
1998     /* shift buffer entries */
1999     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2000         s->input_picture[i-1]= s->input_picture[i];
2001         
2002     s->input_picture[encoding_delay]= (Picture*)pic;
2003
2004     return 0;
2005 }
2006
2007 static void select_input_picture(MpegEncContext *s){
2008     int i;
2009
2010     for(i=1; i<MAX_PICTURE_COUNT; i++)
2011         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2012     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2013
2014     /* set next picture types & ordering */
2015     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2016         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2017             s->reordered_input_picture[0]= s->input_picture[0];
2018             s->reordered_input_picture[0]->pict_type= I_TYPE;
2019             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2020         }else{
2021             int b_frames;
2022             
2023             if(s->flags&CODEC_FLAG_PASS2){
2024                 for(i=0; i<s->max_b_frames+1; i++){
2025                     int pict_num= s->input_picture[0]->display_picture_number + i;
2026                     int pict_type= s->rc_context.entry[pict_num].new_pict_type;
2027                     s->input_picture[i]->pict_type= pict_type;
2028                     
2029                     if(i + 1 >= s->rc_context.num_entries) break;
2030                 }
2031             }
2032
2033             if(s->avctx->b_frame_strategy==0){
2034                 b_frames= s->max_b_frames;
2035                 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2036             }else if(s->avctx->b_frame_strategy==1){
2037                 for(i=1; i<s->max_b_frames+1; i++){
2038                     if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2039                         s->input_picture[i]->b_frame_score= 
2040                             get_intra_count(s, s->input_picture[i  ]->data[0], 
2041                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
2042                     }
2043                 }
2044                 for(i=0; i<s->max_b_frames; i++){
2045                     if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2046                 }
2047                                 
2048                 b_frames= FFMAX(0, i-1);
2049                 
2050                 /* reset scores */
2051                 for(i=0; i<b_frames+1; i++){
2052                     s->input_picture[i]->b_frame_score=0;
2053                 }
2054             }else{
2055                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2056                 b_frames=0;
2057             }
2058
2059             emms_c();
2060 //static int b_count=0;
2061 //b_count+= b_frames;
2062 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2063
2064             for(i= b_frames - 1; i>=0; i--){
2065                 int type= s->input_picture[i]->pict_type;
2066                 if(type && type != B_TYPE)
2067                     b_frames= i;
2068             }
2069             if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2070                 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2071             }
2072
2073             if(s->picture_in_gop_number + b_frames >= s->gop_size){
2074               if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2075                     b_frames= s->gop_size - s->picture_in_gop_number - 1;
2076               }else{
2077                 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2078                     b_frames=0;
2079                 s->input_picture[b_frames]->pict_type= I_TYPE;
2080               }
2081             }
2082             
2083             if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2084                && b_frames
2085                && s->input_picture[b_frames]->pict_type== I_TYPE)
2086                 b_frames--;
2087
2088             s->reordered_input_picture[0]= s->input_picture[b_frames];
2089             if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2090                 s->reordered_input_picture[0]->pict_type= P_TYPE;
2091             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2092             for(i=0; i<b_frames; i++){
2093                 s->reordered_input_picture[i+1]= s->input_picture[i];
2094                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2095                 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2096             }
2097         }
2098     }
2099     
2100     if(s->reordered_input_picture[0]){
2101         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2102
2103         copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2104
2105         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2106             // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2107         
2108             int i= ff_find_unused_picture(s, 0);
2109             Picture *pic= &s->picture[i];
2110
2111             /* mark us unused / free shared pic */
2112             for(i=0; i<4; i++)
2113                 s->reordered_input_picture[0]->data[i]= NULL;
2114             s->reordered_input_picture[0]->type= 0;
2115             
2116             pic->reference              = s->reordered_input_picture[0]->reference;
2117             
2118             alloc_picture(s, pic, 0);
2119
2120             copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2121
2122             s->current_picture_ptr= pic;
2123         }else{
2124             // input is not a shared pix -> reuse buffer for current_pix
2125
2126             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2127                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2128             
2129             s->current_picture_ptr= s->reordered_input_picture[0];
2130             for(i=0; i<4; i++){
2131                 s->new_picture.data[i]+=16;
2132             }
2133         }
2134         copy_picture(&s->current_picture, s->current_picture_ptr);
2135     
2136         s->picture_number= s->new_picture.display_picture_number;
2137 //printf("dpn:%d\n", s->picture_number);
2138     }else{
2139        memset(&s->new_picture, 0, sizeof(Picture));
2140     }
2141 }
2142
2143 int MPV_encode_picture(AVCodecContext *avctx,
2144                        unsigned char *buf, int buf_size, void *data)
2145 {
2146     MpegEncContext *s = avctx->priv_data;
2147     AVFrame *pic_arg = data;
2148     int i, stuffing_count;
2149
2150     if(avctx->pix_fmt != PIX_FMT_YUV420P){
2151         av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2152         return -1;
2153     }
2154     
2155     for(i=0; i<avctx->thread_count; i++){
2156         int start_y= s->thread_context[i]->start_mb_y;
2157         int   end_y= s->thread_context[i]->  end_mb_y;
2158         int h= s->mb_height;
2159         uint8_t *start= buf + buf_size*start_y/h;
2160         uint8_t *end  = buf + buf_size*  end_y/h;
2161
2162         init_put_bits(&s->thread_context[i]->pb, start, end - start);
2163     }
2164
2165     s->picture_in_gop_number++;
2166
2167     if(load_input_picture(s, pic_arg) < 0)
2168         return -1;
2169     
2170     select_input_picture(s);
2171     
2172     /* output? */
2173     if(s->new_picture.data[0]){
2174         s->pict_type= s->new_picture.pict_type;
2175 //emms_c();
2176 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2177         MPV_frame_start(s, avctx);
2178
2179         encode_picture(s, s->picture_number);
2180         
2181         avctx->real_pict_num  = s->picture_number;
2182         avctx->header_bits = s->header_bits;
2183         avctx->mv_bits     = s->mv_bits;
2184         avctx->misc_bits   = s->misc_bits;
2185         avctx->i_tex_bits  = s->i_tex_bits;
2186         avctx->p_tex_bits  = s->p_tex_bits;
2187         avctx->i_count     = s->i_count;
2188         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2189         avctx->skip_count  = s->skip_count;
2190
2191         MPV_frame_end(s);
2192
2193         if (s->out_format == FMT_MJPEG)
2194             mjpeg_picture_trailer(s);
2195         
2196         if(s->flags&CODEC_FLAG_PASS1)
2197             ff_write_pass1_stats(s);
2198
2199         for(i=0; i<4; i++){
2200             avctx->error[i] += s->current_picture_ptr->error[i];
2201         }
2202
2203         flush_put_bits(&s->pb);
2204         s->frame_bits  = put_bits_count(&s->pb);
2205
2206         stuffing_count= ff_vbv_update(s, s->frame_bits);
2207         if(stuffing_count){
2208             switch(s->codec_id){
2209             case CODEC_ID_MPEG1VIDEO:
2210             case CODEC_ID_MPEG2VIDEO:
2211                 while(stuffing_count--){
2212                     put_bits(&s->pb, 8, 0);
2213                 }
2214             break;
2215             case CODEC_ID_MPEG4:
2216                 put_bits(&s->pb, 16, 0);
2217                 put_bits(&s->pb, 16, 0x1C3);
2218                 stuffing_count -= 4;
2219                 while(stuffing_count--){
2220                     put_bits(&s->pb, 8, 0xFF);
2221                 }
2222             break;
2223             default:
2224                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2225             }
2226             flush_put_bits(&s->pb);
2227             s->frame_bits  = put_bits_count(&s->pb);
2228         }
2229
2230         /* update mpeg1/2 vbv_delay for CBR */    
2231         if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2232            && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2233             int vbv_delay;
2234
2235             assert(s->repeat_first_field==0);
2236             
2237             vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2238             assert(vbv_delay < 0xFFFF);
2239
2240             s->vbv_delay_ptr[0] &= 0xF8;
2241             s->vbv_delay_ptr[0] |= vbv_delay>>13;
2242             s->vbv_delay_ptr[1]  = vbv_delay>>5;
2243             s->vbv_delay_ptr[2] &= 0x07;
2244             s->vbv_delay_ptr[2] |= vbv_delay<<3;
2245         }
2246         s->total_bits += s->frame_bits;
2247         avctx->frame_bits  = s->frame_bits;
2248     }else{
2249         assert((pbBufPtr(&s->pb) == s->pb.buf));
2250         s->frame_bits=0;
2251     }
2252     assert((s->frame_bits&7)==0);
2253     
2254     return s->frame_bits/8;
2255 }
2256
2257 #endif //CONFIG_ENCODERS
2258
2259 static inline void gmc1_motion(MpegEncContext *s,
2260                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2261                                uint8_t **ref_picture)
2262 {
2263     uint8_t *ptr;
2264     int offset, src_x, src_y, linesize, uvlinesize;
2265     int motion_x, motion_y;
2266     int emu=0;
2267
2268     motion_x= s->sprite_offset[0][0];
2269     motion_y= s->sprite_offset[0][1];
2270     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2271     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2272     motion_x<<=(3-s->sprite_warping_accuracy);
2273     motion_y<<=(3-s->sprite_warping_accuracy);
2274     src_x = clip(src_x, -16, s->width);
2275     if (src_x == s->width)
2276         motion_x =0;
2277     src_y = clip(src_y, -16, s->height);
2278     if (src_y == s->height)
2279         motion_y =0;
2280
2281     linesize = s->linesize;
2282     uvlinesize = s->uvlinesize;
2283     
2284     ptr = ref_picture[0] + (src_y * linesize) + src_x;
2285
2286     if(s->flags&CODEC_FLAG_EMU_EDGE){
2287         if(   (unsigned)src_x >= s->h_edge_pos - 17
2288            || (unsigned)src_y >= s->v_edge_pos - 17){
2289             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2290             ptr= s->edge_emu_buffer;
2291         }
2292     }
2293     
2294     if((motion_x|motion_y)&7){
2295         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2296         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2297     }else{
2298         int dxy;
2299         
2300         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2301         if (s->no_rounding){
2302             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2303         }else{
2304             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2305         }
2306     }
2307     
2308     if(s->flags&CODEC_FLAG_GRAY) return;
2309
2310     motion_x= s->sprite_offset[1][0];
2311     motion_y= s->sprite_offset[1][1];
2312     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2313     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2314     motion_x<<=(3-s->sprite_warping_accuracy);
2315     motion_y<<=(3-s->sprite_warping_accuracy);
2316     src_x = clip(src_x, -8, s->width>>1);
2317     if (src_x == s->width>>1)
2318         motion_x =0;
2319     src_y = clip(src_y, -8, s->height>>1);
2320     if (src_y == s->height>>1)
2321         motion_y =0;
2322
2323     offset = (src_y * uvlinesize) + src_x;
2324     ptr = ref_picture[1] + offset;
2325     if(s->flags&CODEC_FLAG_EMU_EDGE){
2326         if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2327            || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2328             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);
2329             ptr= s->edge_emu_buffer;
2330             emu=1;
2331         }
2332     }
2333     s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2334     
2335     ptr = ref_picture[2] + offset;
2336     if(emu){
2337         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);
2338         ptr= s->edge_emu_buffer;
2339     }
2340     s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2341     
2342     return;
2343 }
2344
2345 static inline void gmc_motion(MpegEncContext *s,
2346                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2347                                uint8_t **ref_picture)
2348 {
2349     uint8_t *ptr;
2350     int linesize, uvlinesize;
2351     const int a= s->sprite_warping_accuracy;
2352     int ox, oy;
2353
2354     linesize = s->linesize;
2355     uvlinesize = s->uvlinesize;
2356
2357     ptr = ref_picture[0];
2358
2359     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2360     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2361
2362     s->dsp.gmc(dest_y, ptr, linesize, 16,
2363            ox, 
2364            oy, 
2365            s->sprite_delta[0][0], s->sprite_delta[0][1],
2366            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2367            a+1, (1<<(2*a+1)) - s->no_rounding,
2368            s->h_edge_pos, s->v_edge_pos);
2369     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2370            ox + s->sprite_delta[0][0]*8, 
2371            oy + s->sprite_delta[1][0]*8, 
2372            s->sprite_delta[0][0], s->sprite_delta[0][1],
2373            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2374            a+1, (1<<(2*a+1)) - s->no_rounding,
2375            s->h_edge_pos, s->v_edge_pos);
2376
2377     if(s->flags&CODEC_FLAG_GRAY) return;
2378
2379     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2380     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2381
2382     ptr = ref_picture[1];
2383     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2384            ox, 
2385            oy, 
2386            s->sprite_delta[0][0], s->sprite_delta[0][1],
2387            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2388            a+1, (1<<(2*a+1)) - s->no_rounding,
2389            s->h_edge_pos>>1, s->v_edge_pos>>1);
2390     
2391     ptr = ref_picture[2];
2392     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2393            ox, 
2394            oy, 
2395            s->sprite_delta[0][0], s->sprite_delta[0][1],
2396            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2397            a+1, (1<<(2*a+1)) - s->no_rounding,
2398            s->h_edge_pos>>1, s->v_edge_pos>>1);
2399 }
2400
2401 /**
2402  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2403  * @param buf destination buffer
2404  * @param src source buffer
2405  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2406  * @param block_w width of block
2407  * @param block_h height of block
2408  * @param src_x x coordinate of the top left sample of the block in the source buffer
2409  * @param src_y y coordinate of the top left sample of the block in the source buffer
2410  * @param w width of the source buffer
2411  * @param h height of the source buffer
2412  */
2413 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2414                                     int src_x, int src_y, int w, int h){
2415     int x, y;
2416     int start_y, start_x, end_y, end_x;
2417
2418     if(src_y>= h){
2419         src+= (h-1-src_y)*linesize;
2420         src_y=h-1;
2421     }else if(src_y<=-block_h){
2422         src+= (1-block_h-src_y)*linesize;
2423         src_y=1-block_h;
2424     }
2425     if(src_x>= w){
2426         src+= (w-1-src_x);
2427         src_x=w-1;
2428     }else if(src_x<=-block_w){
2429         src+= (1-block_w-src_x);
2430         src_x=1-block_w;
2431     }
2432
2433     start_y= FFMAX(0, -src_y);
2434     start_x= FFMAX(0, -src_x);
2435     end_y= FFMIN(block_h, h-src_y);
2436     end_x= FFMIN(block_w, w-src_x);
2437
2438     // copy existing part
2439     for(y=start_y; y<end_y; y++){
2440         for(x=start_x; x<end_x; x++){
2441             buf[x + y*linesize]= src[x + y*linesize];
2442         }
2443     }
2444
2445     //top
2446     for(y=0; y<start_y; y++){
2447         for(x=start_x; x<end_x; x++){
2448             buf[x + y*linesize]= buf[x + start_y*linesize];
2449         }
2450     }
2451
2452     //bottom
2453     for(y=end_y; y<block_h; y++){
2454         for(x=start_x; x<end_x; x++){
2455             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2456         }
2457     }
2458                                     
2459     for(y=0; y<block_h; y++){
2460        //left
2461         for(x=0; x<start_x; x++){
2462             buf[x + y*linesize]= buf[start_x + y*linesize];
2463         }
2464        
2465        //right
2466         for(x=end_x; x<block_w; x++){
2467             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2468         }
2469     }
2470 }
2471
2472 static inline int hpel_motion(MpegEncContext *s, 
2473                                   uint8_t *dest, uint8_t *src,
2474                                   int field_based, int field_select,
2475                                   int src_x, int src_y,
2476                                   int width, int height, int stride,
2477                                   int h_edge_pos, int v_edge_pos,
2478                                   int w, int h, op_pixels_func *pix_op,
2479                                   int motion_x, int motion_y)
2480 {
2481     int dxy;
2482     int emu=0;
2483
2484     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2485     src_x += motion_x >> 1;
2486     src_y += motion_y >> 1;
2487                 
2488     /* WARNING: do no forget half pels */
2489     src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2490     if (src_x == width)
2491         dxy &= ~1;
2492     src_y = clip(src_y, -16, height);
2493     if (src_y == height)
2494         dxy &= ~2;
2495     src += src_y * stride + src_x;
2496
2497     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2498         if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2499            || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2500             ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2501                              src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2502             src= s->edge_emu_buffer;
2503             emu=1;
2504         }
2505     }
2506     if(field_select)
2507         src += s->linesize;
2508     pix_op[dxy](dest, src, stride, h);
2509     return emu;
2510 }
2511
2512 static inline int hpel_motion_lowres(MpegEncContext *s, 
2513                                   uint8_t *dest, uint8_t *src,
2514                                   int field_based, int field_select,
2515                                   int src_x, int src_y,
2516                                   int width, int height, int stride,
2517                                   int h_edge_pos, int v_edge_pos,
2518                                   int w, int h, h264_chroma_mc_func *pix_op,
2519                                   int motion_x, int motion_y)
2520 {
2521     const int lowres= s->avctx->lowres;
2522     const int s_mask= (2<<lowres)-1;
2523     int emu=0;
2524     int sx, sy;
2525
2526     if(s->quarter_sample){
2527         motion_x/=2;
2528         motion_y/=2;
2529     }
2530
2531     sx= motion_x & s_mask;
2532     sy= motion_y & s_mask;
2533     src_x += motion_x >> (lowres+1);
2534     src_y += motion_y >> (lowres+1);
2535                 
2536     src += src_y * stride + src_x;
2537
2538     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2539        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2540         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2541                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2542         src= s->edge_emu_buffer;
2543         emu=1;
2544     }
2545
2546     sx <<= 2 - lowres;
2547     sy <<= 2 - lowres;
2548     if(field_select)
2549         src += s->linesize;
2550     pix_op[lowres](dest, src, stride, h, sx, sy);
2551     return emu;
2552 }
2553
2554 /* apply one mpeg motion vector to the three components */
2555 static always_inline void mpeg_motion(MpegEncContext *s,
2556                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2557                                int field_based, int bottom_field, int field_select,
2558                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2559                                int motion_x, int motion_y, int h)
2560 {
2561     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2562     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2563     
2564 #if 0    
2565 if(s->quarter_sample)
2566 {
2567     motion_x>>=1;
2568     motion_y>>=1;
2569 }
2570 #endif
2571
2572     v_edge_pos = s->v_edge_pos >> field_based;
2573     linesize   = s->current_picture.linesize[0] << field_based;
2574     uvlinesize = s->current_picture.linesize[1] << field_based;
2575
2576     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2577     src_x = s->mb_x* 16               + (motion_x >> 1);
2578     src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2579
2580     if (s->out_format == FMT_H263) {
2581         if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2582             mx = (motion_x>>1)|(motion_x&1);
2583             my = motion_y >>1;
2584             uvdxy = ((my & 1) << 1) | (mx & 1);
2585             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2586             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2587         }else{
2588             uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2589             uvsrc_x = src_x>>1;
2590             uvsrc_y = src_y>>1;
2591         }
2592     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2593         mx = motion_x / 4;
2594         my = motion_y / 4;
2595         uvdxy = 0;
2596         uvsrc_x = s->mb_x*8 + mx;
2597         uvsrc_y = s->mb_y*8 + my;
2598     } else {
2599         if(s->chroma_y_shift){
2600             mx = motion_x / 2;
2601             my = motion_y / 2;
2602             uvdxy = ((my & 1) << 1) | (mx & 1);
2603             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2604             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2605         } else {
2606             if(s->chroma_x_shift){
2607             //Chroma422
2608                 mx = motion_x / 2;
2609                 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2610                 uvsrc_x = s->mb_x* 8           + (mx >> 1);
2611                 uvsrc_y = src_y;
2612             } else {
2613             //Chroma444
2614                 uvdxy = dxy;
2615                 uvsrc_x = src_x;
2616                 uvsrc_y = src_y;
2617             }
2618         }
2619     }
2620
2621     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2622     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2623     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2624
2625     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2626        || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2627             if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2628                s->codec_id == CODEC_ID_MPEG1VIDEO){
2629                 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2630                 return ;
2631             }
2632             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2633                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2634             ptr_y = s->edge_emu_buffer;
2635             if(!(s->flags&CODEC_FLAG_GRAY)){
2636                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2637                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2638                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2639                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2640                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2641                 ptr_cb= uvbuf;
2642                 ptr_cr= uvbuf+16;
2643             }
2644     }
2645
2646     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2647         dest_y += s->linesize;
2648         dest_cb+= s->uvlinesize;
2649         dest_cr+= s->uvlinesize;
2650     }
2651
2652     if(field_select){
2653         ptr_y += s->linesize;
2654         ptr_cb+= s->uvlinesize;
2655         ptr_cr+= s->uvlinesize;
2656     }
2657
2658     pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2659     
2660     if(!(s->flags&CODEC_FLAG_GRAY)){
2661         pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2662         pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2663     }
2664     if(s->out_format == FMT_H261){
2665         ff_h261_loop_filter(s);
2666     }
2667 }
2668
2669 /* apply one mpeg motion vector to the three components */
2670 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2671                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2672                                int field_based, int bottom_field, int field_select,
2673                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2674                                int motion_x, int motion_y, int h)
2675 {
2676     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2677     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2678     const int lowres= s->avctx->lowres;
2679     const int block_s= 8>>lowres;
2680     const int s_mask= (2<<lowres)-1;
2681     const int h_edge_pos = s->h_edge_pos >> lowres;
2682     const int v_edge_pos = s->v_edge_pos >> lowres;
2683     linesize   = s->current_picture.linesize[0] << field_based;
2684     uvlinesize = s->current_picture.linesize[1] << field_based;
2685
2686     if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2687         motion_x/=2;
2688         motion_y/=2;
2689     }
2690     
2691     if(field_based){
2692         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2693     }
2694
2695     sx= motion_x & s_mask;
2696     sy= motion_y & s_mask;
2697     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2698     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2699     
2700     if (s->out_format == FMT_H263) {
2701         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2702         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2703         uvsrc_x = src_x>>1;
2704         uvsrc_y = src_y>>1;
2705     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2706         mx = motion_x / 4;
2707         my = motion_y / 4;
2708         uvsx = (2*mx) & s_mask;
2709         uvsy = (2*my) & s_mask;
2710         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2711         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2712     } else {
2713         mx = motion_x / 2;
2714         my = motion_y / 2;
2715         uvsx = mx & s_mask;
2716         uvsy = my & s_mask;
2717         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2718         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2719     }
2720
2721     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2722     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2723     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2724
2725     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2726        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2727             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2728                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2729             ptr_y = s->edge_emu_buffer;
2730             if(!(s->flags&CODEC_FLAG_GRAY)){
2731                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2732                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2733                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2734                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2735                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2736                 ptr_cb= uvbuf;
2737                 ptr_cr= uvbuf+16;
2738             }
2739     }
2740
2741     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2742         dest_y += s->linesize;
2743         dest_cb+= s->uvlinesize;
2744         dest_cr+= s->uvlinesize;
2745     }
2746
2747     if(field_select){
2748         ptr_y += s->linesize;
2749         ptr_cb+= s->uvlinesize;
2750         ptr_cr+= s->uvlinesize;
2751     }
2752
2753     sx <<= 2 - lowres;
2754     sy <<= 2 - lowres;
2755     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2756     
2757     if(!(s->flags&CODEC_FLAG_GRAY)){
2758         uvsx <<= 2 - lowres;
2759         uvsy <<= 2 - lowres;
2760         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2761         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2762     }
2763     //FIXME h261 lowres loop filter
2764 }
2765
2766 //FIXME move to dsputil, avg variant, 16x16 version
2767 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2768     int x;
2769     uint8_t * const top   = src[1];
2770     uint8_t * const left  = src[2];
2771     uint8_t * const mid   = src[0];
2772     uint8_t * const right = src[3];
2773     uint8_t * const bottom= src[4];
2774 #define OBMC_FILTER(x, t, l, m, r, b)\
2775     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2776 #define OBMC_FILTER4(x, t, l, m, r, b)\
2777     OBMC_FILTER(x         , t, l, m, r, b);\
2778     OBMC_FILTER(x+1       , t, l, m, r, b);\
2779     OBMC_FILTER(x  +stride, t, l, m, r, b);\
2780     OBMC_FILTER(x+1+stride, t, l, m, r, b);
2781     
2782     x=0;
2783     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2784     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2785     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2786     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2787     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2788     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2789     x+= stride;
2790     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2791     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2792     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2793     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2794     x+= stride;
2795     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2796     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2797     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2798     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2799     x+= 2*stride;
2800     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2801     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2802     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2803     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2804     x+= 2*stride;
2805     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2806     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2807     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2808     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2809     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2810     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2811     x+= stride;
2812     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2813     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2814     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2815     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2816 }
2817
2818 /* obmc for 1 8x8 luma block */
2819 static inline void obmc_motion(MpegEncContext *s,
2820                                uint8_t *dest, uint8_t *src,
2821                                int src_x, int src_y,
2822                                op_pixels_func *pix_op,
2823                                int16_t mv[5][2]/* mid top left right bottom*/)
2824 #define MID    0
2825 {
2826     int i;
2827     uint8_t *ptr[5];
2828     
2829     assert(s->quarter_sample==0);
2830     
2831     for(i=0; i<5; i++){
2832         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2833             ptr[i]= ptr[MID];
2834         }else{
2835             ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2836             hpel_motion(s, ptr[i], src, 0, 0,
2837                         src_x, src_y,
2838                         s->width, s->height, s->linesize,
2839                         s->h_edge_pos, s->v_edge_pos,
2840                         8, 8, pix_op,
2841                         mv[i][0], mv[i][1]);
2842         }
2843     }
2844
2845     put_obmc(dest, ptr, s->linesize);                
2846 }
2847
2848 static inline void qpel_motion(MpegEncContext *s,
2849                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2850                                int field_based, int bottom_field, int field_select,
2851                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2852                                qpel_mc_func (*qpix_op)[16],
2853                                int motion_x, int motion_y, int h)
2854 {
2855     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2856     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2857
2858     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2859     src_x = s->mb_x *  16                 + (motion_x >> 2);
2860     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2861
2862     v_edge_pos = s->v_edge_pos >> field_based;
2863     linesize = s->linesize << field_based;
2864     uvlinesize = s->uvlinesize << field_based;
2865     
2866     if(field_based){
2867         mx= motion_x/2;
2868         my= motion_y>>1;
2869     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2870         static const int rtab[8]= {0,0,1,1,0,0,0,1};
2871         mx= (motion_x>>1) + rtab[motion_x&7];
2872         my= (motion_y>>1) + rtab[motion_y&7];
2873     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2874         mx= (motion_x>>1)|(motion_x&1);
2875         my= (motion_y>>1)|(motion_y&1);
2876     }else{
2877         mx= motion_x/2;
2878         my= motion_y/2;
2879     }
2880     mx= (mx>>1)|(mx&1);
2881     my= (my>>1)|(my&1);
2882
2883     uvdxy= (mx&1) | ((my&1)<<1);
2884     mx>>=1;
2885     my>>=1;
2886
2887     uvsrc_x = s->mb_x *  8                 + mx;
2888     uvsrc_y = s->mb_y * (8 >> field_based) + my;
2889
2890     ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2891     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2892     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2893
2894     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2895        || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2896         ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2897                          src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2898         ptr_y= s->edge_emu_buffer;
2899         if(!(s->flags&CODEC_FLAG_GRAY)){
2900             uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2901             ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2902                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2903             ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2904                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2905             ptr_cb= uvbuf;
2906             ptr_cr= uvbuf + 16;
2907         }
2908     }
2909
2910     if(!field_based)
2911         qpix_op[0][dxy](dest_y, ptr_y, linesize);
2912     else{
2913         if(bottom_field){
2914             dest_y += s->linesize;
2915             dest_cb+= s->uvlinesize;
2916             dest_cr+= s->uvlinesize;
2917         }
2918
2919         if(field_select){
2920             ptr_y  += s->linesize;
2921             ptr_cb += s->uvlinesize;
2922             ptr_cr += s->uvlinesize;
2923         }
2924         //damn interlaced mode
2925         //FIXME boundary mirroring is not exactly correct here
2926         qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2927         qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2928     }
2929     if(!(s->flags&CODEC_FLAG_GRAY)){
2930         pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2931         pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2932     }
2933 }
2934
2935 inline int ff_h263_round_chroma(int x){
2936     if (x >= 0)
2937         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2938     else {
2939         x = -x;
2940         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2941     }
2942 }
2943
2944 /**
2945  * h263 chorma 4mv motion compensation.
2946  */
2947 static inline void chroma_4mv_motion(MpegEncContext *s,
2948                                      uint8_t *dest_cb, uint8_t *dest_cr,
2949                                      uint8_t **ref_picture,
2950                                      op_pixels_func *pix_op,
2951                                      int mx, int my){
2952     int dxy, emu=0, src_x, src_y, offset;
2953     uint8_t *ptr;
2954     
2955     /* In case of 8X8, we construct a single chroma motion vector
2956        with a special rounding */
2957     mx= ff_h263_round_chroma(mx);
2958     my= ff_h263_round_chroma(my);
2959     
2960     dxy = ((my & 1) << 1) | (mx & 1);
2961     mx >>= 1;
2962     my >>= 1;
2963
2964     src_x = s->mb_x * 8 + mx;
2965     src_y = s->mb_y * 8 + my;
2966     src_x = clip(src_x, -8, s->width/2);
2967     if (src_x == s->width/2)
2968         dxy &= ~1;
2969     src_y = clip(src_y, -8, s->height/2);
2970     if (src_y == s->height/2)
2971         dxy &= ~2;
2972     
2973     offset = (src_y * (s->uvlinesize)) + src_x;
2974     ptr = ref_picture[1] + offset;
2975     if(s->flags&CODEC_FLAG_EMU_EDGE){
2976         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2977            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2978             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);
2979             ptr= s->edge_emu_buffer;
2980             emu=1;
2981         }
2982     }
2983     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2984
2985     ptr = ref_picture[2] + offset;
2986     if(emu){
2987         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);
2988         ptr= s->edge_emu_buffer;
2989     }
2990     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2991 }
2992
2993 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2994                                      uint8_t *dest_cb, uint8_t *dest_cr,
2995                                      uint8_t **ref_picture,
2996                                      h264_chroma_mc_func *pix_op,
2997                                      int mx, int my){
2998     const int lowres= s->avctx->lowres;
2999     const int block_s= 8>>lowres;
3000     const int s_mask= (2<<lowres)-1;
3001     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3002     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3003     int emu=0, src_x, src_y, offset, sx, sy;
3004     uint8_t *ptr;
3005     
3006     if(s->quarter_sample){
3007         mx/=2;
3008         my/=2;
3009     }
3010
3011     /* In case of 8X8, we construct a single chroma motion vector
3012        with a special rounding */
3013     mx= ff_h263_round_chroma(mx);
3014     my= ff_h263_round_chroma(my);
3015     
3016     sx= mx & s_mask;
3017     sy= my & s_mask;
3018     src_x = s->mb_x*block_s + (mx >> (lowres+1));
3019     src_y = s->mb_y*block_s + (my >> (lowres+1));
3020     
3021     offset = src_y * s->uvlinesize + src_x;
3022     ptr = ref_picture[1] + offset;
3023     if(s->flags&CODEC_FLAG_EMU_EDGE){
3024         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3025            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3026             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3027             ptr= s->edge_emu_buffer;
3028             emu=1;
3029         }
3030     }     
3031     sx <<= 2 - lowres;
3032     sy <<= 2 - lowres;
3033     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3034           
3035     ptr = ref_picture[2] + offset;
3036     if(emu){
3037         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3038         ptr= s->edge_emu_buffer;
3039     }
3040     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3041 }
3042
3043 /**
3044  * motion compesation of a single macroblock
3045  * @param s context
3046  * @param dest_y luma destination pointer
3047  * @param dest_cb chroma cb/u destination pointer
3048  * @param dest_cr chroma cr/v destination pointer
3049  * @param dir direction (0->forward, 1->backward)
3050  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3051  * @param pic_op halfpel motion compensation function (average or put normally)
3052  * @param pic_op qpel motion compensation function (average or put normally)
3053  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3054  */
3055 static inline void MPV_motion(MpegEncContext *s, 
3056                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3057                               int dir, uint8_t **ref_picture, 
3058                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3059 {
3060     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3061     int mb_x, mb_y, i;
3062     uint8_t *ptr, *dest;
3063
3064     mb_x = s->mb_x;
3065     mb_y = s->mb_y;
3066
3067     if(s->obmc && s->pict_type != B_TYPE){
3068         int16_t mv_cache[4][4][2];
3069         const int xy= s->mb_x + s->mb_y*s->mb_stride;
3070         const int mot_stride= s->b8_stride;
3071         const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3072
3073         assert(!s->mb_skiped);
3074                 
3075         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3076         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3077         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3078
3079         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3080             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3081         }else{
3082             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3083         }
3084
3085         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3086             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3087             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3088         }else{
3089             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3090             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3091         }
3092
3093         if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3094             *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3095             *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3096         }else{
3097             *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3098             *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3099         }
3100         
3101         mx = 0;
3102         my = 0;
3103         for(i=0;i<4;i++) {
3104             const int x= (i&1)+1;
3105             const int y= (i>>1)+1;
3106             int16_t mv[5][2]= {
3107                 {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3108                 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3109                 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3110                 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3111                 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3112             //FIXME cleanup
3113             obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3114                         ref_picture[0],
3115                         mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3116                         pix_op[1],
3117                         mv);
3118
3119             mx += mv[0][0];
3120             my += mv[0][1];
3121         }
3122         if(!(s->flags&CODEC_FLAG_GRAY))
3123             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3124
3125         return;
3126     }
3127    
3128     switch(s->mv_type) {
3129     case MV_TYPE_16X16:
3130 #ifdef CONFIG_RISKY
3131         if(s->mcsel){
3132             if(s->real_sprite_warping_points==1){
3133                 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3134                             ref_picture);
3135             }else{
3136                 gmc_motion(s, dest_y, dest_cb, dest_cr,
3137                             ref_picture);
3138             }
3139         }else if(s->quarter_sample){
3140             qpel_motion(s, dest_y, dest_cb, dest_cr, 
3141                         0, 0, 0,
3142                         ref_picture, pix_op, qpix_op,
3143                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3144         }else if(s->mspel){
3145             ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3146                         ref_picture, pix_op,
3147                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3148         }else
3149 #endif
3150         {
3151             mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3152                         0, 0, 0,
3153                         ref_picture, pix_op,
3154                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3155         }           
3156         break;
3157     case MV_TYPE_8X8:
3158         mx = 0;
3159         my = 0;
3160         if(s->quarter_sample){
3161             for(i=0;i<4;i++) {
3162                 motion_x = s->mv[dir][i][0];
3163                 motion_y = s->mv[dir][i][1];
3164
3165                 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3166                 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3167                 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3168                     
3169                 /* WARNING: do no forget half pels */
3170                 src_x = clip(src_x, -16, s->width);
3171                 if (src_x == s->width)
3172                     dxy &= ~3;
3173                 src_y = clip(src_y, -16, s->height);
3174                 if (src_y == s->height)
3175                     dxy &= ~12;
3176                     
3177                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3178                 if(s->flags&CODEC_FLAG_EMU_EDGE){
3179                     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
3180                        || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3181                         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);
3182                         ptr= s->edge_emu_buffer;
3183                     }
3184                 }
3185                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3186                 qpix_op[1][dxy](dest, ptr, s->linesize);
3187
3188                 mx += s->mv[dir][i][0]/2;
3189                 my += s->mv[dir][i][1]/2;
3190             }
3191         }else{
3192             for(i=0;i<4;i++) {
3193                 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3194                             ref_picture[0], 0, 0,
3195                             mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3196                             s->width, s->height, s->linesize,
3197                             s->h_edge_pos, s->v_edge_pos,
3198                             8, 8, pix_op[1],
3199                             s->mv[dir][i][0], s->mv[dir][i][1]);
3200
3201                 mx += s->mv[dir][i][0];
3202                 my += s->mv[dir][i][1];
3203             }
3204         }
3205
3206         if(!(s->flags&CODEC_FLAG_GRAY))
3207             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3208         break;
3209     case MV_TYPE_FIELD:
3210         if (s->picture_structure == PICT_FRAME) {
3211             if(s->quarter_sample){
3212                 for(i=0; i<2; i++){
3213                     qpel_motion(s, dest_y, dest_cb, dest_cr,
3214                                 1, i, s->field_select[dir][i],
3215                                 ref_picture, pix_op, qpix_op,
3216                                 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3217                 }
3218             }else{
3219                 /* top field */       
3220                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3221                             1, 0, s->field_select[dir][0],
3222                             ref_picture, pix_op,
3223                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
3224                 /* bottom field */
3225                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3226                             1, 1, s->field_select[dir][1],
3227                             ref_picture, pix_op,
3228                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
3229             }
3230         } else {
3231             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3232                 ref_picture= s->current_picture_ptr->data;
3233             } 
3234
3235             mpeg_motion(s, dest_y, dest_cb, dest_cr,
3236                         0, 0, s->field_select[dir][0],
3237                         ref_picture, pix_op,
3238                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3239         }
3240         break;
3241     case MV_TYPE_16X8:
3242         for(i=0; i<2; i++){
3243             uint8_t ** ref2picture;
3244
3245             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3246                 ref2picture= ref_picture;
3247             }else{
3248                 ref2picture= s->current_picture_ptr->data;
3249             } 
3250
3251             mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3252                         0, 0, s->field_select[dir][i],
3253                         ref2picture, pix_op,
3254                         s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3255                 
3256             dest_y += 16*s->linesize;
3257             dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3258             dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3259         }        
3260         break;
3261     case MV_TYPE_DMV:
3262         if(s->picture_structure == PICT_FRAME){
3263             for(i=0; i<2; i++){
3264                 int j;
3265                 for(j=0; j<2; j++){
3266                     mpeg_motion(s, dest_y, dest_cb, dest_cr,
3267                                 1, j, j^i,
3268                                 ref_picture, pix_op,
3269                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3270                 }
3271                 pix_op = s->dsp.avg_pixels_tab; 
3272             }
3273         }else{
3274             for(i=0; i<2; i++){
3275                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3276                             0, 0, s->picture_structure != i+1,
3277                             ref_picture, pix_op,
3278                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3279
3280                 // after put we make avg of the same block
3281                 pix_op=s->dsp.avg_pixels_tab; 
3282
3283                 //opposite parity is always in the same frame if this is second field
3284                 if(!s->first_field){
3285                     ref_picture = s->current_picture_ptr->data;    
3286                 }
3287             }
3288         }
3289     break;
3290     default: assert(0);
3291     }
3292 }
3293
3294 /**
3295  * motion compesation of a single macroblock
3296  * @param s context
3297  * @param dest_y luma destination pointer
3298  * @param dest_cb chroma cb/u destination pointer
3299  * @param dest_cr chroma cr/v destination pointer
3300  * @param dir direction (0->forward, 1->backward)
3301  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3302  * @param pic_op halfpel motion compensation function (average or put normally)
3303  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3304  */
3305 static inline void MPV_motion_lowres(MpegEncContext *s, 
3306                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3307                               int dir, uint8_t **ref_picture, 
3308                               h264_chroma_mc_func *pix_op)
3309 {
3310     int mx, my;
3311     int mb_x, mb_y, i;
3312     const int lowres= s->avctx->lowres;
3313     const int block_s= 8>>lowres;    
3314
3315     mb_x = s->mb_x;
3316     mb_y = s->mb_y;
3317
3318     switch(s->mv_type) {
3319     case MV_TYPE_16X16:
3320         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3321                     0, 0, 0,
3322                     ref_picture, pix_op,
3323                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3324         break;
3325     case MV_TYPE_8X8:
3326         mx = 0;
3327         my = 0;
3328             for(i=0;i<4;i++) {
3329                 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3330                             ref_picture[0], 0, 0,
3331                             (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3332                             s->width, s->height, s->linesize,
3333                             s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3334                             block_s, block_s, pix_op,
3335                             s->mv[dir][i][0], s->mv[dir][i][1]);
3336
3337                 mx += s->mv[dir][i][0];
3338                 my += s->mv[dir][i][1];
3339             }
3340
3341         if(!(s->flags&CODEC_FLAG_GRAY))
3342             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3343         break;
3344     case MV_TYPE_FIELD:
3345         if (s->picture_structure == PICT_FRAME) {
3346             /* top field */       
3347             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3348                         1, 0, s->field_select[dir][0],
3349                         ref_picture, pix_op,
3350                         s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3351             /* bottom field */
3352             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3353                         1, 1, s->field_select[dir][1],
3354                         ref_picture, pix_op,
3355                         s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3356         } else {
3357             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3358                 ref_picture= s->current_picture_ptr->data;
3359             } 
3360
3361             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3362                         0, 0, s->field_select[dir][0],
3363                         ref_picture, pix_op,
3364                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3365         }
3366         break;
3367     case MV_TYPE_16X8:
3368         for(i=0; i<2; i++){
3369             uint8_t ** ref2picture;
3370
3371             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3372                 ref2picture= ref_picture;
3373             }else{
3374                 ref2picture= s->current_picture_ptr->data;
3375             } 
3376
3377             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3378                         0, 0, s->field_select[dir][i],
3379                         ref2picture, pix_op,
3380                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3381                 
3382             dest_y += 2*block_s*s->linesize;
3383             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3384             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3385         }        
3386         break;
3387     case MV_TYPE_DMV:
3388         if(s->picture_structure == PICT_FRAME){
3389             for(i=0; i<2; i++){
3390                 int j;
3391                 for(j=0; j<2; j++){
3392                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3393                                 1, j, j^i,
3394                                 ref_picture, pix_op,
3395                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3396                 }
3397                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3398             }
3399         }else{
3400             for(i=0; i<2; i++){
3401                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3402                             0, 0, s->picture_structure != i+1,
3403                             ref_picture, pix_op,
3404                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3405
3406                 // after put we make avg of the same block
3407                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3408
3409                 //opposite parity is always in the same frame if this is second field
3410                 if(!s->first_field){
3411                     ref_picture = s->current_picture_ptr->data;    
3412                 }
3413             }
3414         }
3415     break;
3416     default: assert(0);
3417     }
3418 }
3419
3420 /* put block[] to dest[] */
3421 static inline void put_dct(MpegEncContext *s, 
3422                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3423 {
3424     s->dct_unquantize_intra(s, block, i, qscale);
3425     s->dsp.idct_put (dest, line_size, block);
3426 }
3427
3428 /* add block[] to dest[] */
3429 static inline void add_dct(MpegEncContext *s, 
3430                            DCTELEM *block, int i, uint8_t *dest, int line_size)
3431 {
3432     if (s->block_last_index[i] >= 0) {
3433         s->dsp.idct_add (dest, line_size, block);
3434     }
3435 }
3436
3437 static inline void add_dequant_dct(MpegEncContext *s, 
3438                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3439 {
3440     if (s->block_last_index[i] >= 0) {
3441         s->dct_unquantize_inter(s, block, i, qscale);
3442
3443         s->dsp.idct_add (dest, line_size, block);
3444     }
3445 }
3446
3447 /**
3448  * cleans dc, ac, coded_block for the current non intra MB
3449  */
3450 void ff_clean_intra_table_entries(MpegEncContext *s)
3451 {
3452     int wrap = s->b8_stride;
3453     int xy = s->block_index[0];
3454     
3455     s->dc_val[0][xy           ] = 
3456     s->dc_val[0][xy + 1       ] = 
3457     s->dc_val[0][xy     + wrap] =
3458     s->dc_val[0][xy + 1 + wrap] = 1024;
3459     /* ac pred */
3460     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3461     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3462     if (s->msmpeg4_version>=3) {
3463         s->coded_block[xy           ] =
3464         s->coded_block[xy + 1       ] =
3465         s->coded_block[xy     + wrap] =
3466         s->coded_block[xy + 1 + wrap] = 0;
3467     }
3468     /* chroma */
3469     wrap = s->mb_stride;
3470     xy = s->mb_x + s->mb_y * wrap;
3471     s->dc_val[1][xy] =
3472     s->dc_val[2][xy] = 1024;
3473     /* ac pred */
3474     memset(s-&