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