576a6b8accdf7bdda0ffd46fcc9cf70fd3b0542c
[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->lambda < s->avctx->lmax){
2539                 s->next_lambda= FFMAX(s->lambda+1, 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                 if(s->pict_type!=B_TYPE){
2546                     s->time_base= s->last_time_base;
2547                     s->last_non_b_time= s->time - s->pp_time;
2548                 }
2549 //                av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
2550                 for(i=0; i<avctx->thread_count; i++){
2551                     PutBitContext *pb= &s->thread_context[i]->pb;
2552                     init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
2553                 }
2554                 goto vbv_retry;
2555             }
2556
2557             assert(s->avctx->rc_max_rate);
2558         }
2559
2560         if(s->flags&CODEC_FLAG_PASS1)
2561             ff_write_pass1_stats(s);
2562
2563         for(i=0; i<4; i++){
2564             s->current_picture_ptr->error[i]= s->current_picture.error[i];
2565             avctx->error[i] += s->current_picture_ptr->error[i];
2566         }
2567
2568         if(s->flags&CODEC_FLAG_PASS1)
2569             assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2570         flush_put_bits(&s->pb);
2571         s->frame_bits  = put_bits_count(&s->pb);
2572
2573         stuffing_count= ff_vbv_update(s, s->frame_bits);
2574         if(stuffing_count){
2575             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2576                 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2577                 return -1;
2578             }
2579
2580             switch(s->codec_id){
2581             case CODEC_ID_MPEG1VIDEO:
2582             case CODEC_ID_MPEG2VIDEO:
2583                 while(stuffing_count--){
2584                     put_bits(&s->pb, 8, 0);
2585                 }
2586             break;
2587             case CODEC_ID_MPEG4:
2588                 put_bits(&s->pb, 16, 0);
2589                 put_bits(&s->pb, 16, 0x1C3);
2590                 stuffing_count -= 4;
2591                 while(stuffing_count--){
2592                     put_bits(&s->pb, 8, 0xFF);
2593                 }
2594             break;
2595             default:
2596                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2597             }
2598             flush_put_bits(&s->pb);
2599             s->frame_bits  = put_bits_count(&s->pb);
2600         }
2601
2602         /* update mpeg1/2 vbv_delay for CBR */
2603         if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2604            && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2605             int vbv_delay;
2606
2607             assert(s->repeat_first_field==0);
2608
2609             vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2610             assert(vbv_delay < 0xFFFF);
2611
2612             s->vbv_delay_ptr[0] &= 0xF8;
2613             s->vbv_delay_ptr[0] |= vbv_delay>>13;
2614             s->vbv_delay_ptr[1]  = vbv_delay>>5;
2615             s->vbv_delay_ptr[2] &= 0x07;
2616             s->vbv_delay_ptr[2] |= vbv_delay<<3;
2617         }
2618         s->total_bits += s->frame_bits;
2619         avctx->frame_bits  = s->frame_bits;
2620     }else{
2621         assert((pbBufPtr(&s->pb) == s->pb.buf));
2622         s->frame_bits=0;
2623     }
2624     assert((s->frame_bits&7)==0);
2625
2626     return s->frame_bits/8;
2627 }
2628
2629 #endif //CONFIG_ENCODERS
2630
2631 static inline void gmc1_motion(MpegEncContext *s,
2632                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2633                                uint8_t **ref_picture)
2634 {
2635     uint8_t *ptr;
2636     int offset, src_x, src_y, linesize, uvlinesize;
2637     int motion_x, motion_y;
2638     int emu=0;
2639
2640     motion_x= s->sprite_offset[0][0];
2641     motion_y= s->sprite_offset[0][1];
2642     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2643     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2644     motion_x<<=(3-s->sprite_warping_accuracy);
2645     motion_y<<=(3-s->sprite_warping_accuracy);
2646     src_x = clip(src_x, -16, s->width);
2647     if (src_x == s->width)
2648         motion_x =0;
2649     src_y = clip(src_y, -16, s->height);
2650     if (src_y == s->height)
2651         motion_y =0;
2652
2653     linesize = s->linesize;
2654     uvlinesize = s->uvlinesize;
2655
2656     ptr = ref_picture[0] + (src_y * linesize) + src_x;
2657
2658     if(s->flags&CODEC_FLAG_EMU_EDGE){
2659         if(   (unsigned)src_x >= s->h_edge_pos - 17
2660            || (unsigned)src_y >= s->v_edge_pos - 17){
2661             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2662             ptr= s->edge_emu_buffer;
2663         }
2664     }
2665
2666     if((motion_x|motion_y)&7){
2667         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2668         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2669     }else{
2670         int dxy;
2671
2672         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2673         if (s->no_rounding){
2674             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2675         }else{
2676             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2677         }
2678     }
2679
2680     if(s->flags&CODEC_FLAG_GRAY) return;
2681
2682     motion_x= s->sprite_offset[1][0];
2683     motion_y= s->sprite_offset[1][1];
2684     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2685     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2686     motion_x<<=(3-s->sprite_warping_accuracy);
2687     motion_y<<=(3-s->sprite_warping_accuracy);
2688     src_x = clip(src_x, -8, s->width>>1);
2689     if (src_x == s->width>>1)
2690         motion_x =0;
2691     src_y = clip(src_y, -8, s->height>>1);
2692     if (src_y == s->height>>1)
2693         motion_y =0;
2694
2695     offset = (src_y * uvlinesize) + src_x;
2696     ptr = ref_picture[1] + offset;
2697     if(s->flags&CODEC_FLAG_EMU_EDGE){
2698         if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2699            || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2700             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);
2701             ptr= s->edge_emu_buffer;
2702             emu=1;
2703         }
2704     }
2705     s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2706
2707     ptr = ref_picture[2] + offset;
2708     if(emu){
2709         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);
2710         ptr= s->edge_emu_buffer;
2711     }
2712     s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2713
2714     return;
2715 }
2716
2717 static inline void gmc_motion(MpegEncContext *s,
2718                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2719                                uint8_t **ref_picture)
2720 {
2721     uint8_t *ptr;
2722     int linesize, uvlinesize;
2723     const int a= s->sprite_warping_accuracy;
2724     int ox, oy;
2725
2726     linesize = s->linesize;
2727     uvlinesize = s->uvlinesize;
2728
2729     ptr = ref_picture[0];
2730
2731     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2732     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2733
2734     s->dsp.gmc(dest_y, ptr, linesize, 16,
2735            ox,
2736            oy,
2737            s->sprite_delta[0][0], s->sprite_delta[0][1],
2738            s->sprite_delta[1][0], s->sprite_delta[1][1],
2739            a+1, (1<<(2*a+1)) - s->no_rounding,
2740            s->h_edge_pos, s->v_edge_pos);
2741     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2742            ox + s->sprite_delta[0][0]*8,
2743            oy + s->sprite_delta[1][0]*8,
2744            s->sprite_delta[0][0], s->sprite_delta[0][1],
2745            s->sprite_delta[1][0], s->sprite_delta[1][1],
2746            a+1, (1<<(2*a+1)) - s->no_rounding,
2747            s->h_edge_pos, s->v_edge_pos);
2748
2749     if(s->flags&CODEC_FLAG_GRAY) return;
2750
2751     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2752     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2753
2754     ptr = ref_picture[1];
2755     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2756            ox,
2757            oy,
2758            s->sprite_delta[0][0], s->sprite_delta[0][1],
2759            s->sprite_delta[1][0], s->sprite_delta[1][1],
2760            a+1, (1<<(2*a+1)) - s->no_rounding,
2761            s->h_edge_pos>>1, s->v_edge_pos>>1);
2762
2763     ptr = ref_picture[2];
2764     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2765            ox,
2766            oy,
2767            s->sprite_delta[0][0], s->sprite_delta[0][1],
2768            s->sprite_delta[1][0], s->sprite_delta[1][1],
2769            a+1, (1<<(2*a+1)) - s->no_rounding,
2770            s->h_edge_pos>>1, s->v_edge_pos>>1);
2771 }
2772
2773 /**
2774  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2775  * @param buf destination buffer
2776  * @param src source buffer
2777  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2778  * @param block_w width of block
2779  * @param block_h height of block
2780  * @param src_x x coordinate of the top left sample of the block in the source buffer
2781  * @param src_y y coordinate of the top left sample of the block in the source buffer
2782  * @param w width of the source buffer
2783  * @param h height of the source buffer
2784  */
2785 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2786                                     int src_x, int src_y, int w, int h){
2787     int x, y;
2788     int start_y, start_x, end_y, end_x;
2789
2790     if(src_y>= h){
2791         src+= (h-1-src_y)*linesize;
2792         src_y=h-1;
2793     }else if(src_y<=-block_h){
2794         src+= (1-block_h-src_y)*linesize;
2795         src_y=1-block_h;
2796     }
2797     if(src_x>= w){
2798         src+= (w-1-src_x);
2799         src_x=w-1;
2800     }else if(src_x<=-block_w){
2801         src+= (1-block_w-src_x);
2802         src_x=1-block_w;
2803     }
2804
2805     start_y= FFMAX(0, -src_y);
2806     start_x= FFMAX(0, -src_x);
2807     end_y= FFMIN(block_h, h-src_y);
2808     end_x= FFMIN(block_w, w-src_x);
2809
2810     // copy existing part
2811     for(y=start_y; y<end_y; y++){
2812         for(x=start_x; x<end_x; x++){
2813             buf[x + y*linesize]= src[x + y*linesize];
2814         }
2815     }
2816
2817     //top
2818     for(y=0; y<start_y; y++){
2819         for(x=start_x; x<end_x; x++){
2820             buf[x + y*linesize]= buf[x + start_y*linesize];
2821         }
2822     }
2823
2824     //bottom
2825     for(y=end_y; y<block_h; y++){
2826         for(x=start_x; x<end_x; x++){
2827             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2828         }
2829     }
2830
2831     for(y=0; y<block_h; y++){
2832        //left
2833         for(x=0; x<start_x; x++){
2834             buf[x + y*linesize]= buf[start_x + y*linesize];
2835         }
2836
2837        //right
2838         for(x=end_x; x<block_w; x++){
2839             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2840         }
2841     }
2842 }
2843
2844 static inline int hpel_motion(MpegEncContext *s,
2845                                   uint8_t *dest, uint8_t *src,
2846                                   int field_based, int field_select,
2847                                   int src_x, int src_y,
2848                                   int width, int height, int stride,
2849                                   int h_edge_pos, int v_edge_pos,
2850                                   int w, int h, op_pixels_func *pix_op,
2851                                   int motion_x, int motion_y)
2852 {
2853     int dxy;
2854     int emu=0;
2855
2856     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2857     src_x += motion_x >> 1;
2858     src_y += motion_y >> 1;
2859
2860     /* WARNING: do no forget half pels */
2861     src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2862     if (src_x == width)
2863         dxy &= ~1;
2864     src_y = clip(src_y, -16, height);
2865     if (src_y == height)
2866         dxy &= ~2;
2867     src += src_y * stride + src_x;
2868
2869     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2870         if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2871            || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2872             ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2873                              src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2874             src= s->edge_emu_buffer;
2875             emu=1;
2876         }
2877     }
2878     if(field_select)
2879         src += s->linesize;
2880     pix_op[dxy](dest, src, stride, h);
2881     return emu;
2882 }
2883
2884 static inline int hpel_motion_lowres(MpegEncContext *s,
2885                                   uint8_t *dest, uint8_t *src,
2886                                   int field_based, int field_select,
2887                                   int src_x, int src_y,
2888                                   int width, int height, int stride,
2889                                   int h_edge_pos, int v_edge_pos,
2890                                   int w, int h, h264_chroma_mc_func *pix_op,
2891                                   int motion_x, int motion_y)
2892 {
2893     const int lowres= s->avctx->lowres;
2894     const int s_mask= (2<<lowres)-1;
2895     int emu=0;
2896     int sx, sy;
2897
2898     if(s->quarter_sample){
2899         motion_x/=2;
2900         motion_y/=2;
2901     }
2902
2903     sx= motion_x & s_mask;
2904     sy= motion_y & s_mask;
2905     src_x += motion_x >> (lowres+1);
2906     src_y += motion_y >> (lowres+1);
2907
2908     src += src_y * stride + src_x;
2909
2910     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2911        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2912         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2913                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2914         src= s->edge_emu_buffer;
2915         emu=1;
2916     }
2917
2918     sx <<= 2 - lowres;
2919     sy <<= 2 - lowres;
2920     if(field_select)
2921         src += s->linesize;
2922     pix_op[lowres](dest, src, stride, h, sx, sy);
2923     return emu;
2924 }
2925
2926 /* apply one mpeg motion vector to the three components */
2927 static always_inline void mpeg_motion(MpegEncContext *s,
2928                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2929                                int field_based, int bottom_field, int field_select,
2930                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2931                                int motion_x, int motion_y, int h)
2932 {
2933     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2934     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2935
2936 #if 0
2937 if(s->quarter_sample)
2938 {
2939     motion_x>>=1;
2940     motion_y>>=1;
2941 }
2942 #endif
2943
2944     v_edge_pos = s->v_edge_pos >> field_based;
2945     linesize   = s->current_picture.linesize[0] << field_based;
2946     uvlinesize = s->current_picture.linesize[1] << field_based;
2947
2948     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2949     src_x = s->mb_x* 16               + (motion_x >> 1);
2950     src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2951
2952     if (s->out_format == FMT_H263) {
2953         if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2954             mx = (motion_x>>1)|(motion_x&1);
2955             my = motion_y >>1;
2956             uvdxy = ((my & 1) << 1) | (mx & 1);
2957             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2958             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2959         }else{
2960             uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2961             uvsrc_x = src_x>>1;
2962             uvsrc_y = src_y>>1;
2963         }
2964     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2965         mx = motion_x / 4;
2966         my = motion_y / 4;
2967         uvdxy = 0;
2968         uvsrc_x = s->mb_x*8 + mx;
2969         uvsrc_y = s->mb_y*8 + my;
2970     } else {
2971         if(s->chroma_y_shift){
2972             mx = motion_x / 2;
2973             my = motion_y / 2;
2974             uvdxy = ((my & 1) << 1) | (mx & 1);
2975             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2976             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2977         } else {
2978             if(s->chroma_x_shift){
2979             //Chroma422
2980                 mx = motion_x / 2;
2981                 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2982                 uvsrc_x = s->mb_x* 8           + (mx >> 1);
2983                 uvsrc_y = src_y;
2984             } else {
2985             //Chroma444
2986                 uvdxy = dxy;
2987                 uvsrc_x = src_x;
2988                 uvsrc_y = src_y;
2989             }
2990         }
2991     }
2992
2993     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2994     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2995     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2996
2997     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2998        || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2999             if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
3000                s->codec_id == CODEC_ID_MPEG1VIDEO){
3001                 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
3002                 return ;
3003             }
3004             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3005                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3006             ptr_y = s->edge_emu_buffer;
3007             if(!(s->flags&CODEC_FLAG_GRAY)){
3008                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3009                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3010                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3011                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3012                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3013                 ptr_cb= uvbuf;
3014                 ptr_cr= uvbuf+16;
3015             }
3016     }
3017
3018     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3019         dest_y += s->linesize;
3020         dest_cb+= s->uvlinesize;
3021         dest_cr+= s->uvlinesize;
3022     }
3023
3024     if(field_select){
3025         ptr_y += s->linesize;
3026         ptr_cb+= s->uvlinesize;
3027         ptr_cr+= s->uvlinesize;
3028     }
3029
3030     pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3031
3032     if(!(s->flags&CODEC_FLAG_GRAY)){
3033         pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
3034         pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
3035     }
3036 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
3037     if(s->out_format == FMT_H261){
3038         ff_h261_loop_filter(s);
3039     }
3040 #endif
3041 }
3042
3043 /* apply one mpeg motion vector to the three components */
3044 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
3045                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3046                                int field_based, int bottom_field, int field_select,
3047                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3048                                int motion_x, int motion_y, int h)
3049 {
3050     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3051     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3052     const int lowres= s->avctx->lowres;
3053     const int block_s= 8>>lowres;
3054     const int s_mask= (2<<lowres)-1;
3055     const int h_edge_pos = s->h_edge_pos >> lowres;
3056     const int v_edge_pos = s->v_edge_pos >> lowres;
3057     linesize   = s->current_picture.linesize[0] << field_based;
3058     uvlinesize = s->current_picture.linesize[1] << field_based;
3059
3060     if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3061         motion_x/=2;
3062         motion_y/=2;
3063     }
3064
3065     if(field_based){
3066         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3067     }
3068
3069     sx= motion_x & s_mask;
3070     sy= motion_y & s_mask;
3071     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
3072     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3073
3074     if (s->out_format == FMT_H263) {
3075         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3076         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3077         uvsrc_x = src_x>>1;
3078         uvsrc_y = src_y>>1;
3079     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3080         mx = motion_x / 4;
3081         my = motion_y / 4;
3082         uvsx = (2*mx) & s_mask;
3083         uvsy = (2*my) & s_mask;
3084         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
3085         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
3086     } else {
3087         mx = motion_x / 2;
3088         my = motion_y / 2;
3089         uvsx = mx & s_mask;
3090         uvsy = my & s_mask;
3091         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
3092         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3093     }
3094
3095     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3096     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3097     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3098
3099     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
3100        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3101             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3102                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3103             ptr_y = s->edge_emu_buffer;
3104             if(!(s->flags&CODEC_FLAG_GRAY)){
3105                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3106                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3107                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3108                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3109                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3110                 ptr_cb= uvbuf;
3111                 ptr_cr= uvbuf+16;
3112             }
3113     }
3114
3115     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3116         dest_y += s->linesize;
3117         dest_cb+= s->uvlinesize;
3118         dest_cr+= s->uvlinesize;
3119     }
3120
3121     if(field_select){
3122         ptr_y += s->linesize;
3123         ptr_cb+= s->uvlinesize;
3124         ptr_cr+= s->uvlinesize;
3125     }
3126
3127     sx <<= 2 - lowres;
3128     sy <<= 2 - lowres;
3129     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3130
3131     if(!(s->flags&CODEC_FLAG_GRAY)){
3132         uvsx <<= 2 - lowres;
3133         uvsy <<= 2 - lowres;
3134         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3135         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3136     }
3137     //FIXME h261 lowres loop filter
3138 }
3139
3140 //FIXME move to dsputil, avg variant, 16x16 version
3141 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3142     int x;
3143     uint8_t * const top   = src[1];
3144     uint8_t * const left  = src[2];
3145     uint8_t * const mid   = src[0];
3146     uint8_t * const right = src[3];
3147     uint8_t * const bottom= src[4];
3148 #define OBMC_FILTER(x, t, l, m, r, b)\
3149     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3150 #define OBMC_FILTER4(x, t, l, m, r, b)\
3151     OBMC_FILTER(x         , t, l, m, r, b);\
3152     OBMC_FILTER(x+1       , t, l, m, r, b);\
3153     OBMC_FILTER(x  +stride, t, l, m, r, b);\
3154     OBMC_FILTER(x+1+stride, t, l, m, r, b);
3155
3156     x=0;
3157     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
3158     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3159     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3160     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3161     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3162     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3163     x+= stride;
3164     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
3165     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3166     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3167     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3168     x+= stride;
3169     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
3170     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3171     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3172     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3173     x+= 2*stride;
3174     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
3175     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3176     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3177     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3178     x+= 2*stride;
3179     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
3180     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3181     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3182     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3183     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3184     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3185     x+= stride;
3186     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
3187     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3188     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3189     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3190 }
3191
3192 /* obmc for 1 8x8 luma block */
3193 static inline void obmc_motion(MpegEncContext *s,
3194                                uint8_t *dest, uint8_t *src,
3195                                int src_x, int src_y,
3196                                op_pixels_func *pix_op,
3197                                int16_t mv[5][2]/* mid top left right bottom*/)
3198 #define MID    0
3199 {
3200     int i;
3201     uint8_t *ptr[5];
3202
3203     assert(s->quarter_sample==0);
3204
3205     for(i=0; i<5; i++){
3206         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3207             ptr[i]= ptr[MID];
3208         }else{
3209             ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3210             hpel_motion(s, ptr[i], src, 0, 0,
3211                         src_x, src_y,
3212                         s->width, s->height, s->linesize,
3213                         s->h_edge_pos, s->v_edge_pos,
3214                         8, 8, pix_op,
3215                         mv[i][0], mv[i][1]);
3216         }
3217     }
3218
3219     put_obmc(dest, ptr, s->linesize);
3220 }
3221
3222 static inline void qpel_motion(MpegEncContext *s,
3223                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3224                                int field_based, int bottom_field, int field_select,
3225                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3226                                qpel_mc_func (*qpix_op)[16],
3227                                int motion_x, int motion_y, int h)
3228 {
3229     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3230     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3231
3232     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3233     src_x = s->mb_x *  16                 + (motion_x >> 2);
3234     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3235
3236     v_edge_pos = s->v_edge_pos >> field_based;
3237     linesize = s->linesize << field_based;
3238     uvlinesize = s->uvlinesize << field_based;
3239
3240     if(field_based){
3241         mx= motion_x/2;
3242         my= motion_y>>1;
3243     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3244         static const int rtab[8]= {0,0,1,1,0,0,0,1};
3245         mx= (motion_x>>1) + rtab[motion_x&7];
3246         my= (motion_y>>1) + rtab[motion_y&7];
3247     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3248         mx= (motion_x>>1)|(motion_x&1);
3249         my= (motion_y>>1)|(motion_y&1);
3250     }else{
3251         mx= motion_x/2;
3252         my= motion_y/2;
3253     }
3254     mx= (mx>>1)|(mx&1);
3255     my= (my>>1)|(my&1);
3256
3257     uvdxy= (mx&1) | ((my&1)<<1);
3258     mx>>=1;
3259     my>>=1;
3260
3261     uvsrc_x = s->mb_x *  8                 + mx;
3262     uvsrc_y = s->mb_y * (8 >> field_based) + my;
3263
3264     ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3265     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3266     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3267
3268     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3269        || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3270         ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3271                          src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3272         ptr_y= s->edge_emu_buffer;
3273         if(!(s->flags&CODEC_FLAG_GRAY)){
3274             uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3275             ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3276                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3277             ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3278                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3279             ptr_cb= uvbuf;
3280             ptr_cr= uvbuf + 16;
3281         }
3282     }
3283
3284     if(!field_based)
3285         qpix_op[0][dxy](dest_y, ptr_y, linesize);
3286     else{
3287         if(bottom_field){
3288             dest_y += s->linesize;
3289             dest_cb+= s->uvlinesize;
3290             dest_cr+= s->uvlinesize;
3291         }
3292
3293         if(field_select){
3294             ptr_y  += s->linesize;
3295             ptr_cb += s->uvlinesize;
3296             ptr_cr += s->uvlinesize;
3297         }
3298         //damn interlaced mode
3299         //FIXME boundary mirroring is not exactly correct here
3300         qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3301         qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3302     }
3303     if(!(s->flags&CODEC_FLAG_GRAY)){
3304         pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3305         pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3306     }
3307 }
3308
3309 inline int ff_h263_round_chroma(int x){
3310     if (x >= 0)
3311         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3312     else {
3313         x = -x;
3314         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3315     }
3316 }
3317
3318 /**
3319  * h263 chorma 4mv motion compensation.
3320  */
3321 static inline void chroma_4mv_motion(MpegEncContext *s,
3322                                      uint8_t *dest_cb, uint8_t *dest_cr,
3323                                      uint8_t **ref_picture,
3324                                      op_pixels_func *pix_op,
3325                                      int mx, int my){
3326     int dxy, emu=0, src_x, src_y, offset;
3327     uint8_t *ptr;
3328
3329     /* In case of 8X8, we construct a single chroma motion vector
3330        with a special rounding */
3331     mx= ff_h263_round_chroma(mx);
3332     my= ff_h263_round_chroma(my);
3333
3334     dxy = ((my & 1) << 1) | (mx & 1);
3335     mx >>= 1;
3336     my >>= 1;
3337
3338     src_x = s->mb_x * 8 + mx;
3339     src_y = s->mb_y * 8 + my;
3340     src_x = clip(src_x, -8, s->width/2);
3341     if (src_x == s->width/2)
3342         dxy &= ~1;
3343     src_y = clip(src_y, -8, s->height/2);
3344     if (src_y == s->height/2)
3345         dxy &= ~2;
3346
3347     offset = (src_y * (s->uvlinesize)) + src_x;
3348     ptr = ref_picture[1] + offset;
3349     if(s->flags&CODEC_FLAG_EMU_EDGE){
3350         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3351            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3352             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);
3353             ptr= s->edge_emu_buffer;
3354             emu=1;
3355         }
3356     }
3357     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3358
3359     ptr = ref_picture[2] + offset;
3360     if(emu){
3361         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);
3362         ptr= s->edge_emu_buffer;
3363     }
3364     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3365 }
3366
3367 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3368                                      uint8_t *dest_cb, uint8_t *dest_cr,
3369                                      uint8_t **ref_picture,
3370                                      h264_chroma_mc_func *pix_op,
3371                                      int mx, int my){
3372     const int lowres= s->avctx->lowres;
3373     const int block_s= 8>>lowres;
3374     const int s_mask= (2<<lowres)-1;
3375     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3376     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3377     int emu=0, src_x, src_y, offset, sx, sy;
3378     uint8_t *ptr;
3379
3380     if(s->quarter_sample){
3381         mx/=2;
3382         my/=2;
3383     }
3384
3385     /* In case of 8X8, we construct a single chroma motion vector
3386        with a special rounding */
3387     mx= ff_h263_round_chroma(mx);
3388     my= ff_h263_round_chroma(my);
3389
3390     sx= mx & s_mask;
3391     sy= my & s_mask;
3392     src_x = s->mb_x*block_s + (mx >> (lowres+1));
3393     src_y = s->mb_y*block_s + (my >> (lowres+1));
3394
3395     offset = src_y * s->uvlinesize + src_x;
3396     ptr = ref_picture[1] + offset;
3397     if(s->flags&CODEC_FLAG_EMU_EDGE){
3398         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3399            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3400             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3401             ptr= s->edge_emu_buffer;
3402             emu=1;
3403         }
3404     }
3405     sx <<= 2 - lowres;
3406     sy <<= 2 - lowres;
3407     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3408
3409     ptr = ref_picture[2] + offset;
3410     if(emu){
3411         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3412         ptr= s->edge_emu_buffer;
3413     }
3414     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3415 }
3416
3417 static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3418     /* fetch pixels for estimated mv 4 macroblocks ahead
3419      * optimized for 64byte cache lines */
3420     const int shift = s->quarter_sample ? 2 : 1;
3421     const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3422     const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3423     int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3424     s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3425     off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3426     s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3427 }
3428
3429 /**
3430  * motion compensation of a single macroblock
3431  * @param s context
3432  * @param dest_y luma destination pointer
3433  * @param dest_cb chroma cb/u destination pointer
3434  * @param dest_cr chroma cr/v destination pointer
3435  * @param dir direction (0->forward, 1->backward)
3436  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3437  * @param pic_op halfpel motion compensation function (average or put normally)
3438  * @param pic_op qpel motion compensation function (average or put normally)
3439  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3440  */
3441 static inline void MPV_motion(MpegEncContext *s,
3442                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3443                               int dir, uint8_t **ref_picture,
3444                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3445 {
3446     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3447     int mb_x, mb_y, i;
3448     uint8_t *ptr, *dest;
3449
3450     mb_x = s->mb_x;
3451     mb_y = s->mb_y;
3452
3453     prefetch_motion(s, ref_picture, dir);
3454
3455     if(s->obmc && s->pict_type != B_TYPE){
3456         int16_t mv_cache[4][4][2];
3457         const int xy= s->mb_x + s->mb_y*s->mb_stride;
3458         const int mot_stride= s->b8_stride;
3459         const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3460
3461         assert(!s->mb_skipped);
3462
3463         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3464         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3465         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3466
3467         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3468             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3469         }else{
3470             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3471         }
3472
3473         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3474             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3475             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3476         }else{
3477             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3478             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3479         }
3480
3481         if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3482             *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3483             *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3484         }else{
3485             *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3486             *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3487         }
3488
3489         mx = 0;
3490         my = 0;
3491         for(i=0;i<4;i++) {
3492             const int x= (i&1)+1;
3493             const int y= (i>>1)+1;
3494             int16_t mv[5][2]= {
3495                 {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3496                 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3497                 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3498                 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3499                 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3500             //FIXME cleanup
3501             obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3502                         ref_picture[0],
3503                         mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3504                         pix_op[1],
3505                         mv);
3506
3507             mx += mv[0][0];
3508             my += mv[0][1];
3509         }
3510         if(!(s->flags&CODEC_FLAG_GRAY))
3511             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3512
3513         return;
3514     }
3515
3516     switch(s->mv_type) {
3517     case MV_TYPE_16X16:
3518         if(s->mcsel){
3519             if(s->real_sprite_warping_points==1){
3520                 gmc1_motion(s, dest_y, dest_cb, dest_cr,