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