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