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