0d312bbd81ac4fa77c7bf05ae7be4f06fc3960b5
[ffmpeg.git] / libavcodec / mpegvideo.c
1 /*
2  * The simplest mpeg encoder (well, it was the simplest!)
3  * Copyright (c) 2000,2001 Fabrice Bellard.
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  *
22  * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
23  */
24
25 /**
26  * @file mpegvideo.c
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29
30 #include "avcodec.h"
31 #include "dsputil.h"
32 #include "mpegvideo.h"
33 #include "msmpeg4.h"
34 #include "faandct.h"
35 #include <limits.h>
36
37 #ifdef USE_FASTMEMCPY
38 #include "libvo/fastmemcpy.h"
39 #endif
40
41 //#undef NDEBUG
42 //#include <assert.h>
43
44 #ifdef CONFIG_ENCODERS
45 static int encode_picture(MpegEncContext *s, int picture_number);
46 #endif //CONFIG_ENCODERS
47 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
48                                    DCTELEM *block, int n, int qscale);
49 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
50                                    DCTELEM *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
52                                    DCTELEM *block, int n, int qscale);
53 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
54                                    DCTELEM *block, int n, int qscale);
55 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
56                                    DCTELEM *block, int n, int qscale);
57 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
58                                   DCTELEM *block, int n, int qscale);
59 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
60                                   DCTELEM *block, int n, int qscale);
61 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
62 #ifdef CONFIG_ENCODERS
63 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
64 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
65 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
66 static int sse_mb(MpegEncContext *s);
67 static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block);
68 #endif //CONFIG_ENCODERS
69
70 #ifdef HAVE_XVMC
71 extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
72 extern void XVMC_field_end(MpegEncContext *s);
73 extern void XVMC_decode_mb(MpegEncContext *s);
74 #endif
75
76 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
77
78
79 /* enable all paranoid tests for rounding, overflows, etc... */
80 //#define PARANOID
81
82 //#define DEBUG
83
84
85 /* for jpeg fast DCT */
86 #define CONST_BITS 14
87
88 static const uint16_t aanscales[64] = {
89     /* precomputed values scaled up by 14 bits */
90     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
91     22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
92     21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
93     19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
94     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
95     12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
96     8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
97     4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
98 };
99
100 static const uint8_t h263_chroma_roundtab[16] = {
101 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
102     0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
103 };
104
105 static const uint8_t ff_default_chroma_qscale_table[32]={
106 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
107     0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
108 };
109
110 #ifdef CONFIG_ENCODERS
111 static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
112 static uint8_t default_fcode_tab[MAX_MV*2+1];
113
114 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
115
116 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
117                            const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
118 {
119     int qscale;
120     int shift=0;
121
122     for(qscale=qmin; qscale<=qmax; qscale++){
123         int i;
124         if (dsp->fdct == ff_jpeg_fdct_islow
125 #ifdef FAAN_POSTSCALE
126             || dsp->fdct == ff_faandct
127 #endif
128             ) {
129             for(i=0;i<64;i++) {
130                 const int j= dsp->idct_permutation[i];
131                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
132                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
133                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
134                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
135
136                 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
137                                 (qscale * quant_matrix[j]));
138             }
139         } else if (dsp->fdct == fdct_ifast
140 #ifndef FAAN_POSTSCALE
141                    || dsp->fdct == ff_faandct
142 #endif
143                    ) {
144             for(i=0;i<64;i++) {
145                 const int j= dsp->idct_permutation[i];
146                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
147                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
148                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
149                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
150
151                 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
152                                 (aanscales[i] * qscale * quant_matrix[j]));
153             }
154         } else {
155             for(i=0;i<64;i++) {
156                 const int j= dsp->idct_permutation[i];
157                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
158                    So 16           <= qscale * quant_matrix[i]             <= 7905
159                    so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
160                    so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
161                 */
162                 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
163 //                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
164                 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
165
166                 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
167                 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
168             }
169         }
170
171         for(i=intra; i<64; i++){
172             int64_t max= 8191;
173             if (dsp->fdct == fdct_ifast
174 #ifndef FAAN_POSTSCALE
175                    || dsp->fdct == ff_faandct
176 #endif
177                    ) {
178                 max= (8191LL*aanscales[i]) >> 14;
179             }
180             while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
181                 shift++;
182             }
183         }
184     }
185     if(shift){
186         av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift);
187     }
188 }
189
190 static inline void update_qscale(MpegEncContext *s){
191     s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
192     s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
193
194     s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
195 }
196 #endif //CONFIG_ENCODERS
197
198 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
199     int i;
200     int end;
201
202     st->scantable= src_scantable;
203
204     for(i=0; i<64; i++){
205         int j;
206         j = src_scantable[i];
207         st->permutated[i] = permutation[j];
208 #ifdef ARCH_POWERPC
209         st->inverse[j] = i;
210 #endif
211     }
212
213     end=-1;
214     for(i=0; i<64; i++){
215         int j;
216         j = st->permutated[i];
217         if(j>end) end=j;
218         st->raster_end[i]= end;
219     }
220 }
221
222 #ifdef CONFIG_ENCODERS
223 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){
224     int i;
225
226     if(matrix){
227         put_bits(pb, 1, 1);
228         for(i=0;i<64;i++) {
229             put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
230         }
231     }else
232         put_bits(pb, 1, 0);
233 }
234 #endif //CONFIG_ENCODERS
235
236 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
237     int i;
238
239     assert(p<=end);
240     if(p>=end)
241         return end;
242
243     for(i=0; i<3; i++){
244         uint32_t tmp= *state << 8;
245         *state= tmp + *(p++);
246         if(tmp == 0x100 || p==end)
247             return p;
248     }
249
250     while(p<end){
251         if     (p[-1] > 1      ) p+= 3;
252         else if(p[-2]          ) p+= 2;
253         else if(p[-3]|(p[-1]-1)) p++;
254         else{
255             p++;
256             break;
257         }
258     }
259
260     p= FFMIN(p, end)-4;
261     *state=  be2me_32(unaligned32(p));
262
263     return p+4;
264 }
265
266 /* init common dct for both encoder and decoder */
267 int DCT_common_init(MpegEncContext *s)
268 {
269     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
270     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
271     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
272     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
273     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
274     if(s->flags & CODEC_FLAG_BITEXACT)
275         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
276     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
277
278 #ifdef CONFIG_ENCODERS
279     s->dct_quantize= dct_quantize_c;
280     s->denoise_dct= denoise_dct_c;
281 #endif //CONFIG_ENCODERS
282
283 #ifdef HAVE_MMX
284     MPV_common_init_mmx(s);
285 #endif
286 #ifdef ARCH_ALPHA
287     MPV_common_init_axp(s);
288 #endif
289 #ifdef HAVE_MLIB
290     MPV_common_init_mlib(s);
291 #endif
292 #ifdef HAVE_MMI
293     MPV_common_init_mmi(s);
294 #endif
295 #ifdef ARCH_ARMV4L
296     MPV_common_init_armv4l(s);
297 #endif
298 #ifdef ARCH_POWERPC
299     MPV_common_init_ppc(s);
300 #endif
301
302 #ifdef CONFIG_ENCODERS
303     s->fast_dct_quantize= s->dct_quantize;
304
305     if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
306         s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
307     }
308
309 #endif //CONFIG_ENCODERS
310
311     /* load & permutate scantables
312        note: only wmv uses different ones
313     */
314     if(s->alternate_scan){
315         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
316         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
317     }else{
318         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
319         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
320     }
321     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
322     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
323
324     return 0;
325 }
326
327 static void copy_picture(Picture *dst, Picture *src){
328     *dst = *src;
329     dst->type= FF_BUFFER_TYPE_COPY;
330 }
331
332 #ifdef CONFIG_ENCODERS
333 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
334     int i;
335
336     dst->pict_type              = src->pict_type;
337     dst->quality                = src->quality;
338     dst->coded_picture_number   = src->coded_picture_number;
339     dst->display_picture_number = src->display_picture_number;
340 //    dst->reference              = src->reference;
341     dst->pts                    = src->pts;
342     dst->interlaced_frame       = src->interlaced_frame;
343     dst->top_field_first        = src->top_field_first;
344
345     if(s->avctx->me_threshold){
346         if(!src->motion_val[0])
347             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
348         if(!src->mb_type)
349             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
350         if(!src->ref_index[0])
351             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
352         if(src->motion_subsample_log2 != dst->motion_subsample_log2)
353             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
354             src->motion_subsample_log2, dst->motion_subsample_log2);
355
356         memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
357
358         for(i=0; i<2; i++){
359             int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
360             int height= ((16*s->mb_height)>>src->motion_subsample_log2);
361
362             if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
363                 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
364             }
365             if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
366                 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
367             }
368         }
369     }
370 }
371 #endif
372
373 /**
374  * allocates a Picture
375  * The pixels are allocated/set by calling get_buffer() if shared=0
376  */
377 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
378     const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
379     const int mb_array_size= s->mb_stride*s->mb_height;
380     const int b8_array_size= s->b8_stride*s->mb_height*2;
381     const int b4_array_size= s->b4_stride*s->mb_height*4;
382     int i;
383
384     if(shared){
385         assert(pic->data[0]);
386         assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
387         pic->type= FF_BUFFER_TYPE_SHARED;
388     }else{
389         int r;
390
391         assert(!pic->data[0]);
392
393         r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
394
395         if(r<0 || !pic->age || !pic->type || !pic->data[0]){
396             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
397             return -1;
398         }
399
400         if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
401             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
402             return -1;
403         }
404
405         if(pic->linesize[1] != pic->linesize[2]){
406             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
407             return -1;
408         }
409
410         s->linesize  = pic->linesize[0];
411         s->uvlinesize= pic->linesize[1];
412     }
413
414     if(pic->qscale_table==NULL){
415         if (s->encoding) {
416             CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
417             CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
418             CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
419         }
420
421         CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
422         CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
423         CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
424         pic->mb_type= pic->mb_type_base + s->mb_stride+1;
425         if(s->out_format == FMT_H264){
426             for(i=0; i<2; i++){
427                 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t))
428                 pic->motion_val[i]= pic->motion_val_base[i]+4;
429                 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
430             }
431             pic->motion_subsample_log2= 2;
432         }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
433             for(i=0; i<2; i++){
434                 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
435                 pic->motion_val[i]= pic->motion_val_base[i]+4;
436                 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
437             }
438             pic->motion_subsample_log2= 3;
439         }
440         if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
441             CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
442         }
443         pic->qstride= s->mb_stride;
444         CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
445     }
446
447     //it might be nicer if the application would keep track of these but it would require a API change
448     memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
449     s->prev_pict_types[0]= s->pict_type;
450     if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
451         pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
452
453     return 0;
454 fail: //for the CHECKED_ALLOCZ macro
455     return -1;
456 }
457
458 /**
459  * deallocates a picture
460  */
461 static void free_picture(MpegEncContext *s, Picture *pic){
462     int i;
463
464     if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
465         s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
466     }
467
468     av_freep(&pic->mb_var);
469     av_freep(&pic->mc_mb_var);
470     av_freep(&pic->mb_mean);
471     av_freep(&pic->mbskip_table);
472     av_freep(&pic->qscale_table);
473     av_freep(&pic->mb_type_base);
474     av_freep(&pic->dct_coeff);
475     av_freep(&pic->pan_scan);
476     pic->mb_type= NULL;
477     for(i=0; i<2; i++){
478         av_freep(&pic->motion_val_base[i]);
479         av_freep(&pic->ref_index[i]);
480     }
481
482     if(pic->type == FF_BUFFER_TYPE_SHARED){
483         for(i=0; i<4; i++){
484             pic->base[i]=
485             pic->data[i]= NULL;
486         }
487         pic->type= 0;
488     }
489 }
490
491 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
492     int i;
493
494     // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
495     CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
496     s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
497
498      //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
499     CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
500     s->rd_scratchpad=   s->me.scratchpad;
501     s->b_scratchpad=    s->me.scratchpad;
502     s->obmc_scratchpad= s->me.scratchpad + 16;
503     if (s->encoding) {
504         CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
505         CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
506         if(s->avctx->noise_reduction){
507             CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
508         }
509     }
510     CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
511     s->block= s->blocks[0];
512
513     for(i=0;i<12;i++){
514         s->pblocks[i] = (short *)(&s->block[i]);
515     }
516     return 0;
517 fail:
518     return -1; //free() through MPV_common_end()
519 }
520
521 static void free_duplicate_context(MpegEncContext *s){
522     if(s==NULL) return;
523
524     av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
525     av_freep(&s->me.scratchpad);
526     s->rd_scratchpad=
527     s->b_scratchpad=
528     s->obmc_scratchpad= NULL;
529
530     av_freep(&s->dct_error_sum);
531     av_freep(&s->me.map);
532     av_freep(&s->me.score_map);
533     av_freep(&s->blocks);
534     s->block= NULL;
535 }
536
537 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
538 #define COPY(a) bak->a= src->a
539     COPY(allocated_edge_emu_buffer);
540     COPY(edge_emu_buffer);
541     COPY(me.scratchpad);
542     COPY(rd_scratchpad);
543     COPY(b_scratchpad);
544     COPY(obmc_scratchpad);
545     COPY(me.map);
546     COPY(me.score_map);
547     COPY(blocks);
548     COPY(block);
549     COPY(start_mb_y);
550     COPY(end_mb_y);
551     COPY(me.map_generation);
552     COPY(pb);
553     COPY(dct_error_sum);
554     COPY(dct_count[0]);
555     COPY(dct_count[1]);
556 #undef COPY
557 }
558
559 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
560     MpegEncContext bak;
561     int i;
562     //FIXME copy only needed parts
563 //START_TIMER
564     backup_duplicate_context(&bak, dst);
565     memcpy(dst, src, sizeof(MpegEncContext));
566     backup_duplicate_context(dst, &bak);
567     for(i=0;i<12;i++){
568         dst->pblocks[i] = (short *)(&dst->block[i]);
569     }
570 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
571 }
572
573 #ifdef CONFIG_ENCODERS
574 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
575 #define COPY(a) dst->a= src->a
576     COPY(pict_type);
577     COPY(current_picture);
578     COPY(f_code);
579     COPY(b_code);
580     COPY(qscale);
581     COPY(lambda);
582     COPY(lambda2);
583     COPY(picture_in_gop_number);
584     COPY(gop_picture_number);
585     COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
586     COPY(progressive_frame); //FIXME don't set in encode_header
587     COPY(partitioned_frame); //FIXME don't set in encode_header
588 #undef COPY
589 }
590 #endif
591
592 /**
593  * sets the given MpegEncContext to common defaults (same for encoding and decoding).
594  * the changed fields will not depend upon the prior state of the MpegEncContext.
595  */
596 static void MPV_common_defaults(MpegEncContext *s){
597     s->y_dc_scale_table=
598     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
599     s->chroma_qscale_table= ff_default_chroma_qscale_table;
600     s->progressive_frame= 1;
601     s->progressive_sequence= 1;
602     s->picture_structure= PICT_FRAME;
603
604     s->coded_picture_number = 0;
605     s->picture_number = 0;
606     s->input_picture_number = 0;
607
608     s->picture_in_gop_number = 0;
609
610     s->f_code = 1;
611     s->b_code = 1;
612 }
613
614 /**
615  * sets the given MpegEncContext to defaults for decoding.
616  * the changed fields will not depend upon the prior state of the MpegEncContext.
617  */
618 void MPV_decode_defaults(MpegEncContext *s){
619     MPV_common_defaults(s);
620 }
621
622 /**
623  * sets the given MpegEncContext to defaults for encoding.
624  * the changed fields will not depend upon the prior state of the MpegEncContext.
625  */
626
627 #ifdef CONFIG_ENCODERS
628 static void MPV_encode_defaults(MpegEncContext *s){
629     int i;
630     MPV_common_defaults(s);
631
632     for(i=-16; i<16; i++){
633         default_fcode_tab[i + MAX_MV]= 1;
634     }
635     s->me.mv_penalty= default_mv_penalty;
636     s->fcode_tab= default_fcode_tab;
637 }
638 #endif //CONFIG_ENCODERS
639
640 /**
641  * init common structure for both encoder and decoder.
642  * this assumes that some variables like width/height are already set
643  */
644 int MPV_common_init(MpegEncContext *s)
645 {
646     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
647
648     s->mb_height = (s->height + 15) / 16;
649
650     if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
651         av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
652         return -1;
653     }
654
655     if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
656         return -1;
657
658     dsputil_init(&s->dsp, s->avctx);
659     DCT_common_init(s);
660
661     s->flags= s->avctx->flags;
662     s->flags2= s->avctx->flags2;
663
664     s->mb_width  = (s->width  + 15) / 16;
665     s->mb_stride = s->mb_width + 1;
666     s->b8_stride = s->mb_width*2 + 1;
667     s->b4_stride = s->mb_width*4 + 1;
668     mb_array_size= s->mb_height * s->mb_stride;
669     mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
670
671     /* set chroma shifts */
672     avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
673                                                     &(s->chroma_y_shift) );
674
675     /* set default edge pos, will be overriden in decode_header if needed */
676     s->h_edge_pos= s->mb_width*16;
677     s->v_edge_pos= s->mb_height*16;
678
679     s->mb_num = s->mb_width * s->mb_height;
680
681     s->block_wrap[0]=
682     s->block_wrap[1]=
683     s->block_wrap[2]=
684     s->block_wrap[3]= s->b8_stride;
685     s->block_wrap[4]=
686     s->block_wrap[5]= s->mb_stride;
687
688     y_size = s->b8_stride * (2 * s->mb_height + 1);
689     c_size = s->mb_stride * (s->mb_height + 1);
690     yc_size = y_size + 2 * c_size;
691
692     /* convert fourcc to upper case */
693     s->codec_tag=          toupper( s->avctx->codec_tag     &0xFF)
694                         + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
695                         + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
696                         + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
697
698     s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
699                                + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
700                                + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
701                                + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
702
703     s->avctx->coded_frame= (AVFrame*)&s->current_picture;
704
705     CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
706     for(y=0; y<s->mb_height; y++){
707         for(x=0; x<s->mb_width; x++){
708             s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
709         }
710     }
711     s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
712
713     if (s->encoding) {
714         /* Allocate MV tables */
715         CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
716         CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
717         CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
718         CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
719         CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
720         CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
721         s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
722         s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
723         s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
724         s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
725         s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
726         s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
727
728         if(s->msmpeg4_version){
729             CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
730         }
731         CHECKED_ALLOCZ(s->avctx->stats_out, 256);
732
733         /* Allocate MB type table */
734         CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
735
736         CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
737
738         CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
739         CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
740         CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
741         CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
742         CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
743         CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
744
745         if(s->avctx->noise_reduction){
746             CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
747         }
748     }
749     CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
750
751     CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
752
753     if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
754         /* interlaced direct mode decoding tables */
755             for(i=0; i<2; i++){
756                 int j, k;
757                 for(j=0; j<2; j++){
758                     for(k=0; k<2; k++){
759                         CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
760                         s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
761                     }
762                     CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
763                     CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
764                     s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
765                 }
766                 CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
767             }
768     }
769     if (s->out_format == FMT_H263) {
770         /* ac values */
771         CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
772         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
773         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
774         s->ac_val[2] = s->ac_val[1] + c_size;
775
776         /* cbp values */
777         CHECKED_ALLOCZ(s->coded_block_base, y_size);
778         s->coded_block= s->coded_block_base + s->b8_stride + 1;
779
780         /* cbp, ac_pred, pred_dir */
781         CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
782         CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
783     }
784
785     if (s->h263_pred || s->h263_plus || !s->encoding) {
786         /* dc values */
787         //MN: we need these for error resilience of intra-frames
788         CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
789         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
790         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
791         s->dc_val[2] = s->dc_val[1] + c_size;
792         for(i=0;i<yc_size;i++)
793             s->dc_val_base[i] = 1024;
794     }
795
796     /* which mb is a intra block */
797     CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
798     memset(s->mbintra_table, 1, mb_array_size);
799
800     /* init macroblock skip table */
801     CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
802     //Note the +1 is for a quicker mpeg4 slice_end detection
803     CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
804
805     s->parse_context.state= -1;
806     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
807        s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
808        s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
809        s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
810     }
811
812     s->context_initialized = 1;
813
814     s->thread_context[0]= s;
815     for(i=1; i<s->avctx->thread_count; i++){
816         s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
817         memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
818     }
819
820     for(i=0; i<s->avctx->thread_count; i++){
821         if(init_duplicate_context(s->thread_context[i], s) < 0)
822            goto fail;
823         s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
824         s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
825     }
826
827     return 0;
828  fail:
829     MPV_common_end(s);
830     return -1;
831 }
832
833 /* init common structure for both encoder and decoder */
834 void MPV_common_end(MpegEncContext *s)
835 {
836     int i, j, k;
837
838     for(i=0; i<s->avctx->thread_count; i++){
839         free_duplicate_context(s->thread_context[i]);
840     }
841     for(i=1; i<s->avctx->thread_count; i++){
842         av_freep(&s->thread_context[i]);
843     }
844
845     av_freep(&s->parse_context.buffer);
846     s->parse_context.buffer_size=0;
847
848     av_freep(&s->mb_type);
849     av_freep(&s->p_mv_table_base);
850     av_freep(&s->b_forw_mv_table_base);
851     av_freep(&s->b_back_mv_table_base);
852     av_freep(&s->b_bidir_forw_mv_table_base);
853     av_freep(&s->b_bidir_back_mv_table_base);
854     av_freep(&s->b_direct_mv_table_base);
855     s->p_mv_table= NULL;
856     s->b_forw_mv_table= NULL;
857     s->b_back_mv_table= NULL;
858     s->b_bidir_forw_mv_table= NULL;
859     s->b_bidir_back_mv_table= NULL;
860     s->b_direct_mv_table= NULL;
861     for(i=0; i<2; i++){
862         for(j=0; j<2; j++){
863             for(k=0; k<2; k++){
864                 av_freep(&s->b_field_mv_table_base[i][j][k]);
865                 s->b_field_mv_table[i][j][k]=NULL;
866             }
867             av_freep(&s->b_field_select_table[i][j]);
868             av_freep(&s->p_field_mv_table_base[i][j]);
869             s->p_field_mv_table[i][j]=NULL;
870         }
871         av_freep(&s->p_field_select_table[i]);
872     }
873
874     av_freep(&s->dc_val_base);
875     av_freep(&s->ac_val_base);
876     av_freep(&s->coded_block_base);
877     av_freep(&s->mbintra_table);
878     av_freep(&s->cbp_table);
879     av_freep(&s->pred_dir_table);
880
881     av_freep(&s->mbskip_table);
882     av_freep(&s->prev_pict_types);
883     av_freep(&s->bitstream_buffer);
884     s->allocated_bitstream_buffer_size=0;
885
886     av_freep(&s->avctx->stats_out);
887     av_freep(&s->ac_stats);
888     av_freep(&s->error_status_table);
889     av_freep(&s->mb_index2xy);
890     av_freep(&s->lambda_table);
891     av_freep(&s->q_intra_matrix);
892     av_freep(&s->q_inter_matrix);
893     av_freep(&s->q_intra_matrix16);
894     av_freep(&s->q_inter_matrix16);
895     av_freep(&s->input_picture);
896     av_freep(&s->reordered_input_picture);
897     av_freep(&s->dct_offset);
898
899     if(s->picture){
900         for(i=0; i<MAX_PICTURE_COUNT; i++){
901             free_picture(s, &s->picture[i]);
902         }
903     }
904     av_freep(&s->picture);
905     s->context_initialized = 0;
906     s->last_picture_ptr=
907     s->next_picture_ptr=
908     s->current_picture_ptr= NULL;
909     s->linesize= s->uvlinesize= 0;
910
911     for(i=0; i<3; i++)
912         av_freep(&s->visualization_buffer[i]);
913
914     avcodec_default_free_buffers(s->avctx);
915 }
916
917 #ifdef CONFIG_ENCODERS
918
919 /* init video encoder */
920 int MPV_encode_init(AVCodecContext *avctx)
921 {
922     MpegEncContext *s = avctx->priv_data;
923     int i;
924     int chroma_h_shift, chroma_v_shift;
925
926     MPV_encode_defaults(s);
927
928     switch (avctx->codec_id) {
929     case CODEC_ID_MPEG2VIDEO:
930         if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
931             av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
932             return -1;
933         }
934         break;
935     case CODEC_ID_LJPEG:
936     case CODEC_ID_MJPEG:
937         if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P &&
938            ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
939             av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
940             return -1;
941         }
942         break;
943     default:
944         if(avctx->pix_fmt != PIX_FMT_YUV420P){
945             av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
946             return -1;
947         }
948     }
949
950     switch (avctx->pix_fmt) {
951     case PIX_FMT_YUVJ422P:
952     case PIX_FMT_YUV422P:
953         s->chroma_format = CHROMA_422;
954         break;
955     case PIX_FMT_YUVJ420P:
956     case PIX_FMT_YUV420P:
957     default:
958         s->chroma_format = CHROMA_420;
959         break;
960     }
961
962     s->bit_rate = avctx->bit_rate;
963     s->width = avctx->width;
964     s->height = avctx->height;
965     if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
966         av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
967         avctx->gop_size=600;
968     }
969     s->gop_size = avctx->gop_size;
970     s->avctx = avctx;
971     s->flags= avctx->flags;
972     s->flags2= avctx->flags2;
973     s->max_b_frames= avctx->max_b_frames;
974     s->codec_id= avctx->codec->id;
975     s->luma_elim_threshold  = avctx->luma_elim_threshold;
976     s->chroma_elim_threshold= avctx->chroma_elim_threshold;
977     s->strict_std_compliance= avctx->strict_std_compliance;
978     s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
979     s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
980     s->mpeg_quant= avctx->mpeg_quant;
981     s->rtp_mode= !!avctx->rtp_payload_size;
982     s->intra_dc_precision= avctx->intra_dc_precision;
983     s->user_specified_pts = AV_NOPTS_VALUE;
984
985     if (s->gop_size <= 1) {
986         s->intra_only = 1;
987         s->gop_size = 12;
988     } else {
989         s->intra_only = 0;
990     }
991
992     s->me_method = avctx->me_method;
993
994     /* Fixed QSCALE */
995     s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
996
997     s->adaptive_quant= (   s->avctx->lumi_masking
998                         || s->avctx->dark_masking
999                         || s->avctx->temporal_cplx_masking
1000                         || s->avctx->spatial_cplx_masking
1001                         || s->avctx->p_masking
1002                         || s->avctx->border_masking
1003                         || (s->flags&CODEC_FLAG_QP_RD))
1004                        && !s->fixed_qscale;
1005
1006     s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1007     s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1008     s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1009     s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1010     s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT);
1011
1012     if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1013         av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1014         return -1;
1015     }
1016
1017     if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1018         av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1019     }
1020
1021     if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1022         av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1023         return -1;
1024     }
1025
1026     if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1027         av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1028         return -1;
1029     }
1030
1031     if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1032        && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1033        && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1034
1035         av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
1036     }
1037
1038     if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1039        && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1040         av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1041         return -1;
1042     }
1043
1044     if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1045         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1046         return -1;
1047     }
1048
1049     if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1050         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1051         return -1;
1052     }
1053
1054     if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1055         av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1056         return -1;
1057     }
1058
1059     if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1060         av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1061         return -1;
1062     }
1063
1064     if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1065         av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1066         return -1;
1067     }
1068
1069     if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1070        && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1071         av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1072         return -1;
1073     }
1074
1075     if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1076         av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1077         return -1;
1078     }
1079
1080     if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1081         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1082         return -1;
1083     }
1084
1085     if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1086         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1087         return -1;
1088     }
1089
1090     if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1091         av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n");
1092         return -1;
1093     }
1094
1095     if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1096         av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1097         return -1;
1098     }
1099
1100     if(s->flags & CODEC_FLAG_LOW_DELAY){
1101         if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
1102             av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
1103             return -1;
1104         }
1105         if (s->max_b_frames != 0){
1106             av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
1107             return -1;
1108         }
1109     }
1110
1111     if(s->q_scale_type == 1){
1112         if(s->codec_id != CODEC_ID_MPEG2VIDEO){
1113             av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n");
1114             return -1;
1115         }
1116         if(avctx->qmax > 12){
1117             av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n");
1118             return -1;
1119         }
1120     }
1121
1122     if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1123        && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1124        && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1125         av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1126         return -1;
1127     }
1128
1129     if(s->avctx->thread_count > 1)
1130         s->rtp_mode= 1;
1131
1132     if(!avctx->time_base.den || !avctx->time_base.num){
1133         av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1134         return -1;
1135     }
1136
1137     i= (INT_MAX/2+128)>>8;
1138     if(avctx->me_threshold >= i){
1139         av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1140         return -1;
1141     }
1142     if(avctx->mb_threshold >= i){
1143         av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1144         return -1;
1145     }
1146
1147     if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1148         av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1149         avctx->b_frame_strategy = 0;
1150     }
1151
1152     i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1153     if(i > 1){
1154         av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1155         avctx->time_base.den /= i;
1156         avctx->time_base.num /= i;
1157 //        return -1;
1158     }
1159
1160     if(s->codec_id==CODEC_ID_MJPEG){
1161         s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1162         s->inter_quant_bias= 0;
1163     }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1164         s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1165         s->inter_quant_bias= 0;
1166     }else{
1167         s->intra_quant_bias=0;
1168         s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1169     }
1170
1171     if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1172         s->intra_quant_bias= avctx->intra_quant_bias;
1173     if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1174         s->inter_quant_bias= avctx->inter_quant_bias;
1175
1176     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1177
1178     if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1179         av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1180         return -1;
1181     }
1182     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1183
1184     switch(avctx->codec->id) {
1185     case CODEC_ID_MPEG1VIDEO:
1186         s->out_format = FMT_MPEG1;
1187         s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1188         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1189         break;
1190     case CODEC_ID_MPEG2VIDEO:
1191         s->out_format = FMT_MPEG1;
1192         s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1193         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1194         s->rtp_mode= 1;
1195         break;
1196     case CODEC_ID_LJPEG:
1197     case CODEC_ID_MJPEG:
1198         s->out_format = FMT_MJPEG;
1199         s->intra_only = 1; /* force intra only for jpeg */
1200         s->mjpeg_write_tables = 1;
1201         s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1202         s->mjpeg_vsample[0] = 2;
1203         s->mjpeg_vsample[1] = 2>>chroma_v_shift;
1204         s->mjpeg_vsample[2] = 2>>chroma_v_shift;
1205         s->mjpeg_hsample[0] = 2;
1206         s->mjpeg_hsample[1] = 2>>chroma_h_shift;
1207         s->mjpeg_hsample[2] = 2>>chroma_h_shift;
1208         if (mjpeg_init(s) < 0)
1209             return -1;
1210         avctx->delay=0;
1211         s->low_delay=1;
1212         break;
1213 #ifdef CONFIG_H261_ENCODER
1214     case CODEC_ID_H261:
1215         if (ff_h261_get_picture_format(s->width, s->height) < 0) {
1216             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);
1217             return -1;
1218         }
1219         s->out_format = FMT_H261;
1220         avctx->delay=0;
1221         s->low_delay=1;
1222         break;
1223 #endif
1224     case CODEC_ID_H263:
1225         if (h263_get_picture_format(s->width, s->height) == 7) {
1226             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);
1227             return -1;
1228         }
1229         s->out_format = FMT_H263;
1230         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1231         avctx->delay=0;
1232         s->low_delay=1;
1233         break;
1234     case CODEC_ID_H263P:
1235         s->out_format = FMT_H263;
1236         s->h263_plus = 1;
1237         /* Fx */
1238         s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1239         s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0;
1240         s->modified_quant= s->h263_aic;
1241         s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1242         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1243         s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1244         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1245         s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1246
1247         /* /Fx */
1248         /* These are just to be sure */
1249         avctx->delay=0;
1250         s->low_delay=1;
1251         break;
1252     case CODEC_ID_FLV1:
1253         s->out_format = FMT_H263;
1254         s->h263_flv = 2; /* format = 1; 11-bit codes */
1255         s->unrestricted_mv = 1;
1256         s->rtp_mode=0; /* don't allow GOB */
1257         avctx->delay=0;
1258         s->low_delay=1;
1259         break;
1260     case CODEC_ID_RV10:
1261         s->out_format = FMT_H263;
1262         avctx->delay=0;
1263         s->low_delay=1;
1264         break;
1265     case CODEC_ID_RV20:
1266         s->out_format = FMT_H263;
1267         avctx->delay=0;
1268         s->low_delay=1;
1269         s->modified_quant=1;
1270         s->h263_aic=1;
1271         s->h263_plus=1;
1272         s->loop_filter=1;
1273         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1274         break;
1275     case CODEC_ID_MPEG4:
1276         s->out_format = FMT_H263;
1277         s->h263_pred = 1;
1278         s->unrestricted_mv = 1;
1279         s->low_delay= s->max_b_frames ? 0 : 1;
1280         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1281         break;
1282     case CODEC_ID_MSMPEG4V1:
1283         s->out_format = FMT_H263;
1284         s->h263_msmpeg4 = 1;
1285         s->h263_pred = 1;
1286         s->unrestricted_mv = 1;
1287         s->msmpeg4_version= 1;
1288         avctx->delay=0;
1289         s->low_delay=1;
1290         break;
1291     case CODEC_ID_MSMPEG4V2:
1292         s->out_format = FMT_H263;
1293         s->h263_msmpeg4 = 1;
1294         s->h263_pred = 1;
1295         s->unrestricted_mv = 1;
1296         s->msmpeg4_version= 2;
1297         avctx->delay=0;
1298         s->low_delay=1;
1299         break;
1300     case CODEC_ID_MSMPEG4V3:
1301         s->out_format = FMT_H263;
1302         s->h263_msmpeg4 = 1;
1303         s->h263_pred = 1;
1304         s->unrestricted_mv = 1;
1305         s->msmpeg4_version= 3;
1306         s->flipflop_rounding=1;
1307         avctx->delay=0;
1308         s->low_delay=1;
1309         break;
1310     case CODEC_ID_WMV1:
1311         s->out_format = FMT_H263;
1312         s->h263_msmpeg4 = 1;
1313         s->h263_pred = 1;
1314         s->unrestricted_mv = 1;
1315         s->msmpeg4_version= 4;
1316         s->flipflop_rounding=1;
1317         avctx->delay=0;
1318         s->low_delay=1;
1319         break;
1320     case CODEC_ID_WMV2:
1321         s->out_format = FMT_H263;
1322         s->h263_msmpeg4 = 1;
1323         s->h263_pred = 1;
1324         s->unrestricted_mv = 1;
1325         s->msmpeg4_version= 5;
1326         s->flipflop_rounding=1;
1327         avctx->delay=0;
1328         s->low_delay=1;
1329         break;
1330     default:
1331         return -1;
1332     }
1333
1334     avctx->has_b_frames= !s->low_delay;
1335
1336     s->encoding = 1;
1337
1338     /* init */
1339     if (MPV_common_init(s) < 0)
1340         return -1;
1341
1342     if(s->modified_quant)
1343         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1344     s->progressive_frame=
1345     s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
1346     s->quant_precision=5;
1347
1348     ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1349     ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1350
1351 #ifdef CONFIG_H261_ENCODER
1352     if (s->out_format == FMT_H261)
1353         ff_h261_encode_init(s);
1354 #endif
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 (s->out_format == FMT_MJPEG)
1405         mjpeg_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 isnt 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 (s->out_format == FMT_MJPEG)
2551             mjpeg_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 defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
3061     if(s->out_format == FMT_H261){
3062         ff_h261_loop_filter(s);
3063     }
3064 #endif
3065 }
3066
3067 /* apply one mpeg motion vector to the three components */
3068 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
3069                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3070                                int field_based, int bottom_field, int field_select,
3071                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3072                                int motion_x, int motion_y, int h)
3073 {
3074     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3075     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3076     const int lowres= s->avctx->lowres;
3077     const int block_s= 8>>lowres;
3078     const int s_mask= (2<<lowres)-1;
3079     const int h_edge_pos = s->h_edge_pos >> lowres;
3080     const int v_edge_pos = s->v_edge_pos >> lowres;
3081     linesize   = s->current_picture.linesize[0] << field_based;
3082     uvlinesize = s->current_picture.linesize[1] << field_based;
3083
3084     if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3085         motion_x/=2;
3086         motion_y/=2;
3087     }
3088
3089     if(field_based){
3090         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3091     }
3092
3093     sx= motion_x & s_mask;
3094     sy= motion_y & s_mask;
3095     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
3096     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3097
3098     if (s->out_format == FMT_H263) {
3099         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3100         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3101         uvsrc_x = src_x>>1;
3102         uvsrc_y = src_y>>1;
3103     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3104         mx = motion_x / 4;
3105         my = motion_y / 4;
3106         uvsx = (2*mx) & s_mask;
3107         uvsy = (2*my) & s_mask;
3108         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
3109         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
3110     } else {
3111         mx = motion_x / 2;
3112         my = motion_y / 2;
3113         uvsx = mx & s_mask;
3114         uvsy = my & s_mask;
3115         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
3116         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3117     }
3118
3119     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3120     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3121     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3122
3123     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
3124        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3125             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3126                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3127             ptr_y = s->edge_emu_buffer;
3128             if(!(s->flags&CODEC_FLAG_GRAY)){
3129                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3130                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3131                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3132                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3133                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3134                 ptr_cb= uvbuf;
3135                 ptr_cr= uvbuf+16;
3136             }
3137     }
3138
3139     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3140         dest_y += s->linesize;
3141         dest_cb+= s->uvlinesize;
3142         dest_cr+= s->uvlinesize;
3143     }
3144
3145     if(field_select){
3146         ptr_y += s->linesize;
3147         ptr_cb+= s->uvlinesize;
3148         ptr_cr+= s->uvlinesize;
3149     }
3150
3151     sx <<= 2 - lowres;
3152     sy <<= 2 - lowres;
3153     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3154
3155     if(!(s->flags&CODEC_FLAG_GRAY)){
3156         uvsx <<= 2 - lowres;
3157         uvsy <<= 2 - lowres;
3158         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3159         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3160     }
3161     //FIXME h261 lowres loop filter
3162 }
3163
3164 //FIXME move to dsputil, avg variant, 16x16 version
3165 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3166     int x;
3167     uint8_t * const top   = src[1];
3168     uint8_t * const left  = src[2];
3169     uint8_t * const mid   = src[0];
3170     uint8_t * const right = src[3];
3171     uint8_t * const bottom= src[4];
3172 #define OBMC_FILTER(x, t, l, m, r, b)\
3173     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3174 #define OBMC_FILTER4(x, t, l, m, r, b)\
3175     OBMC_FILTER(x         , t, l, m, r, b);\
3176     OBMC_FILTER(x+1       , t, l, m, r, b);\
3177     OBMC_FILTER(x  +stride, t, l, m, r, b);\
3178     OBMC_FILTER(x+1+stride, t, l, m, r, b);
3179
3180     x=0;
3181     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
3182     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3183     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3184     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3185     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3186     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3187     x+= stride;
3188     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
3189     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3190     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3191     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3192     x+= stride;
3193     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
3194     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3195     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3196     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3197     x+= 2*stride;
3198     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
3199     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3200     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3201     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3202     x+= 2*stride;
3203     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
3204     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3205     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3206     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3207     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3208     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3209     x+= stride;
3210     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
3211     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3212     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3213     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3214 }
3215
3216 /* obmc for 1 8x8 luma block */
3217 static inline void obmc_motion(MpegEncContext *s,
3218                                uint8_t *dest, uint8_t *src,
3219                                int src_x, int src_y,
3220                                op_pixels_func *pix_op,
3221                                int16_t mv[5][2]/* mid top left right bottom*/)
3222 #define MID    0
3223 {
3224     int i;
3225     uint8_t *ptr[5];
3226
3227     assert(s->quarter_sample==0);
3228
3229     for(i=0; i<5; i++){
3230         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3231             ptr[i]= ptr[MID];
3232         }else{
3233             ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3234             hpel_motion(s, ptr[i], src, 0, 0,
3235                         src_x, src_y,
3236                         s->width, s->height, s->linesize,
3237                         s->h_edge_pos, s->v_edge_pos,
3238                         8, 8, pix_op,
3239                         mv[i][0], mv[i][1]);
3240         }
3241     }
3242
3243     put_obmc(dest, ptr, s->linesize);
3244 }
3245
3246 static inline void qpel_motion(MpegEncContext *s,
3247                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3248                                int field_based, int bottom_field, int field_select,
3249                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3250                                qpel_mc_func (*qpix_op)[16],
3251                                int motion_x, int motion_y, int h)
3252 {
3253     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3254     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3255
3256     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3257     src_x = s->mb_x *  16                 + (motion_x >> 2);
3258     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3259
3260     v_edge_pos = s->v_edge_pos >> field_based;
3261     linesize = s->linesize << field_based;
3262     uvlinesize = s->uvlinesize << field_based;
3263
3264     if(field_based){
3265         mx= motion_x/2;
3266         my= motion_y>>1;
3267     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3268         static const int rtab[8]= {0,0,1,1,0,0,0,1};
3269         mx= (motion_x>>1) + rtab[motion_x&7];
3270         my= (motion_y>>1) + rtab[motion_y&7];
3271     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3272         mx= (motion_x>>1)|(motion_x&1);
3273         my= (motion_y>>1)|(motion_y&1);
3274     }else{
3275         mx= motion_x/2;
3276         my= motion_y/2;
3277     }
3278     mx= (mx>>1)|(mx&1);
3279     my= (my>>1)|(my&1);
3280
3281     uvdxy= (mx&1) | ((my&1)<<1);
3282     mx>>=1;
3283     my>>=1;
3284
3285     uvsrc_x = s->mb_x *  8                 + mx;
3286     uvsrc_y = s->mb_y * (8 >> field_based) + my;
3287
3288     ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3289     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3290     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3291
3292     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3293        || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3294         ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3295                          src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3296         ptr_y= s->edge_emu_buffer;
3297         if(!(s->flags&CODEC_FLAG_GRAY)){
3298             uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3299             ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3300                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3301             ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3302                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3303             ptr_cb= uvbuf;
3304             ptr_cr= uvbuf + 16;
3305         }
3306     }
3307
3308     if(!field_based)
3309         qpix_op[0][dxy](dest_y, ptr_y, linesize);
3310     else{
3311         if(bottom_field){
3312             dest_y += s->linesize;
3313             dest_cb+= s->uvlinesize;
3314             dest_cr+= s->uvlinesize;
3315         }
3316
3317         if(field_select){
3318             ptr_y  += s->linesize;
3319             ptr_cb += s->uvlinesize;
3320             ptr_cr += s->uvlinesize;
3321         }
3322         //damn interlaced mode
3323         //FIXME boundary mirroring is not exactly correct here
3324         qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3325         qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3326     }
3327     if(!(s->flags&CODEC_FLAG_GRAY)){
3328         pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3329         pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3330     }
3331 }
3332
3333 inline int ff_h263_round_chroma(int x){
3334     if (x >= 0)
3335         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3336     else {
3337         x = -x;
3338         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3339     }
3340 }
3341
3342 /**
3343  * h263 chorma 4mv motion compensation.
3344  */
3345 static inline void chroma_4mv_motion(MpegEncContext *s,
3346                                      uint8_t *dest_cb, uint8_t *dest_cr,
3347                                      uint8_t **ref_picture,
3348                                      op_pixels_func *pix_op,
3349                                      int mx, int my){
3350     int dxy, emu=0, src_x, src_y, offset;
3351     uint8_t *ptr;
3352
3353     /* In case of 8X8, we construct a single chroma motion vector
3354        with a special rounding */
3355     mx= ff_h263_round_chroma(mx);
3356     my= ff_h263_round_chroma(my);
3357
3358     dxy = ((my & 1) << 1) | (mx & 1);
3359     mx >>= 1;
3360     my >>= 1;
3361
3362     src_x = s->mb_x * 8 + mx;
3363     src_y = s->mb_y * 8 + my;
3364     src_x = av_clip(src_x, -8, s->width/2);
3365     if (src_x == s->width/2)
3366         dxy &= ~1;
3367     src_y = av_clip(src_y, -8, s->height/2);
3368     if (src_y == s->height/2)
3369         dxy &= ~2;
3370
3371     offset = (src_y * (s->uvlinesize)) + src_x;
3372     ptr = ref_picture[1] + offset;
3373     if(s->flags&CODEC_FLAG_EMU_EDGE){
3374         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3375            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3376             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);
3377             ptr= s->edge_emu_buffer;
3378             emu=1;
3379         }
3380     }
3381     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3382
3383     ptr = ref_picture[2] + offset;
3384     if(emu){
3385         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);
3386         ptr= s->edge_emu_buffer;
3387     }
3388     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3389 }
3390
3391 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3392                                      uint8_t *dest_cb, uint8_t *dest_cr,
3393                                      uint8_t **ref_picture,
3394                                      h264_chroma_mc_func *pix_op,
3395                                      int mx, int my){
3396     const int lowres= s->avctx->lowres;
3397     const int block_s= 8>>lowres;
3398     const int s_mask= (2<<lowres)-1;
3399     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3400     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3401     int emu=0, src_x, src_y, offset, sx, sy;
3402     uint8_t *ptr;
3403
3404     if(s->quarter_sample){
3405         mx/=2;
3406         my/=2;
3407     }
3408
3409     /* In case of 8X8, we construct a single chroma motion vector
3410        with a special rounding */
3411     mx= ff_h263_round_chroma(mx);
3412     my= ff_h263_round_chroma(my);
3413
3414     sx= mx & s_mask;
3415     sy= my & s_mask;
3416     src_x = s->mb_x*block_s + (mx >> (lowres+1));
3417     src_y = s->mb_y*block_s + (my >> (lowres+1));
3418
3419     offset = src_y * s->uvlinesize + src_x;
3420     ptr = ref_picture[1] + offset;
3421     if(s->flags&CODEC_FLAG_EMU_EDGE){
3422         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3423            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3424             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3425             ptr= s->edge_emu_buffer;
3426             emu=1;
3427         }
3428     }
3429     sx <<= 2 - lowres;
3430     sy <<= 2 - lowres;
3431     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3432
3433     ptr = ref_picture[2] + offset;
3434     if(emu){
3435         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3436         ptr= s->edge_emu_buffer;
3437     }
3438     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3439 }
3440
3441 static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3442     /* fetch pixels for estimated mv 4 macroblocks ahead
3443      * optimized for 64byte cache lines */
3444     const int shift = s->quarter_sample ? 2 : 1;
3445     const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3446     const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3447     int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3448     s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3449     off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3450     s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3451 }
3452
3453 /**
3454  * motion compensation of a single macroblock
3455  * @param s context
3456  * @param dest_y luma destination pointer
3457  * @param dest_cb chroma cb/u destination pointer
3458  * @param dest_cr chroma cr/v destination pointer
3459  * @param dir direction (0->forward, 1->backward)
3460  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3461  * @param pic_op halfpel motion compensation function (average or put normally)
3462  * @param pic_op qpel motion compensation function (average or put normally)
3463  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3464  */
3465 static inline void MPV_motion(MpegEncContext *s,
3466                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3467                               int dir, uint8_t **ref_picture,
3468                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3469 {
3470     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3471     int mb_x, mb_y, i;
3472     uint8_t *ptr, *dest;
3473
3474     mb_x = s->mb_x;
3475     mb_y = s->mb_y;
3476
3477     prefetch_motion(s, ref_picture, dir);
3478
3479     if(s->obmc && s->pict_type != B_TYPE){
3480         int16_t mv_cache[4][4][2];
3481         const int xy= s->mb_x + s->mb_y*s->mb_stride;
3482         const int mot_stride= s->b8_stride;
3483         const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3484
3485         assert(!s->mb_skipped);
3486
3487         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3488         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3489         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3490
3491         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3492             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3493         }else{
3494             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3495         }
3496
3497         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3498             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3499             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3500         }else{
3501             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3502             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3503         }
3504
3505         if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3506             *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3507             *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3508         }else{
3509             *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3510             *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3511         }
3512
3513         mx = 0;
3514         my = 0;
3515         for(i=0;i<4;i++) {
3516             const int x= (i&1)+1;
3517             const int y= (i>>1)+1;