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