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