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