switch to native time bases
[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>=0 && 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>=0 && 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(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     if (s->out_format == FMT_H261)
1262         ff_h261_encode_init(s);
1263     if (s->out_format == FMT_H263)
1264         h263_encode_init(s);
1265     if(s->msmpeg4_version)
1266         ff_msmpeg4_encode_init(s);
1267     if (s->out_format == FMT_MPEG1)
1268         ff_mpeg1_encode_init(s);
1269
1270     /* init q matrix */
1271     for(i=0;i<64;i++) {
1272         int j= s->dsp.idct_permutation[i];
1273         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1274             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1275             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1276         }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1277             s->intra_matrix[j] =
1278             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1279         }else
1280         { /* mpeg1/2 */
1281             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1282             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1283         }
1284         if(s->avctx->intra_matrix)
1285             s->intra_matrix[j] = s->avctx->intra_matrix[i];
1286         if(s->avctx->inter_matrix)
1287             s->inter_matrix[j] = s->avctx->inter_matrix[i];
1288     }
1289
1290     /* precompute matrix */
1291     /* for mjpeg, we do include qscale in the matrix */
1292     if (s->out_format != FMT_MJPEG) {
1293         convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1294                        s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1295         convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1296                        s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1297     }
1298
1299     if(ff_rate_control_init(s) < 0)
1300         return -1;
1301     
1302     return 0;
1303 }
1304
1305 int MPV_encode_end(AVCodecContext *avctx)
1306 {
1307     MpegEncContext *s = avctx->priv_data;
1308
1309 #ifdef STATS
1310     print_stats();
1311 #endif
1312
1313     ff_rate_control_uninit(s);
1314
1315     MPV_common_end(s);
1316     if (s->out_format == FMT_MJPEG)
1317         mjpeg_close(s);
1318
1319     av_freep(&avctx->extradata);
1320       
1321     return 0;
1322 }
1323
1324 #endif //CONFIG_ENCODERS
1325
1326 void init_rl(RLTable *rl, int use_static)
1327 {
1328     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1329     uint8_t index_run[MAX_RUN+1];
1330     int last, run, level, start, end, i;
1331
1332     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1333     if(use_static && rl->max_level[0])
1334         return;
1335
1336     /* compute max_level[], max_run[] and index_run[] */
1337     for(last=0;last<2;last++) {
1338         if (last == 0) {
1339             start = 0;
1340             end = rl->last;
1341         } else {
1342             start = rl->last;
1343             end = rl->n;
1344         }
1345
1346         memset(max_level, 0, MAX_RUN + 1);
1347         memset(max_run, 0, MAX_LEVEL + 1);
1348         memset(index_run, rl->n, MAX_RUN + 1);
1349         for(i=start;i<end;i++) {
1350             run = rl->table_run[i];
1351             level = rl->table_level[i];
1352             if (index_run[run] == rl->n)
1353                 index_run[run] = i;
1354             if (level > max_level[run])
1355                 max_level[run] = level;
1356             if (run > max_run[level])
1357                 max_run[level] = run;
1358         }
1359         if(use_static)
1360             rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1361         else
1362             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1363         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1364         if(use_static)
1365             rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1366         else
1367             rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1368         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1369         if(use_static)
1370             rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1371         else
1372             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1373         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1374     }
1375 }
1376
1377 /* draw the edges of width 'w' of an image of size width, height */
1378 //FIXME check that this is ok for mpeg4 interlaced
1379 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1380 {
1381     uint8_t *ptr, *last_line;
1382     int i;
1383
1384     last_line = buf + (height - 1) * wrap;
1385     for(i=0;i<w;i++) {
1386         /* top and bottom */
1387         memcpy(buf - (i + 1) * wrap, buf, width);
1388         memcpy(last_line + (i + 1) * wrap, last_line, width);
1389     }
1390     /* left and right */
1391     ptr = buf;
1392     for(i=0;i<height;i++) {
1393         memset(ptr - w, ptr[0], w);
1394         memset(ptr + width, ptr[width-1], w);
1395         ptr += wrap;
1396     }
1397     /* corners */
1398     for(i=0;i<w;i++) {
1399         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1400         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1401         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1402         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1403     }
1404 }
1405
1406 int ff_find_unused_picture(MpegEncContext *s, int shared){
1407     int i;
1408     
1409     if(shared){
1410         for(i=0; i<MAX_PICTURE_COUNT; i++){
1411             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1412         }
1413     }else{
1414         for(i=0; i<MAX_PICTURE_COUNT; i++){
1415             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1416         }
1417         for(i=0; i<MAX_PICTURE_COUNT; i++){
1418             if(s->picture[i].data[0]==NULL) return i;
1419         }
1420     }
1421
1422     assert(0);
1423     return -1;
1424 }
1425
1426 static void update_noise_reduction(MpegEncContext *s){
1427     int intra, i;
1428
1429     for(intra=0; intra<2; intra++){
1430         if(s->dct_count[intra] > (1<<16)){
1431             for(i=0; i<64; i++){
1432                 s->dct_error_sum[intra][i] >>=1;
1433             }
1434             s->dct_count[intra] >>= 1;
1435         }
1436         
1437         for(i=0; i<64; i++){
1438             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);
1439         }
1440     }
1441 }
1442
1443 /**
1444  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1445  */
1446 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1447 {
1448     int i;
1449     AVFrame *pic;
1450     s->mb_skipped = 0;
1451
1452     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1453
1454     /* mark&release old frames */
1455     if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1456         avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1457
1458         /* release forgotten pictures */
1459         /* if(mpeg124/h263) */
1460         if(!s->encoding){
1461             for(i=0; i<MAX_PICTURE_COUNT; i++){
1462                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1463                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1464                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1465                 }
1466             }
1467         }
1468     }
1469 alloc:
1470     if(!s->encoding){
1471         /* release non refernce frames */
1472         for(i=0; i<MAX_PICTURE_COUNT; i++){
1473             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1474                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1475             }
1476         }
1477
1478         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1479             pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1480         else{
1481             i= ff_find_unused_picture(s, 0);
1482             pic= (AVFrame*)&s->picture[i];
1483         }
1484
1485         pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1486                         && !s->dropable ? 3 : 0;
1487
1488         pic->coded_picture_number= s->coded_picture_number++;
1489         
1490         if( alloc_picture(s, (Picture*)pic, 0) < 0)
1491             return -1;
1492
1493         s->current_picture_ptr= (Picture*)pic;
1494         s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1495         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1496     }
1497
1498     s->current_picture_ptr->pict_type= s->pict_type;
1499 //    if(s->flags && CODEC_FLAG_QSCALE) 
1500   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1501     s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1502
1503     copy_picture(&s->current_picture, s->current_picture_ptr);
1504   
1505   if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1506     if (s->pict_type != B_TYPE) {
1507         s->last_picture_ptr= s->next_picture_ptr;
1508         if(!s->dropable)
1509             s->next_picture_ptr= s->current_picture_ptr;
1510     }
1511 /*    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,
1512         s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1513         s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1514         s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1515         s->pict_type, s->dropable);*/
1516     
1517     if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1518     if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1519     
1520     if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1521         av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1522         assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1523         goto alloc;
1524     }
1525
1526     assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1527
1528     if(s->picture_structure!=PICT_FRAME){
1529         int i;
1530         for(i=0; i<4; i++){
1531             if(s->picture_structure == PICT_BOTTOM_FIELD){
1532                  s->current_picture.data[i] += s->current_picture.linesize[i];
1533             } 
1534             s->current_picture.linesize[i] *= 2;
1535             s->last_picture.linesize[i] *=2;
1536             s->next_picture.linesize[i] *=2;
1537         }
1538     }
1539   }
1540    
1541     s->hurry_up= s->avctx->hurry_up;
1542     s->error_resilience= avctx->error_resilience;
1543
1544     /* set dequantizer, we cant do it during init as it might change for mpeg4
1545        and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1546     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1547         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1548         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1549     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1550         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1551         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1552     }else{
1553         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1554         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1555     }
1556
1557     if(s->dct_error_sum){
1558         assert(s->avctx->noise_reduction && s->encoding);
1559
1560         update_noise_reduction(s);
1561     }
1562         
1563 #ifdef HAVE_XVMC
1564     if(s->avctx->xvmc_acceleration)
1565         return XVMC_field_start(s, avctx);
1566 #endif
1567     return 0;
1568 }
1569
1570 /* generic function for encode/decode called after a frame has been coded/decoded */
1571 void MPV_frame_end(MpegEncContext *s)
1572 {
1573     int i;
1574     /* draw edge for correct motion prediction if outside */
1575 #ifdef HAVE_XVMC
1576 //just to make sure that all data is rendered.
1577     if(s->avctx->xvmc_acceleration){
1578         XVMC_field_end(s);
1579     }else
1580 #endif
1581     if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1582             draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1583             draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1584             draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1585     }
1586     emms_c();
1587     
1588     s->last_pict_type    = s->pict_type;
1589     if(s->pict_type!=B_TYPE){
1590         s->last_non_b_pict_type= s->pict_type;
1591     }
1592 #if 0
1593         /* copy back current_picture variables */
1594     for(i=0; i<MAX_PICTURE_COUNT; i++){
1595         if(s->picture[i].data[0] == s->current_picture.data[0]){
1596             s->picture[i]= s->current_picture;
1597             break;
1598         }    
1599     }
1600     assert(i<MAX_PICTURE_COUNT);
1601 #endif    
1602
1603     if(s->encoding){
1604         /* release non refernce frames */
1605         for(i=0; i<MAX_PICTURE_COUNT; i++){
1606             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1607                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1608             }
1609         }
1610     }
1611     // clear copies, to avoid confusion
1612 #if 0
1613     memset(&s->last_picture, 0, sizeof(Picture));
1614     memset(&s->next_picture, 0, sizeof(Picture));
1615     memset(&s->current_picture, 0, sizeof(Picture));
1616 #endif
1617     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1618 }
1619
1620 /**
1621  * draws an line from (ex, ey) -> (sx, sy).
1622  * @param w width of the image
1623  * @param h height of the image
1624  * @param stride stride/linesize of the image
1625  * @param color color of the arrow
1626  */
1627 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1628     int t, x, y, fr, f;
1629     
1630     sx= clip(sx, 0, w-1);
1631     sy= clip(sy, 0, h-1);
1632     ex= clip(ex, 0, w-1);
1633     ey= clip(ey, 0, h-1);
1634     
1635     buf[sy*stride + sx]+= color;
1636     
1637     if(ABS(ex - sx) > ABS(ey - sy)){
1638         if(sx > ex){
1639             t=sx; sx=ex; ex=t;
1640             t=sy; sy=ey; ey=t;
1641         }
1642         buf+= sx + sy*stride;
1643         ex-= sx;
1644         f= ((ey-sy)<<16)/ex;
1645         for(x= 0; x <= ex; x++){
1646             y = (x*f)>>16;
1647             fr= (x*f)&0xFFFF;
1648             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1649             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1650         }
1651     }else{
1652         if(sy > ey){
1653             t=sx; sx=ex; ex=t;
1654             t=sy; sy=ey; ey=t;
1655         }
1656         buf+= sx + sy*stride;
1657         ey-= sy;
1658         if(ey) f= ((ex-sx)<<16)/ey;
1659         else   f= 0;
1660         for(y= 0; y <= ey; y++){
1661             x = (y*f)>>16;
1662             fr= (y*f)&0xFFFF;
1663             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1664             buf[y*stride + x+1]+= (color*         fr )>>16;;
1665         }
1666     }
1667 }
1668
1669 /**
1670  * draws an arrow from (ex, ey) -> (sx, sy).
1671  * @param w width of the image
1672  * @param h height of the image
1673  * @param stride stride/linesize of the image
1674  * @param color color of the arrow
1675  */
1676 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1677     int dx,dy;
1678
1679     sx= clip(sx, -100, w+100);
1680     sy= clip(sy, -100, h+100);
1681     ex= clip(ex, -100, w+100);
1682     ey= clip(ey, -100, h+100);
1683     
1684     dx= ex - sx;
1685     dy= ey - sy;
1686     
1687     if(dx*dx + dy*dy > 3*3){
1688         int rx=  dx + dy;
1689         int ry= -dx + dy;
1690         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1691         
1692         //FIXME subpixel accuracy
1693         rx= ROUNDED_DIV(rx*3<<4, length);
1694         ry= ROUNDED_DIV(ry*3<<4, length);
1695         
1696         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1697         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1698     }
1699     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1700 }
1701
1702 /**
1703  * prints debuging info for the given picture.
1704  */
1705 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1706
1707     if(!pict || !pict->mb_type) return;
1708
1709     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1710         int x,y;
1711         
1712         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1713         switch (pict->pict_type) {
1714             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1715             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1716             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1717             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1718             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1719             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1720         }
1721         for(y=0; y<s->mb_height; y++){
1722             for(x=0; x<s->mb_width; x++){
1723                 if(s->avctx->debug&FF_DEBUG_SKIP){
1724                     int count= s->mbskip_table[x + y*s->mb_stride];
1725                     if(count>9) count=9;
1726                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1727                 }
1728                 if(s->avctx->debug&FF_DEBUG_QP){
1729                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1730                 }
1731                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1732                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1733                     //Type & MV direction
1734                     if(IS_PCM(mb_type))
1735                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1736                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1737                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1738                     else if(IS_INTRA4x4(mb_type))
1739                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1740                     else if(IS_INTRA16x16(mb_type))
1741                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1742                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1743                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1744                     else if(IS_DIRECT(mb_type))
1745                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1746                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1747                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1748                     else if(IS_GMC(mb_type))
1749                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1750                     else if(IS_SKIP(mb_type))
1751                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1752                     else if(!USES_LIST(mb_type, 1))
1753                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1754                     else if(!USES_LIST(mb_type, 0))
1755                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1756                     else{
1757                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1758                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1759                     }
1760                     
1761                     //segmentation
1762                     if(IS_8X8(mb_type))
1763                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1764                     else if(IS_16X8(mb_type))
1765                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1766                     else if(IS_8X16(mb_type))
1767                         av_log(s->avctx, AV_LOG_DEBUG, "¦");
1768                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1769                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1770                     else
1771                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1772                     
1773                         
1774                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1775                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1776                     else
1777                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1778                 }
1779 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1780             }
1781             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1782         }
1783     }
1784
1785     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1786         const int shift= 1 + s->quarter_sample;
1787         int mb_y;
1788         uint8_t *ptr;
1789         int i;
1790         int h_chroma_shift, v_chroma_shift;
1791         const int width = s->avctx->width;
1792         const int height= s->avctx->height;
1793         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1794         const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1795         s->low_delay=0; //needed to see the vectors without trashing the buffers
1796
1797         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1798         for(i=0; i<3; i++){
1799             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1800             pict->data[i]= s->visualization_buffer[i];
1801         }
1802         pict->type= FF_BUFFER_TYPE_COPY;
1803         ptr= pict->data[0];
1804
1805         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1806             int mb_x;
1807             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1808                 const int mb_index= mb_x + mb_y*s->mb_stride;
1809                 if((s->avctx->debug_mv) && pict->motion_val){
1810                   int type;
1811                   for(type=0; type<3; type++){
1812                     int direction = 0;
1813                     switch (type) {
1814                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1815                                 continue;
1816                               direction = 0;
1817                               break;
1818                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1819                                 continue;
1820                               direction = 0;
1821                               break;
1822                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1823                                 continue;
1824                               direction = 1;
1825                               break;
1826                     }
1827                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1828                         continue;
1829
1830                     if(IS_8X8(pict->mb_type[mb_index])){
1831                       int i;
1832                       for(i=0; i<4; i++){
1833                         int sx= mb_x*16 + 4 + 8*(i&1);
1834                         int sy= mb_y*16 + 4 + 8*(i>>1);
1835                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1836                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1837                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1838                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1839                       }
1840                     }else if(IS_16X8(pict->mb_type[mb_index])){
1841                       int i;
1842                       for(i=0; i<2; i++){
1843                         int sx=mb_x*16 + 8;
1844                         int sy=mb_y*16 + 4 + 8*i;
1845                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1846                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1847                         int my=(pict->motion_val[direction][xy][1]>>shift);
1848                         
1849                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1850                             my*=2;
1851                         
1852                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1853                       }
1854                     }else if(IS_8X16(pict->mb_type[mb_index])){
1855                       int i;
1856                       for(i=0; i<2; i++){
1857                         int sx=mb_x*16 + 4 + 8*i;
1858                         int sy=mb_y*16 + 8;
1859                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1860                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1861                         int my=(pict->motion_val[direction][xy][1]>>shift);
1862                         
1863                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1864                             my*=2;
1865                         
1866                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1867                       }
1868                     }else{
1869                       int sx= mb_x*16 + 8;
1870                       int sy= mb_y*16 + 8;
1871                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1872                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1873                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1874                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1875                     }
1876                   }                  
1877                 }
1878                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1879                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1880                     int y;
1881                     for(y=0; y<8; y++){
1882                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1883                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1884                     }
1885                 }
1886                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1887                     int mb_type= pict->mb_type[mb_index];
1888                     uint64_t u,v;
1889                     int y;
1890 #define COLOR(theta, r)\
1891 u= (int)(128 + r*cos(theta*3.141592/180));\
1892 v= (int)(128 + r*sin(theta*3.141592/180));
1893
1894                     
1895                     u=v=128;
1896                     if(IS_PCM(mb_type)){
1897                         COLOR(120,48)
1898                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1899                         COLOR(30,48)
1900                     }else if(IS_INTRA4x4(mb_type)){
1901                         COLOR(90,48)
1902                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1903 //                        COLOR(120,48)
1904                     }else if(IS_DIRECT(mb_type)){
1905                         COLOR(150,48)
1906                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1907                         COLOR(170,48)
1908                     }else if(IS_GMC(mb_type)){
1909                         COLOR(190,48)
1910                     }else if(IS_SKIP(mb_type)){
1911 //                        COLOR(180,48)
1912                     }else if(!USES_LIST(mb_type, 1)){
1913                         COLOR(240,48)
1914                     }else if(!USES_LIST(mb_type, 0)){
1915                         COLOR(0,48)
1916                     }else{
1917                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1918                         COLOR(300,48)
1919                     }
1920
1921                     u*= 0x0101010101010101ULL;
1922                     v*= 0x0101010101010101ULL;
1923                     for(y=0; y<8; y++){
1924                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1925                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1926                     }
1927
1928                     //segmentation
1929                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1930                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1931                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1932                     }
1933                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1934                         for(y=0; y<16; y++)
1935                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1936                     }
1937                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1938                         int dm= 1 << (mv_sample_log2-2);
1939                         for(i=0; i<4; i++){
1940                             int sx= mb_x*16 + 8*(i&1);
1941                             int sy= mb_y*16 + 8*(i>>1);
1942                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1943                             //FIXME bidir
1944                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1945                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1946                                 for(y=0; y<8; y++)
1947                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1948                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1949                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1950                         }
1951                     }
1952                         
1953                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1954                         // hmm
1955                     }
1956                 }
1957                 s->mbskip_table[mb_index]=0;
1958             }
1959         }
1960     }
1961 }
1962
1963 #ifdef CONFIG_ENCODERS
1964
1965 static int get_sae(uint8_t *src, int ref, int stride){
1966     int x,y;
1967     int acc=0;
1968     
1969     for(y=0; y<16; y++){
1970         for(x=0; x<16; x++){
1971             acc+= ABS(src[x+y*stride] - ref);
1972         }
1973     }
1974     
1975     return acc;
1976 }
1977
1978 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1979     int x, y, w, h;
1980     int acc=0;
1981     
1982     w= s->width &~15;
1983     h= s->height&~15;
1984     
1985     for(y=0; y<h; y+=16){
1986         for(x=0; x<w; x+=16){
1987             int offset= x + y*stride;
1988             int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1989             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1990             int sae = get_sae(src + offset, mean, stride);
1991             
1992             acc+= sae + 500 < sad;
1993         }
1994     }
1995     return acc;
1996 }
1997
1998
1999 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2000     AVFrame *pic=NULL;
2001     int64_t pts;
2002     int i;
2003     const int encoding_delay= s->max_b_frames;
2004     int direct=1;
2005     
2006     if(pic_arg){
2007         pts= pic_arg->pts;
2008         pic_arg->display_picture_number= s->input_picture_number++;
2009
2010         if(pts != AV_NOPTS_VALUE){ 
2011             if(s->user_specified_pts != AV_NOPTS_VALUE){
2012                 int64_t time= pts;
2013                 int64_t last= s->user_specified_pts;
2014             
2015                 if(time <= last){            
2016                     av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pts, s->user_specified_pts);
2017                     return -1;
2018                 }
2019             }
2020             s->user_specified_pts= pts;
2021         }else{
2022             if(s->user_specified_pts != AV_NOPTS_VALUE){
2023                 s->user_specified_pts= 
2024                 pts= s->user_specified_pts + 1;
2025                 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pts);
2026             }else{
2027                 pts= pic_arg->display_picture_number;
2028             }
2029         }
2030     }
2031
2032   if(pic_arg){
2033     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2034     if(pic_arg->linesize[0] != s->linesize) direct=0;
2035     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2036     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2037   
2038 //    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2039     
2040     if(direct){
2041         i= ff_find_unused_picture(s, 1);
2042
2043         pic= (AVFrame*)&s->picture[i];
2044         pic->reference= 3;
2045     
2046         for(i=0; i<4; i++){
2047             pic->data[i]= pic_arg->data[i];
2048             pic->linesize[i]= pic_arg->linesize[i];
2049         }
2050         alloc_picture(s, (Picture*)pic, 1);
2051     }else{
2052         int offset= 16;
2053         i= ff_find_unused_picture(s, 0);
2054
2055         pic= (AVFrame*)&s->picture[i];
2056         pic->reference= 3;
2057
2058         alloc_picture(s, (Picture*)pic, 0);
2059
2060         if(   pic->data[0] + offset == pic_arg->data[0] 
2061            && pic->data[1] + offset == pic_arg->data[1]
2062            && pic->data[2] + offset == pic_arg->data[2]){
2063        // empty
2064         }else{
2065             int h_chroma_shift, v_chroma_shift;
2066             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2067         
2068             for(i=0; i<3; i++){
2069                 int src_stride= pic_arg->linesize[i];
2070                 int dst_stride= i ? s->uvlinesize : s->linesize;
2071                 int h_shift= i ? h_chroma_shift : 0;
2072                 int v_shift= i ? v_chroma_shift : 0;
2073                 int w= s->width >>h_shift;
2074                 int h= s->height>>v_shift;
2075                 uint8_t *src= pic_arg->data[i];
2076                 uint8_t *dst= pic->data[i] + offset;
2077             
2078                 if(src_stride==dst_stride)
2079                     memcpy(dst, src, src_stride*h);
2080                 else{
2081                     while(h--){
2082                         memcpy(dst, src, w);
2083                         dst += dst_stride;
2084                         src += src_stride;
2085                     }
2086                 }
2087             }
2088         }
2089     }
2090     copy_picture_attributes(s, pic, pic_arg);
2091     pic->pts= pts; //we set this here to avoid modifiying pic_arg
2092   }
2093   
2094     /* shift buffer entries */
2095     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2096         s->input_picture[i-1]= s->input_picture[i];
2097         
2098     s->input_picture[encoding_delay]= (Picture*)pic;
2099
2100     return 0;
2101 }
2102
2103 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2104     int x, y, plane;
2105     int score=0;
2106     int64_t score64=0;
2107
2108     for(plane=0; plane<3; plane++){
2109         const int stride= p->linesize[plane];
2110         const int bw= plane ? 1 : 2;
2111         for(y=0; y<s->mb_height*bw; y++){
2112             for(x=0; x<s->mb_width*bw; x++){
2113                 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);
2114                 
2115                 switch(s->avctx->frame_skip_exp){
2116                     case 0: score= FFMAX(score, v); break;
2117                     case 1: score+= ABS(v);break;
2118                     case 2: score+= v*v;break;
2119                     case 3: score64+= ABS(v*v*(int64_t)v);break;
2120                     case 4: score64+= v*v*(int64_t)(v*v);break;
2121                 }
2122             }
2123         }
2124     }
2125     
2126     if(score) score64= score;
2127
2128     if(score64 < s->avctx->frame_skip_threshold)
2129         return 1;
2130     if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2131         return 1;
2132     return 0;
2133 }
2134
2135 static void select_input_picture(MpegEncContext *s){
2136     int i;
2137
2138     for(i=1; i<MAX_PICTURE_COUNT; i++)
2139         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2140     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2141
2142     /* set next picture types & ordering */
2143     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2144         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2145             s->reordered_input_picture[0]= s->input_picture[0];
2146             s->reordered_input_picture[0]->pict_type= I_TYPE;
2147             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2148         }else{
2149             int b_frames;
2150
2151             if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2152                 if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2153 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2154                 
2155                     if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2156                         for(i=0; i<4; i++)
2157                             s->input_picture[0]->data[i]= NULL;
2158                         s->input_picture[0]->type= 0;            
2159                     }else{
2160                         assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER 
2161                                || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2162             
2163                         s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2164                     }
2165
2166                     goto no_output_pic;
2167                 }
2168             }
2169
2170             if(s->flags&CODEC_FLAG_PASS2){
2171                 for(i=0; i<s->max_b_frames+1; i++){
2172                     int pict_num= s->input_picture[0]->display_picture_number + i;
2173
2174                     if(pict_num >= s->rc_context.num_entries) 
2175                         break;
2176                     if(!s->input_picture[i]){
2177                         s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2178                         break;
2179                     }
2180
2181                     s->input_picture[i]->pict_type= 
2182                         s->rc_context.entry[pict_num].new_pict_type;
2183                 }
2184             }
2185
2186             if(s->avctx->b_frame_strategy==0){
2187                 b_frames= s->max_b_frames;
2188                 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2189             }else if(s->avctx->b_frame_strategy==1){
2190                 for(i=1; i<s->max_b_frames+1; i++){
2191                     if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2192                         s->input_picture[i]->b_frame_score= 
2193                             get_intra_count(s, s->input_picture[i  ]->data[0], 
2194                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
2195                     }
2196                 }
2197                 for(i=0; i<s->max_b_frames; i++){
2198                     if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2199                 }
2200                                 
2201                 b_frames= FFMAX(0, i-1);
2202                 
2203                 /* reset scores */
2204                 for(i=0; i<b_frames+1; i++){
2205                     s->input_picture[i]->b_frame_score=0;
2206                 }
2207             }else{
2208                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2209                 b_frames=0;
2210             }
2211
2212             emms_c();
2213 //static int b_count=0;
2214 //b_count+= b_frames;
2215 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2216
2217             for(i= b_frames - 1; i>=0; i--){
2218                 int type= s->input_picture[i]->pict_type;
2219                 if(type && type != B_TYPE)
2220                     b_frames= i;
2221             }
2222             if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2223                 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2224             }
2225
2226             if(s->picture_in_gop_number + b_frames >= s->gop_size){
2227               if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2228                     b_frames= s->gop_size - s->picture_in_gop_number - 1;
2229               }else{
2230                 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2231                     b_frames=0;
2232                 s->input_picture[b_frames]->pict_type= I_TYPE;
2233               }
2234             }
2235             
2236             if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2237                && b_frames
2238                && s->input_picture[b_frames]->pict_type== I_TYPE)
2239                 b_frames--;
2240
2241             s->reordered_input_picture[0]= s->input_picture[b_frames];
2242             if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2243                 s->reordered_input_picture[0]->pict_type= P_TYPE;
2244             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2245             for(i=0; i<b_frames; i++){
2246                 s->reordered_input_picture[i+1]= s->input_picture[i];
2247                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2248                 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2249             }
2250         }
2251     }
2252 no_output_pic:
2253     if(s->reordered_input_picture[0]){
2254         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2255
2256         copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2257
2258         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2259             // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2260         
2261             int i= ff_find_unused_picture(s, 0);
2262             Picture *pic= &s->picture[i];
2263
2264             /* mark us unused / free shared pic */
2265             for(i=0; i<4; i++)
2266                 s->reordered_input_picture[0]->data[i]= NULL;
2267             s->reordered_input_picture[0]->type= 0;
2268             
2269             pic->reference              = s->reordered_input_picture[0]->reference;
2270             
2271             alloc_picture(s, pic, 0);
2272
2273             copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2274
2275             s->current_picture_ptr= pic;
2276         }else{
2277             // input is not a shared pix -> reuse buffer for current_pix
2278
2279             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2280                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2281             
2282             s->current_picture_ptr= s->reordered_input_picture[0];
2283             for(i=0; i<4; i++){
2284                 s->new_picture.data[i]+=16;
2285             }
2286         }
2287         copy_picture(&s->current_picture, s->current_picture_ptr);
2288     
2289         s->picture_number= s->new_picture.display_picture_number;
2290 //printf("dpn:%d\n", s->picture_number);
2291     }else{
2292        memset(&s->new_picture, 0, sizeof(Picture));
2293     }
2294 }
2295
2296 int MPV_encode_picture(AVCodecContext *avctx,
2297                        unsigned char *buf, int buf_size, void *data)
2298 {
2299     MpegEncContext *s = avctx->priv_data;
2300     AVFrame *pic_arg = data;
2301     int i, stuffing_count;
2302
2303     if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2304         av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2305         return -1;
2306     }
2307     
2308     for(i=0; i<avctx->thread_count; i++){
2309         int start_y= s->thread_context[i]->start_mb_y;
2310         int   end_y= s->thread_context[i]->  end_mb_y;
2311         int h= s->mb_height;
2312         uint8_t *start= buf + buf_size*start_y/h;
2313         uint8_t *end  = buf + buf_size*  end_y/h;
2314
2315         init_put_bits(&s->thread_context[i]->pb, start, end - start);
2316     }
2317
2318     s->picture_in_gop_number++;
2319
2320     if(load_input_picture(s, pic_arg) < 0)
2321         return -1;
2322     
2323     select_input_picture(s);
2324     
2325     /* output? */
2326     if(s->new_picture.data[0]){
2327         s->pict_type= s->new_picture.pict_type;
2328 //emms_c();
2329 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2330         MPV_frame_start(s, avctx);
2331
2332         encode_picture(s, s->picture_number);
2333         
2334         avctx->real_pict_num  = s->picture_number;
2335         avctx->header_bits = s->header_bits;
2336         avctx->mv_bits     = s->mv_bits;
2337         avctx->misc_bits   = s->misc_bits;
2338         avctx->i_tex_bits  = s->i_tex_bits;
2339         avctx->p_tex_bits  = s->p_tex_bits;
2340         avctx->i_count     = s->i_count;
2341         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2342         avctx->skip_count  = s->skip_count;
2343
2344         MPV_frame_end(s);
2345
2346         if (s->out_format == FMT_MJPEG)
2347             mjpeg_picture_trailer(s);
2348         
2349         if(s->flags&CODEC_FLAG_PASS1)
2350             ff_write_pass1_stats(s);
2351
2352         for(i=0; i<4; i++){
2353             avctx->error[i] += s->current_picture_ptr->error[i];
2354         }
2355
2356         if(s->flags&CODEC_FLAG_PASS1)
2357             assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2358         flush_put_bits(&s->pb);
2359         s->frame_bits  = put_bits_count(&s->pb);
2360
2361         stuffing_count= ff_vbv_update(s, s->frame_bits);
2362         if(stuffing_count){
2363             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2364                 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2365                 return -1;
2366             }
2367
2368             switch(s->codec_id){
2369             case CODEC_ID_MPEG1VIDEO:
2370             case CODEC_ID_MPEG2VIDEO:
2371                 while(stuffing_count--){
2372                     put_bits(&s->pb, 8, 0);
2373                 }
2374             break;
2375             case CODEC_ID_MPEG4:
2376                 put_bits(&s->pb, 16, 0);
2377                 put_bits(&s->pb, 16, 0x1C3);
2378                 stuffing_count -= 4;
2379                 while(stuffing_count--){
2380                     put_bits(&s->pb, 8, 0xFF);
2381                 }
2382             break;
2383             default:
2384                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2385             }
2386             flush_put_bits(&s->pb);
2387             s->frame_bits  = put_bits_count(&s->pb);
2388         }
2389
2390         /* update mpeg1/2 vbv_delay for CBR */    
2391         if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2392            && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2393             int vbv_delay;
2394
2395             assert(s->repeat_first_field==0);
2396             
2397             vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2398             assert(vbv_delay < 0xFFFF);
2399
2400             s->vbv_delay_ptr[0] &= 0xF8;
2401             s->vbv_delay_ptr[0] |= vbv_delay>>13;
2402             s->vbv_delay_ptr[1]  = vbv_delay>>5;
2403             s->vbv_delay_ptr[2] &= 0x07;
2404             s->vbv_delay_ptr[2] |= vbv_delay<<3;
2405         }
2406         s->total_bits += s->frame_bits;
2407         avctx->frame_bits  = s->frame_bits;
2408     }else{
2409         assert((pbBufPtr(&s->pb) == s->pb.buf));
2410         s->frame_bits=0;
2411     }
2412     assert((s->frame_bits&7)==0);
2413     
2414     return s->frame_bits/8;
2415 }
2416
2417 #endif //CONFIG_ENCODERS
2418
2419 static inline void gmc1_motion(MpegEncContext *s,
2420                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2421                                uint8_t **ref_picture)
2422 {
2423     uint8_t *ptr;
2424     int offset, src_x, src_y, linesize, uvlinesize;
2425     int motion_x, motion_y;
2426     int emu=0;
2427
2428     motion_x= s->sprite_offset[0][0];
2429     motion_y= s->sprite_offset[0][1];
2430     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2431     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2432     motion_x<<=(3-s->sprite_warping_accuracy);
2433     motion_y<<=(3-s->sprite_warping_accuracy);
2434     src_x = clip(src_x, -16, s->width);
2435     if (src_x == s->width)
2436         motion_x =0;
2437     src_y = clip(src_y, -16, s->height);
2438     if (src_y == s->height)
2439         motion_y =0;
2440
2441     linesize = s->linesize;
2442     uvlinesize = s->uvlinesize;
2443     
2444     ptr = ref_picture[0] + (src_y * linesize) + src_x;
2445
2446     if(s->flags&CODEC_FLAG_EMU_EDGE){
2447         if(   (unsigned)src_x >= s->h_edge_pos - 17
2448            || (unsigned)src_y >= s->v_edge_pos - 17){
2449             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2450             ptr= s->edge_emu_buffer;
2451         }
2452     }
2453     
2454     if((motion_x|motion_y)&7){
2455         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2456         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2457     }else{
2458         int dxy;
2459         
2460         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2461         if (s->no_rounding){
2462             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2463         }else{
2464             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2465         }
2466     }
2467     
2468     if(s->flags&CODEC_FLAG_GRAY) return;
2469
2470     motion_x= s->sprite_offset[1][0];
2471     motion_y= s->sprite_offset[1][1];
2472     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2473     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2474     motion_x<<=(3-s->sprite_warping_accuracy);
2475     motion_y<<=(3-s->sprite_warping_accuracy);
2476     src_x = clip(src_x, -8, s->width>>1);
2477     if (src_x == s->width>>1)
2478         motion_x =0;
2479     src_y = clip(src_y, -8, s->height>>1);
2480     if (src_y == s->height>>1)
2481         motion_y =0;
2482
2483     offset = (src_y * uvlinesize) + src_x;
2484     ptr = ref_picture[1] + offset;
2485     if(s->flags&CODEC_FLAG_EMU_EDGE){
2486         if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2487            || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2488             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);
2489             ptr= s->edge_emu_buffer;
2490             emu=1;
2491         }
2492     }
2493     s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2494     
2495     ptr = ref_picture[2] + offset;
2496     if(emu){
2497         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);
2498         ptr= s->edge_emu_buffer;
2499     }
2500     s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2501     
2502     return;
2503 }
2504
2505 static inline void gmc_motion(MpegEncContext *s,
2506                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2507                                uint8_t **ref_picture)
2508 {
2509     uint8_t *ptr;
2510     int linesize, uvlinesize;
2511     const int a= s->sprite_warping_accuracy;
2512     int ox, oy;
2513
2514     linesize = s->linesize;
2515     uvlinesize = s->uvlinesize;
2516
2517     ptr = ref_picture[0];
2518
2519     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2520     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2521
2522     s->dsp.gmc(dest_y, ptr, linesize, 16,
2523            ox, 
2524            oy, 
2525            s->sprite_delta[0][0], s->sprite_delta[0][1],
2526            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2527            a+1, (1<<(2*a+1)) - s->no_rounding,
2528            s->h_edge_pos, s->v_edge_pos);
2529     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2530            ox + s->sprite_delta[0][0]*8, 
2531            oy + s->sprite_delta[1][0]*8, 
2532            s->sprite_delta[0][0], s->sprite_delta[0][1],
2533            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2534            a+1, (1<<(2*a+1)) - s->no_rounding,
2535            s->h_edge_pos, s->v_edge_pos);
2536
2537     if(s->flags&CODEC_FLAG_GRAY) return;
2538
2539     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2540     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2541
2542     ptr = ref_picture[1];
2543     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2544            ox, 
2545            oy, 
2546            s->sprite_delta[0][0], s->sprite_delta[0][1],
2547            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2548            a+1, (1<<(2*a+1)) - s->no_rounding,
2549            s->h_edge_pos>>1, s->v_edge_pos>>1);
2550     
2551     ptr = ref_picture[2];
2552     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2553            ox, 
2554            oy, 
2555            s->sprite_delta[0][0], s->sprite_delta[0][1],
2556            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2557            a+1, (1<<(2*a+1)) - s->no_rounding,
2558            s->h_edge_pos>>1, s->v_edge_pos>>1);
2559 }
2560
2561 /**
2562  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2563  * @param buf destination buffer
2564  * @param src source buffer
2565  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2566  * @param block_w width of block
2567  * @param block_h height of block
2568  * @param src_x x coordinate of the top left sample of the block in the source buffer
2569  * @param src_y y coordinate of the top left sample of the block in the source buffer
2570  * @param w width of the source buffer
2571  * @param h height of the source buffer
2572  */
2573 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2574                                     int src_x, int src_y, int w, int h){
2575     int x, y;
2576     int start_y, start_x, end_y, end_x;
2577
2578     if(src_y>= h){
2579         src+= (h-1-src_y)*linesize;
2580         src_y=h-1;
2581     }else if(src_y<=-block_h){
2582         src+= (1-block_h-src_y)*linesize;
2583         src_y=1-block_h;
2584     }
2585     if(src_x>= w){
2586         src+= (w-1-src_x);
2587         src_x=w-1;
2588     }else if(src_x<=-block_w){
2589         src+= (1-block_w-src_x);
2590         src_x=1-block_w;
2591     }
2592
2593     start_y= FFMAX(0, -src_y);
2594     start_x= FFMAX(0, -src_x);
2595     end_y= FFMIN(block_h, h-src_y);
2596     end_x= FFMIN(block_w, w-src_x);
2597
2598     // copy existing part
2599     for(y=start_y; y<end_y; y++){
2600         for(x=start_x; x<end_x; x++){
2601             buf[x + y*linesize]= src[x + y*linesize];
2602         }
2603     }
2604
2605     //top
2606     for(y=0; y<start_y; y++){
2607         for(x=start_x; x<end_x; x++){
2608             buf[x + y*linesize]= buf[x + start_y*linesize];
2609         }
2610     }
2611
2612     //bottom
2613     for(y=end_y; y<block_h; y++){
2614         for(x=start_x; x<end_x; x++){
2615             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2616         }
2617     }
2618                                     
2619     for(y=0; y<block_h; y++){
2620        //left
2621         for(x=0; x<start_x; x++){
2622             buf[x + y*linesize]= buf[start_x + y*linesize];
2623         }
2624        
2625        //right
2626         for(x=end_x; x<block_w; x++){
2627             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2628         }
2629     }
2630 }
2631
2632 static inline int hpel_motion(MpegEncContext *s, 
2633                                   uint8_t *dest, uint8_t *src,
2634                                   int field_based, int field_select,
2635                                   int src_x, int src_y,
2636                                   int width, int height, int stride,
2637                                   int h_edge_pos, int v_edge_pos,
2638                                   int w, int h, op_pixels_func *pix_op,
2639                                   int motion_x, int motion_y)
2640 {
2641     int dxy;
2642     int emu=0;
2643
2644     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2645     src_x += motion_x >> 1;
2646     src_y += motion_y >> 1;
2647                 
2648     /* WARNING: do no forget half pels */
2649     src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2650     if (src_x == width)
2651         dxy &= ~1;
2652     src_y = clip(src_y, -16, height);
2653     if (src_y == height)
2654         dxy &= ~2;
2655     src += src_y * stride + src_x;
2656
2657     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2658         if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2659            || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2660             ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2661                              src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2662             src= s->edge_emu_buffer;
2663             emu=1;
2664         }
2665     }
2666     if(field_select)
2667         src += s->linesize;
2668     pix_op[dxy](dest, src, stride, h);
2669     return emu;
2670 }
2671
2672 static inline int hpel_motion_lowres(MpegEncContext *s, 
2673                                   uint8_t *dest, uint8_t *src,
2674                                   int field_based, int field_select,
2675                                   int src_x, int src_y,
2676                                   int width, int height, int stride,
2677                                   int h_edge_pos, int v_edge_pos,
2678                                   int w, int h, h264_chroma_mc_func *pix_op,
2679                                   int motion_x, int motion_y)
2680 {
2681     const int lowres= s->avctx->lowres;
2682     const int s_mask= (2<<lowres)-1;
2683     int emu=0;
2684     int sx, sy;
2685
2686     if(s->quarter_sample){
2687         motion_x/=2;
2688         motion_y/=2;
2689     }
2690
2691     sx= motion_x & s_mask;
2692     sy= motion_y & s_mask;
2693     src_x += motion_x >> (lowres+1);
2694     src_y += motion_y >> (lowres+1);
2695                 
2696     src += src_y * stride + src_x;
2697
2698     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2699        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2700         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2701                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2702         src= s->edge_emu_buffer;
2703         emu=1;
2704     }
2705
2706     sx <<= 2 - lowres;
2707     sy <<= 2 - lowres;
2708     if(field_select)
2709         src += s->linesize;
2710     pix_op[lowres](dest, src, stride, h, sx, sy);
2711     return emu;
2712 }
2713
2714 /* apply one mpeg motion vector to the three components */
2715 static always_inline void mpeg_motion(MpegEncContext *s,
2716                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2717                                int field_based, int bottom_field, int field_select,
2718                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2719                                int motion_x, int motion_y, int h)
2720 {
2721     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2722     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2723     
2724 #if 0    
2725 if(s->quarter_sample)
2726 {
2727     motion_x>>=1;
2728     motion_y>>=1;
2729 }
2730 #endif
2731
2732     v_edge_pos = s->v_edge_pos >> field_based;
2733     linesize   = s->current_picture.linesize[0] << field_based;
2734     uvlinesize = s->current_picture.linesize[1] << field_based;
2735
2736     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2737     src_x = s->mb_x* 16               + (motion_x >> 1);
2738     src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2739
2740     if (s->out_format == FMT_H263) {
2741         if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2742             mx = (motion_x>>1)|(motion_x&1);
2743             my = motion_y >>1;
2744             uvdxy = ((my & 1) << 1) | (mx & 1);
2745             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2746             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2747         }else{
2748             uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2749             uvsrc_x = src_x>>1;
2750             uvsrc_y = src_y>>1;
2751         }
2752     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2753         mx = motion_x / 4;
2754         my = motion_y / 4;
2755         uvdxy = 0;
2756         uvsrc_x = s->mb_x*8 + mx;
2757         uvsrc_y = s->mb_y*8 + my;
2758     } else {
2759         if(s->chroma_y_shift){
2760             mx = motion_x / 2;
2761             my = motion_y / 2;
2762             uvdxy = ((my & 1) << 1) | (mx & 1);
2763             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2764             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2765         } else {
2766             if(s->chroma_x_shift){
2767             //Chroma422
2768                 mx = motion_x / 2;
2769                 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2770                 uvsrc_x = s->mb_x* 8           + (mx >> 1);
2771                 uvsrc_y = src_y;
2772             } else {
2773             //Chroma444
2774                 uvdxy = dxy;
2775                 uvsrc_x = src_x;
2776                 uvsrc_y = src_y;
2777             }
2778         }
2779     }
2780
2781     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2782     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2783     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2784
2785     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2786        || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2787             if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2788                s->codec_id == CODEC_ID_MPEG1VIDEO){
2789                 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2790                 return ;
2791             }
2792             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2793                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2794             ptr_y = s->edge_emu_buffer;
2795             if(!(s->flags&CODEC_FLAG_GRAY)){
2796                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2797                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2798                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2799                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2800                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2801                 ptr_cb= uvbuf;
2802                 ptr_cr= uvbuf+16;
2803             }
2804     }
2805
2806     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2807         dest_y += s->linesize;
2808         dest_cb+= s->uvlinesize;
2809         dest_cr+= s->uvlinesize;
2810     }
2811
2812     if(field_select){
2813         ptr_y += s->linesize;
2814         ptr_cb+= s->uvlinesize;
2815         ptr_cr+= s->uvlinesize;
2816     }
2817
2818     pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2819     
2820     if(!(s->flags&CODEC_FLAG_GRAY)){
2821         pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2822         pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2823     }
2824     if(s->out_format == FMT_H261){
2825         ff_h261_loop_filter(s);
2826     }
2827 }
2828
2829 /* apply one mpeg motion vector to the three components */
2830 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2831                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2832                                int field_based, int bottom_field, int field_select,
2833                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2834                                int motion_x, int motion_y, int h)
2835 {
2836     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2837     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2838     const int lowres= s->avctx->lowres;
2839     const int block_s= 8>>lowres;
2840     const int s_mask= (2<<lowres)-1;
2841     const int h_edge_pos = s->h_edge_pos >> lowres;
2842     const int v_edge_pos = s->v_edge_pos >> lowres;
2843     linesize   = s->current_picture.linesize[0] << field_based;
2844     uvlinesize = s->current_picture.linesize[1] << field_based;
2845
2846     if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2847         motion_x/=2;
2848         motion_y/=2;
2849     }
2850     
2851     if(field_based){
2852         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2853     }
2854
2855     sx= motion_x & s_mask;
2856     sy= motion_y & s_mask;
2857     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2858     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2859     
2860     if (s->out_format == FMT_H263) {
2861         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2862         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2863         uvsrc_x = src_x>>1;
2864         uvsrc_y = src_y>>1;
2865     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2866         mx = motion_x / 4;
2867         my = motion_y / 4;
2868         uvsx = (2*mx) & s_mask;
2869         uvsy = (2*my) & s_mask;
2870         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2871         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2872     } else {
2873         mx = motion_x / 2;
2874         my = motion_y / 2;
2875         uvsx = mx & s_mask;
2876         uvsy = my & s_mask;
2877         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2878         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2879     }
2880
2881     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2882     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2883     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2884
2885     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2886        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2887             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2888                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2889             ptr_y = s->edge_emu_buffer;
2890             if(!(s->flags&CODEC_FLAG_GRAY)){
2891                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2892                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2893                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2894                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2895                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2896                 ptr_cb= uvbuf;
2897                 ptr_cr= uvbuf+16;
2898             }
2899     }
2900
2901     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2902         dest_y += s->linesize;
2903         dest_cb+= s->uvlinesize;
2904         dest_cr+= s->uvlinesize;
2905     }
2906
2907     if(field_select){
2908         ptr_y += s->linesize;
2909         ptr_cb+= s->uvlinesize;
2910         ptr_cr+= s->uvlinesize;
2911     }
2912
2913     sx <<= 2 - lowres;
2914     sy <<= 2 - lowres;
2915     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2916     
2917     if(!(s->flags&CODEC_FLAG_GRAY)){
2918         uvsx <<= 2 - lowres;
2919         uvsy <<= 2 - lowres;
2920         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2921         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2922     }
2923     //FIXME h261 lowres loop filter
2924 }
2925
2926 //FIXME move to dsputil, avg variant, 16x16 version
2927 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2928     int x;
2929     uint8_t * const top   = src[1];
2930     uint8_t * const left  = src[2];
2931     uint8_t * const mid   = src[0];
2932     uint8_t * const right = src[3];
2933     uint8_t * const bottom= src[4];
2934 #define OBMC_FILTER(x, t, l, m, r, b)\
2935     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2936 #define OBMC_FILTER4(x, t, l, m, r, b)\
2937     OBMC_FILTER(x         , t, l, m, r, b);\
2938     OBMC_FILTER(x+1       , t, l, m, r, b);\
2939     OBMC_FILTER(x  +stride, t, l, m, r, b);\
2940     OBMC_FILTER(x+1+stride, t, l, m, r, b);
2941     
2942     x=0;
2943     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2944     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2945     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2946     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2947     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2948     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2949     x+= stride;
2950     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2951     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2952     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2953     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2954     x+= stride;
2955     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2956     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2957     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2958     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2959     x+= 2*stride;
2960     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2961     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2962     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2963     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2964     x+= 2*stride;
2965     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2966     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2967     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2968     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2969     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2970     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2971     x+= stride;
2972     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2973     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2974     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2975     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2976 }
2977
2978 /* obmc for 1 8x8 luma block */
2979 static inline void obmc_motion(MpegEncContext *s,
2980                                uint8_t *dest, uint8_t *src,
2981                                int src_x, int src_y,
2982                                op_pixels_func *pix_op,
2983                                int16_t mv[5][2]/* mid top left right bottom*/)
2984 #define MID    0
2985 {
2986     int i;
2987     uint8_t *ptr[5];
2988     
2989     assert(s->quarter_sample==0);
2990     
2991     for(i=0; i<5; i++){
2992         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2993             ptr[i]= ptr[MID];
2994         }else{
2995             ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2996             hpel_motion(s, ptr[i], src, 0, 0,
2997                         src_x, src_y,
2998                         s->width, s->height, s->linesize,
2999                         s->h_edge_pos, s->v_edge_pos,
3000                         8, 8, pix_op,
3001                         mv[i][0], mv[i][1]);
3002         }
3003     }
3004
3005     put_obmc(dest, ptr, s->linesize);                
3006 }
3007
3008 static inline void qpel_motion(MpegEncContext *s,
3009                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3010                                int field_based, int bottom_field, int field_select,
3011                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3012                                qpel_mc_func (*qpix_op)[16],
3013                                int motion_x, int motion_y, int h)
3014 {
3015     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3016     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3017
3018     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3019     src_x = s->mb_x *  16                 + (motion_x >> 2);
3020     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3021
3022     v_edge_pos = s->v_edge_pos >> field_based;
3023     linesize = s->linesize << field_based;
3024     uvlinesize = s->uvlinesize << field_based;
3025     
3026     if(field_based){
3027         mx= motion_x/2;
3028         my= motion_y>>1;
3029     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3030         static const int rtab[8]= {0,0,1,1,0,0,0,1};
3031         mx= (motion_x>>1) + rtab[motion_x&7];
3032         my= (motion_y>>1) + rtab[motion_y&7];
3033     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3034         mx= (motion_x>>1)|(motion_x&1);
3035         my= (motion_y>>1)|(motion_y&1);
3036     }else{
3037         mx= motion_x/2;
3038         my= motion_y/2;
3039     }
3040     mx= (mx>>1)|(mx&1);
3041     my= (my>>1)|(my&1);
3042
3043     uvdxy= (mx&1) | ((my&1)<<1);
3044     mx>>=1;
3045     my>>=1;
3046
3047     uvsrc_x = s->mb_x *  8                 + mx;
3048     uvsrc_y = s->mb_y * (8 >> field_based) + my;
3049
3050     ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3051     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3052     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3053
3054     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
3055        || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3056         ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
3057                          src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3058         ptr_y= s->edge_emu_buffer;
3059         if(!(s->flags&CODEC_FLAG_GRAY)){
3060             uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3061             ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
3062                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3063             ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
3064                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3065             ptr_cb= uvbuf;
3066             ptr_cr= uvbuf + 16;
3067         }
3068     }
3069
3070     if(!field_based)
3071         qpix_op[0][dxy](dest_y, ptr_y, linesize);
3072     else{
3073         if(bottom_field){
3074             dest_y += s->linesize;
3075             dest_cb+= s->uvlinesize;
3076             dest_cr+= s->uvlinesize;
3077         }
3078
3079         if(field_select){
3080             ptr_y  += s->linesize;
3081             ptr_cb += s->uvlinesize;
3082             ptr_cr += s->uvlinesize;
3083         }
3084         //damn interlaced mode
3085         //FIXME boundary mirroring is not exactly correct here
3086         qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3087         qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3088     }
3089     if(!(s->flags&CODEC_FLAG_GRAY)){
3090         pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3091         pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3092     }
3093 }
3094
3095 inline int ff_h263_round_chroma(int x){
3096     if (x >= 0)
3097         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3098     else {
3099         x = -x;
3100         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3101     }
3102 }
3103
3104 /**
3105  * h263 chorma 4mv motion compensation.
3106  */
3107 static inline void chroma_4mv_motion(MpegEncContext *s,
3108                                      uint8_t *dest_cb, uint8_t *dest_cr,
3109                                      uint8_t **ref_picture,
3110                                      op_pixels_func *pix_op,
3111                                      int mx, int my){
3112     int dxy, emu=0, src_x, src_y, offset;
3113     uint8_t *ptr;
3114     
3115     /* In case of 8X8, we construct a single chroma motion vector
3116        with a special rounding */
3117     mx= ff_h263_round_chroma(mx);
3118     my= ff_h263_round_chroma(my);
3119     
3120     dxy = ((my & 1) << 1) | (mx & 1);
3121     mx >>= 1;
3122     my >>= 1;
3123
3124     src_x = s->mb_x * 8 + mx;
3125     src_y = s->mb_y * 8 + my;
3126     src_x = clip(src_x, -8, s->width/2);
3127     if (src_x == s->width/2)
3128         dxy &= ~1;
3129     src_y = clip(src_y, -8, s->height/2);
3130     if (src_y == s->height/2)
3131         dxy &= ~2;
3132     
3133     offset = (src_y * (s->uvlinesize)) + src_x;
3134     ptr = ref_picture[1] + offset;
3135     if(s->flags&CODEC_FLAG_EMU_EDGE){
3136         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3137            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3138             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);
3139             ptr= s->edge_emu_buffer;
3140             emu=1;
3141         }
3142     }
3143     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3144
3145     ptr = ref_picture[2] + offset;
3146     if(emu){
3147         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);
3148         ptr= s->edge_emu_buffer;
3149     }
3150     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3151 }
3152
3153 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3154                                      uint8_t *dest_cb, uint8_t *dest_cr,
3155                                      uint8_t **ref_picture,
3156                                      h264_chroma_mc_func *pix_op,
3157                                      int mx, int my){
3158     const int lowres= s->avctx->lowres;
3159     const int block_s= 8>>lowres;
3160     const int s_mask= (2<<lowres)-1;
3161     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3162     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3163     int emu=0, src_x, src_y, offset, sx, sy;
3164     uint8_t *ptr;
3165     
3166     if(s->quarter_sample){
3167         mx/=2;
3168         my/=2;
3169     }
3170
3171     /* In case of 8X8, we construct a single chroma motion vector
3172        with a special rounding */
3173     mx= ff_h263_round_chroma(mx);
3174     my= ff_h263_round_chroma(my);
3175     
3176     sx= mx & s_mask;
3177     sy= my & s_mask;
3178     src_x = s->mb_x*block_s + (mx >> (lowres+1));
3179     src_y = s->mb_y*block_s + (my >> (lowres+1));
3180     
3181     offset = src_y * s->uvlinesize + src_x;
3182     ptr = ref_picture[1] + offset;
3183     if(s->flags&CODEC_FLAG_EMU_EDGE){
3184         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3185            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3186             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3187             ptr= s->edge_emu_buffer;
3188             emu=1;
3189         }
3190     }     
3191     sx <<= 2 - lowres;
3192     sy <<= 2 - lowres;
3193     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3194           
3195     ptr = ref_picture[2] + offset;
3196     if(emu){
3197         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3198         ptr= s->edge_emu_buffer;
3199     }
3200     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3201 }
3202
3203 /**
3204  * motion compesation of a single macroblock
3205  * @param s context
3206  * @param dest_y luma destination pointer
3207  * @param dest_cb chroma cb/u destination pointer
3208  * @param dest_cr chroma cr/v destination pointer
3209  * @param dir direction (0->forward, 1->backward)
3210  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3211  * @param pic_op halfpel motion compensation function (average or put normally)
3212  * @param pic_op qpel motion compensation function (average or put normally)
3213  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3214  */
3215 static inline void MPV_motion(MpegEncContext *s, 
3216                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3217                               int dir, uint8_t **ref_picture, 
3218                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3219 {
3220     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3221     int mb_x, mb_y, i;
3222     uint8_t *ptr, *dest;
3223
3224     mb_x = s->mb_x;
3225     mb_y = s->mb_y;
3226
3227     if(s->obmc && s->pict_type != B_TYPE){
3228         int16_t mv_cache[4][4][2];
3229         const int xy= s->mb_x + s->mb_y*s->mb_stride;
3230         const int mot_stride= s->b8_stride;
3231         const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3232
3233         assert(!s->mb_skipped);
3234                 
3235         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3236         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3237         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3238
3239         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3240             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3241         }else{
3242             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3243         }
3244
3245         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3246             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3247             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3248         }else{
3249             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3250             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3251         }
3252
3253         if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3254             *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3255             *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3256         }else{
3257             *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3258             *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3259         }
3260         
3261         mx = 0;
3262         my = 0;
3263         for(i=0;i<4;i++) {
3264             const int x= (i&1)+1;
3265             const int y= (i>>1)+1;
3266             int16_t mv[5][2]= {
3267                 {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3268                 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3269                 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3270                 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3271                 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3272             //FIXME cleanup
3273             obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3274                         ref_picture[0],
3275                         mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3276                         pix_op[1],
3277                         mv);
3278
3279             mx += mv[0][0];
3280             my += mv[0][1];
3281         }
3282         if(!(s->flags&CODEC_FLAG_GRAY))
3283             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3284
3285         return;
3286     }
3287    
3288     switch(s->mv_type) {
3289     case MV_TYPE_16X16:
3290         if(s->mcsel){
3291             if(s->real_sprite_warping_points==1){
3292                 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3293                             ref_picture);
3294             }else{
3295                 gmc_motion(s, dest_y, dest_cb, dest_cr,
3296                             ref_picture);
3297             }
3298         }else if(s->quarter_sample){
3299             qpel_motion(s, dest_y, dest_cb, dest_cr, 
3300                         0, 0, 0,
3301                         ref_picture, pix_op, qpix_op,
3302                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3303         }else if(s->mspel){
3304             ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3305                         ref_picture, pix_op,
3306                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3307         }else
3308         {
3309             mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3310                         0, 0, 0,
3311                         ref_picture, pix_op,
3312                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3313         }           
3314         break;
3315     case MV_TYPE_8X8:
3316         mx = 0;
3317         my = 0;
3318         if(s->quarter_sample){
3319             for(i=0;i<4;i++) {
3320                 motion_x = s->mv[dir][i][0];
3321                 motion_y = s->mv[dir][i][1];
3322
3323                 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3324                 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3325                 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3326                     
3327                 /* WARNING: do no forget half pels */
3328                 src_x = clip(src_x, -16, s->width);
3329                 if (src_x == s->width)
3330                     dxy &= ~3;
3331                 src_y = clip(src_y, -16, s->height);
3332                 if (src_y == s->height)
3333                     dxy &= ~12;
3334                     
3335                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3336                 if(s->flags&CODEC_FLAG_EMU_EDGE){
3337                     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
3338                        || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3339                         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);
3340                         ptr= s->edge_emu_buffer;
3341                     }
3342                 }
3343                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3344                 qpix_op[1][dxy](dest, ptr, s->linesize);
3345
3346                 mx += s->mv[dir][i][0]/2;
3347                 my += s->mv[dir][i][1]/2;
3348             }
3349         }else{
3350             for(i=0;i<4;i++) {
3351                 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3352                             ref_picture[0], 0, 0,
3353                             mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3354                             s->width, s->height, s->linesize,
3355                             s->h_edge_pos, s->v_edge_pos,
3356                             8, 8, pix_op[1],
3357                             s->mv[dir][i][0], s->mv[dir][i][1]);
3358
3359                 mx += s->mv[dir][i][0];
3360                 my += s->mv[dir][i][1];
3361             }
3362         }
3363
3364         if(!(s->flags&CODEC_FLAG_GRAY))
3365             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3366         break;
3367     case MV_TYPE_FIELD:
3368         if (s->picture_structure == PICT_FRAME) {
3369             if(s->quarter_sample){
3370                 for(i=0; i<2; i++){
3371                     qpel_motion(s, dest_y, dest_cb, dest_cr,
3372                                 1, i, s->field_select[dir][i],
3373                                 ref_picture, pix_op, qpix_op,
3374                                 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3375                 }
3376             }else{
3377                 /* top field */       
3378                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3379                             1, 0, s->field_select[dir][0],
3380                             ref_picture, pix_op,
3381                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
3382                 /* bottom field */
3383                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3384                             1, 1, s->field_select[dir][1],
3385                             ref_picture, pix_op,
3386                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
3387             }
3388         } else {
3389             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3390                 ref_picture= s->current_picture_ptr->data;
3391             } 
3392
3393             mpeg_motion(s, dest_y, dest_cb, dest_cr,
3394                         0, 0, s->field_select[dir][0],
3395                         ref_picture, pix_op,
3396                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3397         }
3398         break;
3399     case MV_TYPE_16X8:
3400         for(i=0; i<2; i++){
3401             uint8_t ** ref2picture;
3402
3403             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3404                 ref2picture= ref_picture;
3405             }else{
3406                 ref2picture= s->current_picture_ptr->data;
3407             } 
3408
3409             mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3410                         0, 0, s->field_select[dir][i],
3411                         ref2picture, pix_op,
3412                         s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3413                 
3414             dest_y += 16*s->linesize;
3415             dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3416             dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3417         }        
3418         break;
3419     case MV_TYPE_DMV:
3420         if(s->picture_structure == PICT_FRAME){
3421             for(i=0; i<2; i++){
3422                 int j;
3423                 for(j=0; j<2; j++){
3424                     mpeg_motion(s, dest_y, dest_cb, dest_cr,
3425                                 1, j, j^i,
3426                                 ref_picture, pix_op,
3427                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3428                 }
3429                 pix_op = s->dsp.avg_pixels_tab; 
3430             }
3431         }else{
3432             for(i=0; i<2; i++){
3433                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3434                             0, 0, s->picture_structure != i+1,
3435                             ref_picture, pix_op,
3436                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3437
3438                 // after put we make avg of the same block
3439                 pix_op=s->dsp.avg_pixels_tab; 
3440
3441                 //opposite parity is always in the same frame if this is second field
3442                 if(!s->first_field){
3443                     ref_picture = s->current_picture_ptr->data;    
3444                 }
3445             }
3446         }
3447     break;
3448     default: assert(0);
3449     }
3450 }
3451
3452 /**
3453  * motion compesation of a single macroblock
3454  * @param s context
3455  * @param dest_y luma destination pointer
3456  * @param dest_cb chroma cb/u destination pointer
3457  * @param dest_cr chroma cr/v destination pointer
3458  * @param dir direction (0->forward, 1->backward)
3459  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3460  * @param pic_op halfpel motion compensation function (average or put normally)
3461  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3462  */
3463 static inline void MPV_motion_lowres(MpegEncContext *s, 
3464                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3465          &n