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