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