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