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