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