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