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