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