2269609b1de1fc605ba2bac92a1802ba9851233f
[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->input_picture[0]->pict_type){
2027                 /* user selected pict_type */
2028                 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
2029                     if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
2030                 }
2031             
2032                 if(b_frames > s->max_b_frames){
2033                     av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2034                     b_frames = s->max_b_frames;
2035                 }
2036             }else if(s->avctx->b_frame_strategy==0){
2037                 b_frames= s->max_b_frames;
2038                 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2039             }else if(s->avctx->b_frame_strategy==1){
2040                 for(i=1; i<s->max_b_frames+1; i++){
2041                     if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2042                         s->input_picture[i]->b_frame_score= 
2043                             get_intra_count(s, s->input_picture[i  ]->data[0], 
2044                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
2045                     }
2046                 }
2047                 for(i=0; i<s->max_b_frames; i++){
2048                     if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2049                 }
2050                                 
2051                 b_frames= FFMAX(0, i-1);
2052                 
2053                 /* reset scores */
2054                 for(i=0; i<b_frames+1; i++){
2055                     s->input_picture[i]->b_frame_score=0;
2056                 }
2057             }else{
2058                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2059                 b_frames=0;
2060             }
2061
2062             emms_c();
2063 //static int b_count=0;
2064 //b_count+= b_frames;
2065 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2066             if(s->picture_in_gop_number + b_frames >= s->gop_size){
2067                 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2068                     b_frames=0;
2069                 s->input_picture[b_frames]->pict_type= I_TYPE;
2070             }
2071             
2072             if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2073                && b_frames
2074                && s->input_picture[b_frames]->pict_type== I_TYPE)
2075                 b_frames--;
2076
2077             s->reordered_input_picture[0]= s->input_picture[b_frames];
2078             if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2079                 s->reordered_input_picture[0]->pict_type= P_TYPE;
2080             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2081             for(i=0; i<b_frames; i++){
2082                 s->reordered_input_picture[i+1]= s->input_picture[i];
2083                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2084                 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2085             }
2086         }
2087     }
2088     
2089     if(s->reordered_input_picture[0]){
2090         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2091
2092         copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2093
2094         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2095             // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2096         
2097             int i= ff_find_unused_picture(s, 0);
2098             Picture *pic= &s->picture[i];
2099
2100             /* mark us unused / free shared pic */
2101             for(i=0; i<4; i++)
2102                 s->reordered_input_picture[0]->data[i]= NULL;
2103             s->reordered_input_picture[0]->type= 0;
2104             
2105             pic->reference              = s->reordered_input_picture[0]->reference;
2106             
2107             alloc_picture(s, pic, 0);
2108
2109             copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2110
2111             s->current_picture_ptr= pic;
2112         }else{
2113             // input is not a shared pix -> reuse buffer for current_pix
2114
2115             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2116                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2117             
2118             s->current_picture_ptr= s->reordered_input_picture[0];
2119             for(i=0; i<4; i++){
2120                 s->new_picture.data[i]+=16;
2121             }
2122         }
2123         copy_picture(&s->current_picture, s->current_picture_ptr);
2124     
2125         s->picture_number= s->new_picture.display_picture_number;
2126 //printf("dpn:%d\n", s->picture_number);
2127     }else{
2128        memset(&s->new_picture, 0, sizeof(Picture));
2129     }
2130 }
2131
2132 int MPV_encode_picture(AVCodecContext *avctx,
2133                        unsigned char *buf, int buf_size, void *data)
2134 {
2135     MpegEncContext *s = avctx->priv_data;
2136     AVFrame *pic_arg = data;
2137     int i, stuffing_count;
2138
2139     if(avctx->pix_fmt != PIX_FMT_YUV420P){
2140         av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2141         return -1;
2142     }
2143     
2144     for(i=0; i<avctx->thread_count; i++){
2145         int start_y= s->thread_context[i]->start_mb_y;
2146         int   end_y= s->thread_context[i]->  end_mb_y;
2147         int h= s->mb_height;
2148         uint8_t *start= buf + buf_size*start_y/h;
2149         uint8_t *end  = buf + buf_size*  end_y/h;
2150
2151         init_put_bits(&s->thread_context[i]->pb, start, end - start);
2152     }
2153
2154     s->picture_in_gop_number++;
2155
2156     if(load_input_picture(s, pic_arg) < 0)
2157         return -1;
2158     
2159     select_input_picture(s);
2160     
2161     /* output? */
2162     if(s->new_picture.data[0]){
2163         s->pict_type= s->new_picture.pict_type;
2164 //emms_c();
2165 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2166         MPV_frame_start(s, avctx);
2167
2168         encode_picture(s, s->picture_number);
2169         
2170         avctx->real_pict_num  = s->picture_number;
2171         avctx->header_bits = s->header_bits;
2172         avctx->mv_bits     = s->mv_bits;
2173         avctx->misc_bits   = s->misc_bits;
2174         avctx->i_tex_bits  = s->i_tex_bits;
2175         avctx->p_tex_bits  = s->p_tex_bits;
2176         avctx->i_count     = s->i_count;
2177         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2178         avctx->skip_count  = s->skip_count;
2179
2180         MPV_frame_end(s);
2181
2182         if (s->out_format == FMT_MJPEG)
2183             mjpeg_picture_trailer(s);
2184         
2185         if(s->flags&CODEC_FLAG_PASS1)
2186             ff_write_pass1_stats(s);
2187
2188         for(i=0; i<4; i++){
2189             avctx->error[i] += s->current_picture_ptr->error[i];
2190         }
2191
2192         flush_put_bits(&s->pb);
2193         s->frame_bits  = put_bits_count(&s->pb);
2194
2195         stuffing_count= ff_vbv_update(s, s->frame_bits);
2196         if(stuffing_count){
2197             switch(s->codec_id){
2198             case CODEC_ID_MPEG1VIDEO:
2199             case CODEC_ID_MPEG2VIDEO:
2200                 while(stuffing_count--){
2201                     put_bits(&s->pb, 8, 0);
2202                 }
2203             break;
2204             case CODEC_ID_MPEG4:
2205                 put_bits(&s->pb, 16, 0);
2206                 put_bits(&s->pb, 16, 0x1C3);
2207                 stuffing_count -= 4;
2208                 while(stuffing_count--){
2209                     put_bits(&s->pb, 8, 0xFF);
2210                 }
2211             break;
2212             default:
2213                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2214             }
2215             flush_put_bits(&s->pb);
2216             s->frame_bits  = put_bits_count(&s->pb);
2217         }
2218
2219         /* update mpeg1/2 vbv_delay for CBR */    
2220         if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2221            && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2222             int vbv_delay;
2223
2224             assert(s->repeat_first_field==0);
2225             
2226             vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2227             assert(vbv_delay < 0xFFFF);
2228
2229             s->vbv_delay_ptr[0] &= 0xF8;
2230             s->vbv_delay_ptr[0] |= vbv_delay>>13;
2231             s->vbv_delay_ptr[1]  = vbv_delay>>5;
2232             s->vbv_delay_ptr[2] &= 0x07;
2233             s->vbv_delay_ptr[2] |= vbv_delay<<3;
2234         }
2235         s->total_bits += s->frame_bits;
2236         avctx->frame_bits  = s->frame_bits;
2237     }else{
2238         assert((pbBufPtr(&s->pb) == s->pb.buf));
2239         s->frame_bits=0;
2240     }
2241     assert((s->frame_bits&7)==0);
2242     
2243     return s->frame_bits/8;
2244 }
2245
2246 #endif //CONFIG_ENCODERS
2247
2248 static inline void gmc1_motion(MpegEncContext *s,
2249                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2250                                uint8_t **ref_picture)
2251 {
2252     uint8_t *ptr;
2253     int offset, src_x, src_y, linesize, uvlinesize;
2254     int motion_x, motion_y;
2255     int emu=0;
2256
2257     motion_x= s->sprite_offset[0][0];
2258     motion_y= s->sprite_offset[0][1];
2259     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2260     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2261     motion_x<<=(3-s->sprite_warping_accuracy);
2262     motion_y<<=(3-s->sprite_warping_accuracy);
2263     src_x = clip(src_x, -16, s->width);
2264     if (src_x == s->width)
2265         motion_x =0;
2266     src_y = clip(src_y, -16, s->height);
2267     if (src_y == s->height)
2268         motion_y =0;
2269
2270     linesize = s->linesize;
2271     uvlinesize = s->uvlinesize;
2272     
2273     ptr = ref_picture[0] + (src_y * linesize) + src_x;
2274
2275     if(s->flags&CODEC_FLAG_EMU_EDGE){
2276         if(   (unsigned)src_x >= s->h_edge_pos - 17
2277            || (unsigned)src_y >= s->v_edge_pos - 17){
2278             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2279             ptr= s->edge_emu_buffer;
2280         }
2281     }
2282     
2283     if((motion_x|motion_y)&7){
2284         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2285         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2286     }else{
2287         int dxy;
2288         
2289         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2290         if (s->no_rounding){
2291             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2292         }else{
2293             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2294         }
2295     }
2296     
2297     if(s->flags&CODEC_FLAG_GRAY) return;
2298
2299     motion_x= s->sprite_offset[1][0];
2300     motion_y= s->sprite_offset[1][1];
2301     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2302     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2303     motion_x<<=(3-s->sprite_warping_accuracy);
2304     motion_y<<=(3-s->sprite_warping_accuracy);
2305     src_x = clip(src_x, -8, s->width>>1);
2306     if (src_x == s->width>>1)
2307         motion_x =0;
2308     src_y = clip(src_y, -8, s->height>>1);
2309     if (src_y == s->height>>1)
2310         motion_y =0;
2311
2312     offset = (src_y * uvlinesize) + src_x;
2313     ptr = ref_picture[1] + offset;
2314     if(s->flags&CODEC_FLAG_EMU_EDGE){
2315         if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2316            || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2317             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);
2318             ptr= s->edge_emu_buffer;
2319             emu=1;
2320         }
2321     }
2322     s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2323     
2324     ptr = ref_picture[2] + offset;
2325     if(emu){
2326         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);
2327         ptr= s->edge_emu_buffer;
2328     }
2329     s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2330     
2331     return;
2332 }
2333
2334 static inline void gmc_motion(MpegEncContext *s,
2335                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2336                                uint8_t **ref_picture)
2337 {
2338     uint8_t *ptr;
2339     int linesize, uvlinesize;
2340     const int a= s->sprite_warping_accuracy;
2341     int ox, oy;
2342
2343     linesize = s->linesize;
2344     uvlinesize = s->uvlinesize;
2345
2346     ptr = ref_picture[0];
2347
2348     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2349     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2350
2351     s->dsp.gmc(dest_y, ptr, linesize, 16,
2352            ox, 
2353            oy, 
2354            s->sprite_delta[0][0], s->sprite_delta[0][1],
2355            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2356            a+1, (1<<(2*a+1)) - s->no_rounding,
2357            s->h_edge_pos, s->v_edge_pos);
2358     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2359            ox + s->sprite_delta[0][0]*8, 
2360            oy + s->sprite_delta[1][0]*8, 
2361            s->sprite_delta[0][0], s->sprite_delta[0][1],
2362            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2363            a+1, (1<<(2*a+1)) - s->no_rounding,
2364            s->h_edge_pos, s->v_edge_pos);
2365
2366     if(s->flags&CODEC_FLAG_GRAY) return;
2367
2368     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2369     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2370
2371     ptr = ref_picture[1];
2372     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2373            ox, 
2374            oy, 
2375            s->sprite_delta[0][0], s->sprite_delta[0][1],
2376            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2377            a+1, (1<<(2*a+1)) - s->no_rounding,
2378            s->h_edge_pos>>1, s->v_edge_pos>>1);
2379     
2380     ptr = ref_picture[2];
2381     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2382            ox, 
2383            oy, 
2384            s->sprite_delta[0][0], s->sprite_delta[0][1],
2385            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2386            a+1, (1<<(2*a+1)) - s->no_rounding,
2387            s->h_edge_pos>>1, s->v_edge_pos>>1);
2388 }
2389
2390 /**
2391  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2392  * @param buf destination buffer
2393  * @param src source buffer
2394  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2395  * @param block_w width of block
2396  * @param block_h height of block
2397  * @param src_x x coordinate of the top left sample of the block in the source buffer
2398  * @param src_y y coordinate of the top left sample of the block in the source buffer
2399  * @param w width of the source buffer
2400  * @param h height of the source buffer
2401  */
2402 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2403                                     int src_x, int src_y, int w, int h){
2404     int x, y;
2405     int start_y, start_x, end_y, end_x;
2406
2407     if(src_y>= h){
2408         src+= (h-1-src_y)*linesize;
2409         src_y=h-1;
2410     }else if(src_y<=-block_h){
2411         src+= (1-block_h-src_y)*linesize;
2412         src_y=1-block_h;
2413     }
2414     if(src_x>= w){
2415         src+= (w-1-src_x);
2416         src_x=w-1;
2417     }else if(src_x<=-block_w){
2418         src+= (1-block_w-src_x);
2419         src_x=1-block_w;
2420     }
2421
2422     start_y= FFMAX(0, -src_y);
2423     start_x= FFMAX(0, -src_x);
2424     end_y= FFMIN(block_h, h-src_y);
2425     end_x= FFMIN(block_w, w-src_x);
2426
2427     // copy existing part
2428     for(y=start_y; y<end_y; y++){
2429         for(x=start_x; x<end_x; x++){
2430             buf[x + y*linesize]= src[x + y*linesize];
2431         }
2432     }
2433
2434     //top
2435     for(y=0; y<start_y; y++){
2436         for(x=start_x; x<end_x; x++){
2437             buf[x + y*linesize]= buf[x + start_y*linesize];
2438         }
2439     }
2440
2441     //bottom
2442     for(y=end_y; y<block_h; y++){
2443         for(x=start_x; x<end_x; x++){
2444             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2445         }
2446     }
2447                                     
2448     for(y=0; y<block_h; y++){
2449        //left
2450         for(x=0; x<start_x; x++){
2451             buf[x + y*linesize]= buf[start_x + y*linesize];
2452         }
2453        
2454        //right
2455         for(x=end_x; x<block_w; x++){
2456             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2457         }
2458     }
2459 }
2460
2461 static inline int hpel_motion(MpegEncContext *s, 
2462                                   uint8_t *dest, uint8_t *src,
2463                                   int field_based, int field_select,
2464                                   int src_x, int src_y,
2465                                   int width, int height, int stride,
2466                                   int h_edge_pos, int v_edge_pos,
2467                                   int w, int h, op_pixels_func *pix_op,
2468                                   int motion_x, int motion_y)
2469 {
2470     int dxy;
2471     int emu=0;
2472
2473     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2474     src_x += motion_x >> 1;
2475     src_y += motion_y >> 1;
2476                 
2477     /* WARNING: do no forget half pels */
2478     src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2479     if (src_x == width)
2480         dxy &= ~1;
2481     src_y = clip(src_y, -16, height);
2482     if (src_y == height)
2483         dxy &= ~2;
2484     src += src_y * stride + src_x;
2485
2486     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2487         if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2488            || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2489             ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2490                              src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2491             src= s->edge_emu_buffer;
2492             emu=1;
2493         }
2494     }
2495     if(field_select)
2496         src += s->linesize;
2497     pix_op[dxy](dest, src, stride, h);
2498     return emu;
2499 }
2500
2501 /* apply one mpeg motion vector to the three components */
2502 static always_inline void mpeg_motion(MpegEncContext *s,
2503                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2504                                int field_based, int bottom_field, int field_select,
2505                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2506                                int motion_x, int motion_y, int h)
2507 {
2508     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2509     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2510     
2511 #if 0    
2512 if(s->quarter_sample)
2513 {
2514     motion_x>>=1;
2515     motion_y>>=1;
2516 }
2517 #endif
2518
2519     v_edge_pos = s->v_edge_pos >> field_based;
2520     linesize   = s->current_picture.linesize[0] << field_based;
2521     uvlinesize = s->current_picture.linesize[1] << field_based;
2522
2523     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2524     src_x = s->mb_x* 16               + (motion_x >> 1);
2525     src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2526
2527     if (s->out_format == FMT_H263) {
2528         if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2529             mx = (motion_x>>1)|(motion_x&1);
2530             my = motion_y >>1;
2531             uvdxy = ((my & 1) << 1) | (mx & 1);
2532             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2533             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2534         }else{
2535             uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2536             uvsrc_x = src_x>>1;
2537             uvsrc_y = src_y>>1;
2538         }
2539     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2540         mx = motion_x / 4;
2541         my = motion_y / 4;
2542         uvdxy = 0;
2543         uvsrc_x = s->mb_x*8 + mx;
2544         uvsrc_y = s->mb_y*8 + my;
2545     } else {
2546         if(s->chroma_y_shift){
2547             mx = motion_x / 2;
2548             my = motion_y / 2;
2549             uvdxy = ((my & 1) << 1) | (mx & 1);
2550             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2551             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2552         } else {
2553             if(s->chroma_x_shift){
2554             //Chroma422
2555                 mx = motion_x / 2;
2556                 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2557                 uvsrc_x = s->mb_x* 8           + (mx >> 1);
2558                 uvsrc_y = src_y;
2559             } else {
2560             //Chroma444
2561                 uvdxy = dxy;
2562                 uvsrc_x = src_x;
2563                 uvsrc_y = src_y;
2564             }
2565         }
2566     }
2567
2568     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2569     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2570     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2571
2572     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2573        || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2574             if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2575                s->codec_id == CODEC_ID_MPEG1VIDEO){
2576                 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2577                 return ;
2578             }
2579             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2580                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2581             ptr_y = s->edge_emu_buffer;
2582             if(!(s->flags&CODEC_FLAG_GRAY)){
2583                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2584                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2585                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2586                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2587                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2588                 ptr_cb= uvbuf;
2589                 ptr_cr= uvbuf+16;
2590             }
2591     }
2592
2593     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2594         dest_y += s->linesize;
2595         dest_cb+= s->uvlinesize;
2596         dest_cr+= s->uvlinesize;
2597     }
2598
2599     if(field_select){
2600         ptr_y += s->linesize;
2601         ptr_cb+= s->uvlinesize;
2602         ptr_cr+= s->uvlinesize;
2603     }
2604
2605     pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2606     
2607     if(!(s->flags&CODEC_FLAG_GRAY)){
2608         pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2609         pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2610     }
2611     if(s->out_format == FMT_H261){
2612         ff_h261_loop_filter(s);
2613     }
2614 }
2615
2616 /* apply one mpeg motion vector to the three components */
2617 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2618                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2619                                int field_based, int bottom_field, int field_select,
2620                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2621                                int motion_x, int motion_y, int h)
2622 {
2623     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2624     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2625     const int lowres= s->avctx->lowres;
2626     const int block_s= 8>>lowres;
2627     const int s_mask= (2<<lowres)-1;
2628     const int h_edge_pos = s->h_edge_pos >> lowres;
2629     const int v_edge_pos = s->v_edge_pos >> lowres;
2630     linesize   = s->current_picture.linesize[0] << field_based;
2631     uvlinesize = s->current_picture.linesize[1] << field_based;
2632
2633     if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2634         motion_x/=2;
2635         motion_y/=2;
2636     }
2637     
2638     if(field_based){
2639         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2640     }
2641
2642     sx= motion_x & s_mask;
2643     sy= motion_y & s_mask;
2644     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2645     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2646     
2647     if (s->out_format == FMT_H263) {
2648         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2649         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2650         uvsrc_x = src_x>>1;
2651         uvsrc_y = src_y>>1;
2652     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2653         mx = motion_x / 4;
2654         my = motion_y / 4;
2655         uvsx = (2*mx) & s_mask;
2656         uvsy = (2*my) & s_mask;
2657         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2658         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2659     } else {
2660         mx = motion_x / 2;
2661         my = motion_y / 2;
2662         uvsx = mx & s_mask;
2663         uvsy = my & s_mask;
2664         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2665         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2666     }
2667
2668     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2669     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2670     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2671
2672     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2673        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2674             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2675                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2676             ptr_y = s->edge_emu_buffer;
2677             if(!(s->flags&CODEC_FLAG_GRAY)){
2678                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2679                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2680                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2681                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2682                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2683                 ptr_cb= uvbuf;
2684                 ptr_cr= uvbuf+16;
2685             }
2686     }
2687
2688     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2689         dest_y += s->linesize;
2690         dest_cb+= s->uvlinesize;
2691         dest_cr+= s->uvlinesize;
2692     }
2693
2694     if(field_select){
2695         ptr_y += s->linesize;
2696         ptr_cb+= s->uvlinesize;
2697         ptr_cr+= s->uvlinesize;
2698     }
2699
2700     sx <<= 2 - lowres;
2701     sy <<= 2 - lowres;
2702     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2703     
2704     if(!(s->flags&CODEC_FLAG_GRAY)){
2705         uvsx <<= 2 - lowres;
2706         uvsy <<= 2 - lowres;
2707         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2708         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2709     }
2710     //FIXME h261 lowres loop filter
2711 }
2712
2713 //FIXME move to dsputil, avg variant, 16x16 version
2714 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2715     int x;
2716     uint8_t * const top   = src[1];
2717     uint8_t * const left  = src[2];
2718     uint8_t * const mid   = src[0];
2719     uint8_t * const right = src[3];
2720     uint8_t * const bottom= src[4];
2721 #define OBMC_FILTER(x, t, l, m, r, b)\
2722     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2723 #define OBMC_FILTER4(x, t, l, m, r, b)\
2724     OBMC_FILTER(x         , t, l, m, r, b);\
2725     OBMC_FILTER(x+1       , t, l, m, r, b);\
2726     OBMC_FILTER(x  +stride, t, l, m, r, b);\
2727     OBMC_FILTER(x+1+stride, t, l, m, r, b);
2728     
2729     x=0;
2730     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2731     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2732     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2733     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2734     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2735     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2736     x+= stride;
2737     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2738     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2739     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2740     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2741     x+= stride;
2742     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2743     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2744     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2745     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2746     x+= 2*stride;
2747     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2748     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2749     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2750     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2751     x+= 2*stride;
2752     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2753     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2754     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2755     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2756     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2757     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2758     x+= stride;
2759     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2760     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2761     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2762     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2763 }
2764
2765 /* obmc for 1 8x8 luma block */
2766 static inline void obmc_motion(MpegEncContext *s,
2767                                uint8_t *dest, uint8_t *src,
2768                                int src_x, int src_y,
2769                                op_pixels_func *pix_op,
2770                                int16_t mv[5][2]/* mid top left right bottom*/)
2771 #define MID    0
2772 {
2773     int i;
2774     uint8_t *ptr[5];
2775     
2776     assert(s->quarter_sample==0);
2777     
2778     for(i=0; i<5; i++){
2779         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2780             ptr[i]= ptr[MID];
2781         }else{
2782             ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2783             hpel_motion(s, ptr[i], src, 0, 0,
2784                         src_x, src_y,
2785                         s->width, s->height, s->linesize,
2786                         s->h_edge_pos, s->v_edge_pos,
2787                         8, 8, pix_op,
2788                         mv[i][0], mv[i][1]);
2789         }
2790     }
2791
2792     put_obmc(dest, ptr, s->linesize);                
2793 }
2794
2795 static inline void qpel_motion(MpegEncContext *s,
2796                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2797                                int field_based, int bottom_field, int field_select,
2798                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2799                                qpel_mc_func (*qpix_op)[16],
2800                                int motion_x, int motion_y, int h)
2801 {
2802     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2803     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2804
2805     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2806     src_x = s->mb_x *  16                 + (motion_x >> 2);
2807     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2808
2809     v_edge_pos = s->v_edge_pos >> field_based;
2810     linesize = s->linesize << field_based;
2811     uvlinesize = s->uvlinesize << field_based;
2812     
2813     if(field_based){
2814         mx= motion_x/2;
2815         my= motion_y>>1;
2816     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2817         static const int rtab[8]= {0,0,1,1,0,0,0,1};
2818         mx= (motion_x>>1) + rtab[motion_x&7];
2819         my= (motion_y>>1) + rtab[motion_y&7];
2820     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2821         mx= (motion_x>>1)|(motion_x&1);
2822         my= (motion_y>>1)|(motion_y&1);
2823     }else{
2824         mx= motion_x/2;
2825         my= motion_y/2;
2826     }
2827     mx= (mx>>1)|(mx&1);
2828     my= (my>>1)|(my&1);
2829
2830     uvdxy= (mx&1) | ((my&1)<<1);
2831     mx>>=1;
2832     my>>=1;
2833
2834     uvsrc_x = s->mb_x *  8                 + mx;
2835     uvsrc_y = s->mb_y * (8 >> field_based) + my;
2836
2837     ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2838     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2839     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2840
2841     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2842        || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2843         ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2844                          src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2845         ptr_y= s->edge_emu_buffer;
2846         if(!(s->flags&CODEC_FLAG_GRAY)){
2847             uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2848             ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2849                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2850             ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2851                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2852             ptr_cb= uvbuf;
2853             ptr_cr= uvbuf + 16;
2854         }
2855     }
2856
2857     if(!field_based)
2858         qpix_op[0][dxy](dest_y, ptr_y, linesize);
2859     else{
2860         if(bottom_field){
2861             dest_y += s->linesize;
2862             dest_cb+= s->uvlinesize;
2863             dest_cr+= s->uvlinesize;
2864         }
2865
2866         if(field_select){
2867             ptr_y  += s->linesize;
2868             ptr_cb += s->uvlinesize;
2869             ptr_cr += s->uvlinesize;
2870         }
2871         //damn interlaced mode
2872         //FIXME boundary mirroring is not exactly correct here
2873         qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2874         qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2875     }
2876     if(!(s->flags&CODEC_FLAG_GRAY)){
2877         pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2878         pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2879     }
2880 }
2881
2882 inline int ff_h263_round_chroma(int x){
2883     if (x >= 0)
2884         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2885     else {
2886         x = -x;
2887         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2888     }
2889 }
2890
2891 /**
2892  * h263 chorma 4mv motion compensation.
2893  */
2894 static inline void chroma_4mv_motion(MpegEncContext *s,
2895                                      uint8_t *dest_cb, uint8_t *dest_cr,
2896                                      uint8_t **ref_picture,
2897                                      op_pixels_func *pix_op,
2898                                      int mx, int my){
2899     int dxy, emu=0, src_x, src_y, offset;
2900     uint8_t *ptr;
2901     
2902     /* In case of 8X8, we construct a single chroma motion vector
2903        with a special rounding */
2904     mx= ff_h263_round_chroma(mx);
2905     my= ff_h263_round_chroma(my);
2906     
2907     dxy = ((my & 1) << 1) | (mx & 1);
2908     mx >>= 1;
2909     my >>= 1;
2910
2911     src_x = s->mb_x * 8 + mx;
2912     src_y = s->mb_y * 8 + my;
2913     src_x = clip(src_x, -8, s->width/2);
2914     if (src_x == s->width/2)
2915         dxy &= ~1;
2916     src_y = clip(src_y, -8, s->height/2);
2917     if (src_y == s->height/2)
2918         dxy &= ~2;
2919     
2920     offset = (src_y * (s->uvlinesize)) + src_x;
2921     ptr = ref_picture[1] + offset;
2922     if(s->flags&CODEC_FLAG_EMU_EDGE){
2923         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2924            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2925             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);
2926             ptr= s->edge_emu_buffer;
2927             emu=1;
2928         }
2929     }
2930     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2931
2932     ptr = ref_picture[2] + offset;
2933     if(emu){
2934         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);
2935         ptr= s->edge_emu_buffer;
2936     }
2937     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2938 }
2939
2940 /**
2941  * motion compesation of a single macroblock
2942  * @param s context
2943  * @param dest_y luma destination pointer
2944  * @param dest_cb chroma cb/u destination pointer
2945  * @param dest_cr chroma cr/v destination pointer
2946  * @param dir direction (0->forward, 1->backward)
2947  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2948  * @param pic_op halfpel motion compensation function (average or put normally)
2949  * @param pic_op qpel motion compensation function (average or put normally)
2950  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2951  */
2952 static inline void MPV_motion(MpegEncContext *s, 
2953                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2954                               int dir, uint8_t **ref_picture, 
2955                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2956 {
2957     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2958     int mb_x, mb_y, i;
2959     uint8_t *ptr, *dest;
2960
2961     mb_x = s->mb_x;
2962     mb_y = s->mb_y;
2963
2964     if(s->obmc && s->pict_type != B_TYPE){
2965         int16_t mv_cache[4][4][2];
2966         const int xy= s->mb_x + s->mb_y*s->mb_stride;
2967         const int mot_stride= s->b8_stride;
2968         const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2969
2970         assert(!s->mb_skiped);
2971                 
2972         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2973         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2974         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2975
2976         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2977             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2978         }else{
2979             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2980         }
2981
2982         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2983             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2984             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2985         }else{
2986             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2987             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2988         }
2989
2990         if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2991             *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2992             *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2993         }else{
2994             *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2995             *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2996         }
2997         
2998         mx = 0;
2999         my = 0;
3000         for(i=0;i<4;i++) {
3001             const int x= (i&1)+1;
3002             const int y= (i>>1)+1;
3003             int16_t mv[5][2]= {
3004                 {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3005                 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3006                 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3007                 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3008                 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3009             //FIXME cleanup
3010             obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3011                         ref_picture[0],
3012                         mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3013                         pix_op[1],
3014                         mv);
3015
3016             mx += mv[0][0];
3017             my += mv[0][1];
3018         }
3019         if(!(s->flags&CODEC_FLAG_GRAY))
3020             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3021
3022         return;
3023     }
3024    
3025     switch(s->mv_type) {
3026     case MV_TYPE_16X16:
3027 #ifdef CONFIG_RISKY
3028         if(s->mcsel){
3029             if(s->real_sprite_warping_points==1){
3030                 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3031                             ref_picture);
3032             }else{
3033                 gmc_motion(s, dest_y, dest_cb, dest_cr,
3034                             ref_picture);
3035             }
3036         }else if(s->quarter_sample){
3037             qpel_motion(s, dest_y, dest_cb, dest_cr, 
3038                         0, 0, 0,
3039                         ref_picture, pix_op, qpix_op,
3040                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3041         }else if(s->mspel){
3042             ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3043                         ref_picture, pix_op,
3044                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3045         }else
3046 #endif
3047         {
3048             mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3049                         0, 0, 0,
3050                         ref_picture, pix_op,
3051                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3052         }           
3053         break;
3054     case MV_TYPE_8X8:
3055         mx = 0;
3056         my = 0;
3057         if(s->quarter_sample){
3058             for(i=0;i<4;i++) {
3059                 motion_x = s->mv[dir][i][0];
3060                 motion_y = s->mv[dir][i][1];
3061
3062                 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3063                 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3064                 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3065                     
3066                 /* WARNING: do no forget half pels */
3067                 src_x = clip(src_x, -16, s->width);
3068                 if (src_x == s->width)
3069                     dxy &= ~3;
3070                 src_y = clip(src_y, -16, s->height);
3071                 if (src_y == s->height)
3072                     dxy &= ~12;
3073                     
3074                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3075                 if(s->flags&CODEC_FLAG_EMU_EDGE){
3076                     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
3077                        || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3078                         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);
3079                         ptr= s->edge_emu_buffer;
3080                     }
3081                 }
3082                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3083                 qpix_op[1][dxy](dest, ptr, s->linesize);
3084
3085                 mx += s->mv[dir][i][0]/2;
3086                 my += s->mv[dir][i][1]/2;
3087             }
3088         }else{
3089             for(i=0;i<4;i++) {
3090                 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3091                             ref_picture[0], 0, 0,
3092                             mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3093                             s->width, s->height, s->linesize,
3094                             s->h_edge_pos, s->v_edge_pos,
3095                             8, 8, pix_op[1],
3096                             s->mv[dir][i][0], s->mv[dir][i][1]);
3097
3098                 mx += s->mv[dir][i][0];
3099                 my += s->mv[dir][i][1];
3100             }
3101         }
3102
3103         if(!(s->flags&CODEC_FLAG_GRAY))
3104             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3105         break;
3106     case MV_TYPE_FIELD:
3107         if (s->picture_structure == PICT_FRAME) {
3108             if(s->quarter_sample){
3109                 for(i=0; i<2; i++){
3110                     qpel_motion(s, dest_y, dest_cb, dest_cr,
3111                                 1, i, s->field_select[dir][i],
3112                                 ref_picture, pix_op, qpix_op,
3113                                 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3114                 }
3115             }else{
3116                 /* top field */       
3117                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3118                             1, 0, s->field_select[dir][0],
3119                             ref_picture, pix_op,
3120                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
3121                 /* bottom field */
3122                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3123                             1, 1, s->field_select[dir][1],
3124                             ref_picture, pix_op,
3125                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
3126             }
3127         } else {
3128             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3129                 ref_picture= s->current_picture_ptr->data;
3130             } 
3131
3132             mpeg_motion(s, dest_y, dest_cb, dest_cr,
3133                         0, 0, s->field_select[dir][0],
3134                         ref_picture, pix_op,
3135                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3136         }
3137         break;
3138     case MV_TYPE_16X8:
3139         for(i=0; i<2; i++){
3140             uint8_t ** ref2picture;
3141
3142             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3143                 ref2picture= ref_picture;
3144             }else{
3145                 ref2picture= s->current_picture_ptr->data;
3146             } 
3147
3148             mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3149                         0, 0, s->field_select[dir][i],
3150                         ref2picture, pix_op,
3151                         s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3152                 
3153             dest_y += 16*s->linesize;
3154             dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3155             dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3156         }        
3157         break;
3158     case MV_TYPE_DMV:
3159         if(s->picture_structure == PICT_FRAME){
3160             for(i=0; i<2; i++){
3161                 int j;
3162                 for(j=0; j<2; j++){
3163                     mpeg_motion(s, dest_y, dest_cb, dest_cr,
3164                                 1, j, j^i,
3165                                 ref_picture, pix_op,
3166                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3167                 }
3168                 pix_op = s->dsp.avg_pixels_tab; 
3169             }
3170         }else{
3171             for(i=0; i<2; i++){
3172                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3173                             0, 0, s->picture_structure != i+1,
3174                             ref_picture, pix_op,
3175                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3176
3177                 // after put we make avg of the same block
3178                 pix_op=s->dsp.avg_pixels_tab; 
3179
3180                 //opposite parity is always in the same frame if this is second field
3181                 if(!s->first_field){
3182                     ref_picture = s->current_picture_ptr->data;    
3183                 }
3184             }
3185         }
3186     break;
3187     default: assert(0);
3188     }
3189 }
3190
3191 /**
3192  * motion compesation of a single macroblock
3193  * @param s context
3194  * @param dest_y luma destination pointer
3195  * @param dest_cb chroma cb/u destination pointer
3196  * @param dest_cr chroma cr/v destination pointer
3197  * @param dir direction (0->forward, 1->backward)
3198  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3199  * @param pic_op halfpel motion compensation function (average or put normally)
3200  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3201  */
3202 static inline void MPV_motion_lowres(MpegEncContext *s, 
3203                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3204                               int dir, uint8_t **ref_picture, 
3205                               h264_chroma_mc_func *pix_op)
3206 {
3207     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3208     int mb_x, mb_y, i;
3209     uint8_t *ptr, *dest;
3210     const int lowres= s->avctx->lowres;
3211     const int block_s= 8>>lowres;    
3212
3213     mb_x = s->mb_x;
3214     mb_y = s->mb_y;
3215
3216     switch(s->mv_type) {
3217     case MV_TYPE_16X16:
3218         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3219                     0, 0, 0,
3220                     ref_picture, pix_op,
3221                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3222         break;
3223 /*    case MV_TYPE_8X8:
3224         mx = 0;
3225         my = 0;
3226             for(i=0;i<4;i++) {
3227                 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3228                             ref_picture[0], 0, 0,
3229                             mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3230                             s->width, s->height, s->linesize,
3231                             s->h_edge_pos, s->v_edge_pos,
3232                             8, 8, pix_op[1],
3233                             s->mv[dir][i][0], s->mv[dir][i][1]);
3234
3235                 mx += s->mv[dir][i][0];
3236                 my += s->mv[dir][i][1];
3237             }
3238
3239         if(!(s->flags&CODEC_FLAG_GRAY))
3240             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3241         break;*/
3242     case MV_TYPE_FIELD:
3243         if (s->picture_structure == PICT_FRAME) {
3244             /* top field */       
3245             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3246                         1, 0, s->field_select[dir][0],
3247                         ref_picture, pix_op,
3248                         s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3249             /* bottom field */
3250             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3251                         1, 1, s->field_select[dir][1],
3252                         ref_picture, pix_op,
3253                         s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3254         } else {
3255             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3256                 ref_picture= s->current_picture_ptr->data;
3257             } 
3258
3259             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3260                         0, 0, s->field_select[dir][0],
3261                         ref_picture, pix_op,
3262                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3263         }
3264         break;
3265     case MV_TYPE_16X8:
3266         for(i=0; i<2; i++){
3267             uint8_t ** ref2picture;
3268
3269             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3270                 ref2picture= ref_picture;
3271             }else{
3272                 ref2picture= s->current_picture_ptr->data;
3273             } 
3274
3275             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3276                         0, 0, s->field_select[dir][i],
3277                         ref2picture, pix_op,
3278                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3279                 
3280             dest_y += 2*block_s*s->linesize;
3281             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3282             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3283         }        
3284         break;
3285     case MV_TYPE_DMV:
3286         if(s->picture_structure == PICT_FRAME){
3287             for(i=0; i<2; i++){
3288                 int j;
3289                 for(j=0; j<2; j++){
3290                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3291                                 1, j, j^i,
3292                                 ref_picture, pix_op,
3293                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3294                 }
3295                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3296             }
3297         }else{
3298             for(i=0; i<2; i++){
3299                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3300                             0, 0, s->picture_structure != i+1,
3301                             ref_picture, pix_op,
3302                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3303
3304                 // after put we make avg of the same block
3305                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3306
3307                 //opposite parity is always in the same frame if this is second field
3308                 if(!s->first_field){
3309                     ref_picture = s->current_picture_ptr->data;    
3310                 }
3311             }
3312         }
3313     break;
3314     default: assert(0);
3315     }
3316 }
3317
3318 /* put block[] to dest[] */
3319 static inline void put_dct(MpegEncContext *s, 
3320                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3321 {
3322     s->dct_unquantize_intra(s, block, i, qscale);
3323     s->dsp.idct_put (dest, line_size, block);
3324 }
3325
3326 /* add block[] to dest[] */
3327 static inline void add_dct(MpegEncContext *s, 
3328                            DCTELEM *block, int i, uint8_t *dest, int line_size)
3329 {
3330     if (s->block_last_index[i] >= 0) {
3331         s->dsp.idct_add (dest, line_size, block);
3332     }
3333 }
3334
3335 static inline void add_dequant_dct(MpegEncContext *s, 
3336                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3337 {
3338     if (s->block_last_index[i] >= 0) {
3339         s->dct_unquantize_inter(s, block, i, qscale);
3340
3341         s->dsp.idct_add (dest, line_size, block);
3342     }
3343 }
3344
3345 /**
3346  * cleans dc, ac, coded_block for the current non intra MB
3347  */
3348 void ff_clean_intra_table_entries(MpegEncContext *s)
3349 {
3350     int wrap = s->b8_stride;
3351     int xy = s->block_index[0];
3352     
3353     s->dc_val[0][xy           ] = 
3354     s->dc_val[0][xy + 1       ] = 
3355     s->dc_val[0][xy     + wrap] =
3356     s->dc_val[0][xy + 1 + wrap] = 1024;
3357     /* ac pred */
3358     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3359     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3360     if (s->msmpeg4_version>=3) {
3361         s->coded_block[xy           ] =
3362         s->coded_block[xy + 1       ] =
3363         s->coded_block[xy     + wrap] =
3364         s->coded_block[xy + 1 + wrap] = 0;
3365     }
3366     /* chroma */
3367     wrap = s->mb_stride;
3368     xy = s->mb_x + s->mb_y * wrap;
3369     s->dc_val[1][xy] =
3370     s->dc_val[2][xy] = 1024;
3371     /* ac pred */
3372     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3373     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3374     
3375     s->mbintra_table[xy]= 0;
3376 }
3377
3378 /* generic function called after a macroblock has been parsed by the
3379    decoder or after it has been encoded by the encoder.
3380
3381    Important variables used:
3382    s->mb_intra : true if intra macroblock
3383    s->mv_dir   : motion vector direction
3384    s->mv_type  : motion vector type
3385    s->mv       : motion vector
3386    s->interlaced_dct : true if interlaced dct used (mpeg2)
3387  */
3388 static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3389 {
3390     int mb_x, mb_y;
3391     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3392 #ifdef HAVE_XVMC
3393     if(s->avctx->xvmc_acceleration){
3394         XVMC_decode_mb(s);//xvmc uses pblocks
3395         return;
3396     }
3397 #endif
3398
3399     mb_x = s->mb_x;
3400     mb_y = s->mb_y;
3401
3402     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3403        /* save DCT coefficients */
3404        int i,j;
3405        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3406        for(i=0; i<6; i++)
3407            for(j=0; j<64; j++)
3408                *dct++ = block[i][s->dsp.idct_permutation[j]];
3409     }
3410
3411     s->current_picture.qscale_table[mb_xy]= s->qscale;
3412
3413     /* update DC predictors for P macroblocks */
3414     if (!s->mb_intra) {
3415         if (s->h263_pred || s->h263_aic) {
3416             if(s->mbintra_table[mb_xy])
3417                 ff_clean_intra_table_entries(s);
3418         } else {
3419             s->last_dc[0] =
3420             s->last_dc[1] =
3421             s->last_dc[2] = 128 << s->intra_dc_precision;
3422         }
3423     }
3424     else if (s->h263_pred || s->h263_aic)
3425         s->mbintra_table[mb_xy]=1;
3426
3427     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3428         uint8_t *dest_y, *dest_cb, *dest_cr;
3429         int dct_linesize, dct_offset;
3430         op_pixels_func (*op_pix)[4];
3431         qpel_mc_func (*op_qpix)[16];
3432         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3433         const int uvlinesize= s->current_picture.linesize[1];
3434         const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3435         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3436
3437         /* avoid copy if macroblock skipped in last frame too */
3438         /* skip only during decoding as we might trash the buffers during encoding a bit */
3439         if(!s->encoding){
3440             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3441             const int age= s->current_picture.age;
3442
3443             assert(age);
3444
3445             if (s->mb_skiped) {
3446                 s->mb_skiped= 0;
3447                 assert(s->pict_type!=I_TYPE);
3448  
3449                 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3450                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3451
3452                 /* if previous was skipped too, then nothing to do !  */
3453                 if (*mbskip_ptr >= age && s->current_picture.reference){
3454                     return;
3455                 }
3456             } else if(!s->current_picture.reference){
3457                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3458                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3459             } else{
3460                 *mbskip_ptr = 0; /* not skipped */
3461             }
3462         }
3463         
3464         dct_linesize = linesize << s->interlaced_dct;
3465         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3466         
3467         if(readable){
3468             dest_y=  s->dest[0];
3469             dest_cb= s->dest[1];
3470             dest_cr= s->dest[2];
3471         }else{
3472             dest_y = s->b_scratchpad;
3473             dest_cb= s->b_scratchpad+16*linesize;
3474             dest_cr= s->b_scratchpad+32*linesize;
3475         }
3476
3477         if (!s->mb_intra) {
3478             /* motion handling */
3479