dummy support for mpeg2 non linear quant
[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_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_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_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 than %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= av_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->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->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     s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT);
1019
1020     if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1021         av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1022         return -1;
1023     }
1024
1025     if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1026         av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1027     }
1028
1029     if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1030         av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1031         return -1;
1032     }
1033
1034     if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1035         av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1036         return -1;
1037     }
1038
1039     if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1040        && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1041        && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1042
1043         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");
1044     }
1045
1046     if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1047        && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1048         av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1049         return -1;
1050     }
1051
1052     if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1053         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1054         return -1;
1055     }
1056
1057     if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1058         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1059         return -1;
1060     }
1061
1062     if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1063         av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1064         return -1;
1065     }
1066
1067     if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1068         av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1069         return -1;
1070     }
1071
1072     if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1073         av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1074         return -1;
1075     }
1076
1077     if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1078        && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1079         av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1080         return -1;
1081     }
1082
1083     if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1084         av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1085         return -1;
1086     }
1087
1088     if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1089         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1090         return -1;
1091     }
1092
1093     if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1094         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1095         return -1;
1096     }
1097
1098     if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1099         av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n");
1100         return -1;
1101     }
1102
1103     if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1104         av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1105         return -1;
1106     }
1107
1108     if(s->flags & CODEC_FLAG_LOW_DELAY){
1109         if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
1110             av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
1111             return -1;
1112         }
1113         if (s->max_b_frames != 0){
1114             av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
1115             return -1;
1116         }
1117     }
1118
1119     if(s->q_scale_type == 1){
1120         if(s->codec_id != CODEC_ID_MPEG2VIDEO){
1121             av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n");
1122             return -1;
1123         }
1124         if(avctx->qmax > 12){
1125             av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n");
1126             return -1;
1127         }
1128     }
1129
1130     if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1131        && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1132        && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1133         av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1134         return -1;
1135     }
1136
1137     if(s->avctx->thread_count > 1)
1138         s->rtp_mode= 1;
1139
1140     if(!avctx->time_base.den || !avctx->time_base.num){
1141         av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1142         return -1;
1143     }
1144
1145     i= (INT_MAX/2+128)>>8;
1146     if(avctx->me_threshold >= i){
1147         av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1148         return -1;
1149     }
1150     if(avctx->mb_threshold >= i){
1151         av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1152         return -1;
1153     }
1154
1155     if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1156         av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1157         avctx->b_frame_strategy = 0;
1158     }
1159
1160     i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1161     if(i > 1){
1162         av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1163         avctx->time_base.den /= i;
1164         avctx->time_base.num /= i;
1165 //        return -1;
1166     }
1167
1168     if(s->codec_id==CODEC_ID_MJPEG){
1169         s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1170         s->inter_quant_bias= 0;
1171     }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1172         s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1173         s->inter_quant_bias= 0;
1174     }else{
1175         s->intra_quant_bias=0;
1176         s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1177     }
1178
1179     if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1180         s->intra_quant_bias= avctx->intra_quant_bias;
1181     if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1182         s->inter_quant_bias= avctx->inter_quant_bias;
1183
1184     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1185
1186     if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1187         av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1188         return -1;
1189     }
1190     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1191
1192     switch(avctx->codec->id) {
1193     case CODEC_ID_MPEG1VIDEO:
1194         s->out_format = FMT_MPEG1;
1195         s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1196         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1197         break;
1198     case CODEC_ID_MPEG2VIDEO:
1199         s->out_format = FMT_MPEG1;
1200         s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1201         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1202         s->rtp_mode= 1;
1203         break;
1204     case CODEC_ID_LJPEG:
1205     case CODEC_ID_JPEGLS:
1206     case CODEC_ID_MJPEG:
1207         s->out_format = FMT_MJPEG;
1208         s->intra_only = 1; /* force intra only for jpeg */
1209         s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1210         s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1211         s->mjpeg_vsample[0] = 2;
1212         s->mjpeg_vsample[1] = 2>>chroma_v_shift;
1213         s->mjpeg_vsample[2] = 2>>chroma_v_shift;
1214         s->mjpeg_hsample[0] = 2;
1215         s->mjpeg_hsample[1] = 2>>chroma_h_shift;
1216         s->mjpeg_hsample[2] = 2>>chroma_h_shift;
1217         if (mjpeg_init(s) < 0)
1218             return -1;
1219         avctx->delay=0;
1220         s->low_delay=1;
1221         break;
1222 #ifdef CONFIG_H261_ENCODER
1223     case CODEC_ID_H261:
1224         if (ff_h261_get_picture_format(s->width, s->height) < 0) {
1225             av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height);
1226             return -1;
1227         }
1228         s->out_format = FMT_H261;
1229         avctx->delay=0;
1230         s->low_delay=1;
1231         break;
1232 #endif
1233     case CODEC_ID_H263:
1234         if (h263_get_picture_format(s->width, s->height) == 7) {
1235             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);
1236             return -1;
1237         }
1238         s->out_format = FMT_H263;
1239         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1240         avctx->delay=0;
1241         s->low_delay=1;
1242         break;
1243     case CODEC_ID_H263P:
1244         s->out_format = FMT_H263;
1245         s->h263_plus = 1;
1246         /* Fx */
1247         s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1248         s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0;
1249         s->modified_quant= s->h263_aic;
1250         s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1251         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1252         s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1253         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1254         s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1255
1256         /* /Fx */
1257         /* These are just to be sure */
1258         avctx->delay=0;
1259         s->low_delay=1;
1260         break;
1261     case CODEC_ID_FLV1:
1262         s->out_format = FMT_H263;
1263         s->h263_flv = 2; /* format = 1; 11-bit codes */
1264         s->unrestricted_mv = 1;
1265         s->rtp_mode=0; /* don't allow GOB */
1266         avctx->delay=0;
1267         s->low_delay=1;
1268         break;
1269     case CODEC_ID_RV10:
1270         s->out_format = FMT_H263;
1271         avctx->delay=0;
1272         s->low_delay=1;
1273         break;
1274     case CODEC_ID_RV20:
1275         s->out_format = FMT_H263;
1276         avctx->delay=0;
1277         s->low_delay=1;
1278         s->modified_quant=1;
1279         s->h263_aic=1;
1280         s->h263_plus=1;
1281         s->loop_filter=1;
1282         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1283         break;
1284     case CODEC_ID_MPEG4:
1285         s->out_format = FMT_H263;
1286         s->h263_pred = 1;
1287         s->unrestricted_mv = 1;
1288         s->low_delay= s->max_b_frames ? 0 : 1;
1289         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1290         break;
1291     case CODEC_ID_MSMPEG4V1:
1292         s->out_format = FMT_H263;
1293         s->h263_msmpeg4 = 1;
1294         s->h263_pred = 1;
1295         s->unrestricted_mv = 1;
1296         s->msmpeg4_version= 1;
1297         avctx->delay=0;
1298         s->low_delay=1;
1299         break;
1300     case CODEC_ID_MSMPEG4V2:
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= 2;
1306         avctx->delay=0;
1307         s->low_delay=1;
1308         break;
1309     case CODEC_ID_MSMPEG4V3:
1310         s->out_format = FMT_H263;
1311         s->h263_msmpeg4 = 1;
1312         s->h263_pred = 1;
1313         s->unrestricted_mv = 1;
1314         s->msmpeg4_version= 3;
1315         s->flipflop_rounding=1;
1316         avctx->delay=0;
1317         s->low_delay=1;
1318         break;
1319     case CODEC_ID_WMV1:
1320         s->out_format = FMT_H263;
1321         s->h263_msmpeg4 = 1;
1322         s->h263_pred = 1;
1323         s->unrestricted_mv = 1;
1324         s->msmpeg4_version= 4;
1325         s->flipflop_rounding=1;
1326         avctx->delay=0;
1327         s->low_delay=1;
1328         break;
1329     case CODEC_ID_WMV2:
1330         s->out_format = FMT_H263;
1331         s->h263_msmpeg4 = 1;
1332         s->h263_pred = 1;
1333         s->unrestricted_mv = 1;
1334         s->msmpeg4_version= 5;
1335         s->flipflop_rounding=1;
1336         avctx->delay=0;
1337         s->low_delay=1;
1338         break;
1339     default:
1340         return -1;
1341     }
1342
1343     avctx->has_b_frames= !s->low_delay;
1344
1345     s->encoding = 1;
1346
1347     /* init */
1348     if (MPV_common_init(s) < 0)
1349         return -1;
1350
1351     if(s->modified_quant)
1352         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1353     s->progressive_frame=
1354     s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
1355     s->quant_precision=5;
1356
1357     ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1358     ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1359
1360 #ifdef CONFIG_H261_ENCODER
1361     if (s->out_format == FMT_H261)
1362         ff_h261_encode_init(s);
1363 #endif
1364     if (s->out_format == FMT_H263)
1365         h263_encode_init(s);
1366     if(s->msmpeg4_version)
1367         ff_msmpeg4_encode_init(s);
1368     if (s->out_format == FMT_MPEG1)
1369         ff_mpeg1_encode_init(s);
1370
1371     /* init q matrix */
1372     for(i=0;i<64;i++) {
1373         int j= s->dsp.idct_permutation[i];
1374         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1375             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1376             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1377         }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1378             s->intra_matrix[j] =
1379             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1380         }else
1381         { /* mpeg1/2 */
1382             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1383             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1384         }
1385         if(s->avctx->intra_matrix)
1386             s->intra_matrix[j] = s->avctx->intra_matrix[i];
1387         if(s->avctx->inter_matrix)
1388             s->inter_matrix[j] = s->avctx->inter_matrix[i];
1389     }
1390
1391     /* precompute matrix */
1392     /* for mjpeg, we do include qscale in the matrix */
1393     if (s->out_format != FMT_MJPEG) {
1394         convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1395                        s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1396         convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1397                        s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1398     }
1399
1400     if(ff_rate_control_init(s) < 0)
1401         return -1;
1402
1403     return 0;
1404 }
1405
1406 int MPV_encode_end(AVCodecContext *avctx)
1407 {
1408     MpegEncContext *s = avctx->priv_data;
1409
1410     ff_rate_control_uninit(s);
1411
1412     MPV_common_end(s);
1413     if (s->out_format == FMT_MJPEG)
1414         mjpeg_close(s);
1415
1416     av_freep(&avctx->extradata);
1417
1418     return 0;
1419 }
1420
1421 #endif //CONFIG_ENCODERS
1422
1423 void init_rl(RLTable *rl, int use_static)
1424 {
1425     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1426     uint8_t index_run[MAX_RUN+1];
1427     int last, run, level, start, end, i;
1428
1429     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1430     if(use_static && rl->max_level[0])
1431         return;
1432
1433     /* compute max_level[], max_run[] and index_run[] */
1434     for(last=0;last<2;last++) {
1435         if (last == 0) {
1436             start = 0;
1437             end = rl->last;
1438         } else {
1439             start = rl->last;
1440             end = rl->n;
1441         }
1442
1443         memset(max_level, 0, MAX_RUN + 1);
1444         memset(max_run, 0, MAX_LEVEL + 1);
1445         memset(index_run, rl->n, MAX_RUN + 1);
1446         for(i=start;i<end;i++) {
1447             run = rl->table_run[i];
1448             level = rl->table_level[i];
1449             if (index_run[run] == rl->n)
1450                 index_run[run] = i;
1451             if (level > max_level[run])
1452                 max_level[run] = level;
1453             if (run > max_run[level])
1454                 max_run[level] = run;
1455         }
1456         if(use_static)
1457             rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1458         else
1459             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1460         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1461         if(use_static)
1462             rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1463         else
1464             rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1465         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1466         if(use_static)
1467             rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1468         else
1469             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1470         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1471     }
1472 }
1473
1474 /* draw the edges of width 'w' of an image of size width, height */
1475 //FIXME check that this is ok for mpeg4 interlaced
1476 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1477 {
1478     uint8_t *ptr, *last_line;
1479     int i;
1480
1481     last_line = buf + (height - 1) * wrap;
1482     for(i=0;i<w;i++) {
1483         /* top and bottom */
1484         memcpy(buf - (i + 1) * wrap, buf, width);
1485         memcpy(last_line + (i + 1) * wrap, last_line, width);
1486     }
1487     /* left and right */
1488     ptr = buf;
1489     for(i=0;i<height;i++) {
1490         memset(ptr - w, ptr[0], w);
1491         memset(ptr + width, ptr[width-1], w);
1492         ptr += wrap;
1493     }
1494     /* corners */
1495     for(i=0;i<w;i++) {
1496         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1497         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1498         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1499         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1500     }
1501 }
1502
1503 int ff_find_unused_picture(MpegEncContext *s, int shared){
1504     int i;
1505
1506     if(shared){
1507         for(i=0; i<MAX_PICTURE_COUNT; i++){
1508             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1509         }
1510     }else{
1511         for(i=0; i<MAX_PICTURE_COUNT; i++){
1512             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1513         }
1514         for(i=0; i<MAX_PICTURE_COUNT; i++){
1515             if(s->picture[i].data[0]==NULL) return i;
1516         }
1517     }
1518
1519     assert(0);
1520     return -1;
1521 }
1522
1523 static void update_noise_reduction(MpegEncContext *s){
1524     int intra, i;
1525
1526     for(intra=0; intra<2; intra++){
1527         if(s->dct_count[intra] > (1<<16)){
1528             for(i=0; i<64; i++){
1529                 s->dct_error_sum[intra][i] >>=1;
1530             }
1531             s->dct_count[intra] >>= 1;
1532         }
1533
1534         for(i=0; i<64; i++){
1535             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);
1536         }
1537     }
1538 }
1539
1540 /**
1541  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1542  */
1543 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1544 {
1545     int i;
1546     AVFrame *pic;
1547     s->mb_skipped = 0;
1548
1549     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1550
1551     /* mark&release old frames */
1552     if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1553       if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1554         avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1555
1556         /* release forgotten pictures */
1557         /* if(mpeg124/h263) */
1558         if(!s->encoding){
1559             for(i=0; i<MAX_PICTURE_COUNT; i++){
1560                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1561                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1562                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1563                 }
1564             }
1565         }
1566       }
1567     }
1568 alloc:
1569     if(!s->encoding){
1570         /* release non reference frames */
1571         for(i=0; i<MAX_PICTURE_COUNT; i++){
1572             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1573                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1574             }
1575         }
1576
1577         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1578             pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1579         else{
1580             i= ff_find_unused_picture(s, 0);
1581             pic= (AVFrame*)&s->picture[i];
1582         }
1583
1584         pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1585                         && !s->dropable ? 3 : 0;
1586
1587         pic->coded_picture_number= s->coded_picture_number++;
1588
1589         if( alloc_picture(s, (Picture*)pic, 0) < 0)
1590             return -1;
1591
1592         s->current_picture_ptr= (Picture*)pic;
1593         s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1594         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1595     }
1596
1597     s->current_picture_ptr->pict_type= s->pict_type;
1598 //    if(s->flags && CODEC_FLAG_QSCALE)
1599   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1600     s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1601
1602     copy_picture(&s->current_picture, s->current_picture_ptr);
1603
1604     if (s->pict_type != B_TYPE) {
1605         s->last_picture_ptr= s->next_picture_ptr;
1606         if(!s->dropable)
1607             s->next_picture_ptr= s->current_picture_ptr;
1608     }
1609 /*    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,
1610         s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1611         s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1612         s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1613         s->pict_type, s->dropable);*/
1614
1615     if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1616     if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1617
1618     if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
1619         av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1620         assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1621         goto alloc;
1622     }
1623
1624     assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1625
1626     if(s->picture_structure!=PICT_FRAME){
1627         int i;
1628         for(i=0; i<4; i++){
1629             if(s->picture_structure == PICT_BOTTOM_FIELD){
1630                  s->current_picture.data[i] += s->current_picture.linesize[i];
1631             }
1632             s->current_picture.linesize[i] *= 2;
1633             s->last_picture.linesize[i] *=2;
1634             s->next_picture.linesize[i] *=2;
1635         }
1636     }
1637
1638     s->hurry_up= s->avctx->hurry_up;
1639     s->error_resilience= avctx->error_resilience;
1640
1641     /* set dequantizer, we can't do it during init as it might change for mpeg4
1642        and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1643     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1644         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1645         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1646     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1647         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1648         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1649     }else{
1650         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1651         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1652     }
1653
1654     if(s->dct_error_sum){
1655         assert(s->avctx->noise_reduction && s->encoding);
1656
1657         update_noise_reduction(s);
1658     }
1659
1660 #ifdef HAVE_XVMC
1661     if(s->avctx->xvmc_acceleration)
1662         return XVMC_field_start(s, avctx);
1663 #endif
1664     return 0;
1665 }
1666
1667 /* generic function for encode/decode called after a frame has been coded/decoded */
1668 void MPV_frame_end(MpegEncContext *s)
1669 {
1670     int i;
1671     /* draw edge for correct motion prediction if outside */
1672 #ifdef HAVE_XVMC
1673 //just to make sure that all data is rendered.
1674     if(s->avctx->xvmc_acceleration){
1675         XVMC_field_end(s);
1676     }else
1677 #endif
1678     if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1679             draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1680             draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1681             draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1682     }
1683     emms_c();
1684
1685     s->last_pict_type    = s->pict_type;
1686     s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1687     if(s->pict_type!=B_TYPE){
1688         s->last_non_b_pict_type= s->pict_type;
1689     }
1690 #if 0
1691         /* copy back current_picture variables */
1692     for(i=0; i<MAX_PICTURE_COUNT; i++){
1693         if(s->picture[i].data[0] == s->current_picture.data[0]){
1694             s->picture[i]= s->current_picture;
1695             break;
1696         }
1697     }
1698     assert(i<MAX_PICTURE_COUNT);
1699 #endif
1700
1701     if(s->encoding){
1702         /* release non-reference frames */
1703         for(i=0; i<MAX_PICTURE_COUNT; i++){
1704             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1705                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1706             }
1707         }
1708     }
1709     // clear copies, to avoid confusion
1710 #if 0
1711     memset(&s->last_picture, 0, sizeof(Picture));
1712     memset(&s->next_picture, 0, sizeof(Picture));
1713     memset(&s->current_picture, 0, sizeof(Picture));
1714 #endif
1715     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1716 }
1717
1718 /**
1719  * draws an line from (ex, ey) -> (sx, sy).
1720  * @param w width of the image
1721  * @param h height of the image
1722  * @param stride stride/linesize of the image
1723  * @param color color of the arrow
1724  */
1725 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1726     int x, y, fr, f;
1727
1728     sx= av_clip(sx, 0, w-1);
1729     sy= av_clip(sy, 0, h-1);
1730     ex= av_clip(ex, 0, w-1);
1731     ey= av_clip(ey, 0, h-1);
1732
1733     buf[sy*stride + sx]+= color;
1734
1735     if(FFABS(ex - sx) > FFABS(ey - sy)){
1736         if(sx > ex){
1737             FFSWAP(int, sx, ex);
1738             FFSWAP(int, sy, ey);
1739         }
1740         buf+= sx + sy*stride;
1741         ex-= sx;
1742         f= ((ey-sy)<<16)/ex;
1743         for(x= 0; x <= ex; x++){
1744             y = (x*f)>>16;
1745             fr= (x*f)&0xFFFF;
1746             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1747             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1748         }
1749     }else{
1750         if(sy > ey){
1751             FFSWAP(int, sx, ex);
1752             FFSWAP(int, sy, ey);
1753         }
1754         buf+= sx + sy*stride;
1755         ey-= sy;
1756         if(ey) f= ((ex-sx)<<16)/ey;
1757         else   f= 0;
1758         for(y= 0; y <= ey; y++){
1759             x = (y*f)>>16;
1760             fr= (y*f)&0xFFFF;
1761             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1762             buf[y*stride + x+1]+= (color*         fr )>>16;;
1763         }
1764     }
1765 }
1766
1767 /**
1768  * draws an arrow from (ex, ey) -> (sx, sy).
1769  * @param w width of the image
1770  * @param h height of the image
1771  * @param stride stride/linesize of the image
1772  * @param color color of the arrow
1773  */
1774 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1775     int dx,dy;
1776
1777     sx= av_clip(sx, -100, w+100);
1778     sy= av_clip(sy, -100, h+100);
1779     ex= av_clip(ex, -100, w+100);
1780     ey= av_clip(ey, -100, h+100);
1781
1782     dx= ex - sx;
1783     dy= ey - sy;
1784
1785     if(dx*dx + dy*dy > 3*3){
1786         int rx=  dx + dy;
1787         int ry= -dx + dy;
1788         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1789
1790         //FIXME subpixel accuracy
1791         rx= ROUNDED_DIV(rx*3<<4, length);
1792         ry= ROUNDED_DIV(ry*3<<4, length);
1793
1794         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1795         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1796     }
1797     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1798 }
1799
1800 /**
1801  * prints debuging info for the given picture.
1802  */
1803 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1804
1805     if(!pict || !pict->mb_type) return;
1806
1807     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1808         int x,y;
1809
1810         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1811         switch (pict->pict_type) {
1812             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1813             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1814             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1815             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1816             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1817             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1818         }
1819         for(y=0; y<s->mb_height; y++){
1820             for(x=0; x<s->mb_width; x++){
1821                 if(s->avctx->debug&FF_DEBUG_SKIP){
1822                     int count= s->mbskip_table[x + y*s->mb_stride];
1823                     if(count>9) count=9;
1824                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1825                 }
1826                 if(s->avctx->debug&FF_DEBUG_QP){
1827                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1828                 }
1829                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1830                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1831                     //Type & MV direction
1832                     if(IS_PCM(mb_type))
1833                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1834                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1835                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1836                     else if(IS_INTRA4x4(mb_type))
1837                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1838                     else if(IS_INTRA16x16(mb_type))
1839                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1840                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1841                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1842                     else if(IS_DIRECT(mb_type))
1843                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1844                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1845                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1846                     else if(IS_GMC(mb_type))
1847                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1848                     else if(IS_SKIP(mb_type))
1849                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1850                     else if(!USES_LIST(mb_type, 1))
1851                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1852                     else if(!USES_LIST(mb_type, 0))
1853                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1854                     else{
1855                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1856                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1857                     }
1858
1859                     //segmentation
1860                     if(IS_8X8(mb_type))
1861                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1862                     else if(IS_16X8(mb_type))
1863                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1864                     else if(IS_8X16(mb_type))
1865                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1866                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1867                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1868                     else
1869                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1870
1871
1872                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1873                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1874                     else
1875                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1876                 }
1877 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1878             }
1879             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1880         }
1881     }
1882
1883     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1884         const int shift= 1 + s->quarter_sample;
1885         int mb_y;
1886         uint8_t *ptr;
1887         int i;
1888         int h_chroma_shift, v_chroma_shift;
1889         const int width = s->avctx->width;
1890         const int height= s->avctx->height;
1891         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1892         const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1893         s->low_delay=0; //needed to see the vectors without trashing the buffers
1894
1895         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1896         for(i=0; i<3; i++){
1897             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1898             pict->data[i]= s->visualization_buffer[i];
1899         }
1900         pict->type= FF_BUFFER_TYPE_COPY;
1901         ptr= pict->data[0];
1902
1903         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1904             int mb_x;
1905             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1906                 const int mb_index= mb_x + mb_y*s->mb_stride;
1907                 if((s->avctx->debug_mv) && pict->motion_val){
1908                   int type;
1909                   for(type=0; type<3; type++){
1910                     int direction = 0;
1911                     switch (type) {
1912                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1913                                 continue;
1914                               direction = 0;
1915                               break;
1916                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1917                                 continue;
1918                               direction = 0;
1919                               break;
1920                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1921                                 continue;
1922                               direction = 1;
1923                               break;
1924                     }
1925                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1926                         continue;
1927
1928                     if(IS_8X8(pict->mb_type[mb_index])){
1929                       int i;
1930                       for(i=0; i<4; i++){
1931                         int sx= mb_x*16 + 4 + 8*(i&1);
1932                         int sy= mb_y*16 + 4 + 8*(i>>1);
1933                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1934                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1935                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1936                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1937                       }
1938                     }else if(IS_16X8(pict->mb_type[mb_index])){
1939                       int i;
1940                       for(i=0; i<2; i++){
1941                         int sx=mb_x*16 + 8;
1942                         int sy=mb_y*16 + 4 + 8*i;
1943                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1944                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1945                         int my=(pict->motion_val[direction][xy][1]>>shift);
1946
1947                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1948                             my*=2;
1949
1950                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1951                       }
1952                     }else if(IS_8X16(pict->mb_type[mb_index])){
1953                       int i;
1954                       for(i=0; i<2; i++){
1955                         int sx=mb_x*16 + 4 + 8*i;
1956                         int sy=mb_y*16 + 8;
1957                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1958                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1959                         int my=(pict->motion_val[direction][xy][1]>>shift);
1960
1961                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1962                             my*=2;
1963
1964                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1965                       }
1966                     }else{
1967                       int sx= mb_x*16 + 8;
1968                       int sy= mb_y*16 + 8;
1969                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1970                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1971                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1972                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1973                     }
1974                   }
1975                 }
1976                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1977                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1978                     int y;
1979                     for(y=0; y<8; y++){
1980                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1981                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1982                     }
1983                 }
1984                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1985                     int mb_type= pict->mb_type[mb_index];
1986                     uint64_t u,v;
1987                     int y;
1988 #define COLOR(theta, r)\
1989 u= (int)(128 + r*cos(theta*3.141592/180));\
1990 v= (int)(128 + r*sin(theta*3.141592/180));
1991
1992
1993                     u=v=128;
1994                     if(IS_PCM(mb_type)){
1995                         COLOR(120,48)
1996                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1997                         COLOR(30,48)
1998                     }else if(IS_INTRA4x4(mb_type)){
1999                         COLOR(90,48)
2000                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
2001 //                        COLOR(120,48)
2002                     }else if(IS_DIRECT(mb_type)){
2003                         COLOR(150,48)
2004                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
2005                         COLOR(170,48)
2006                     }else if(IS_GMC(mb_type)){
2007                         COLOR(190,48)
2008                     }else if(IS_SKIP(mb_type)){
2009 //                        COLOR(180,48)
2010                     }else if(!USES_LIST(mb_type, 1)){
2011                         COLOR(240,48)
2012                     }else if(!USES_LIST(mb_type, 0)){
2013                         COLOR(0,48)
2014                     }else{
2015                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2016                         COLOR(300,48)
2017                     }
2018
2019                     u*= 0x0101010101010101ULL;
2020                     v*= 0x0101010101010101ULL;
2021                     for(y=0; y<8; y++){
2022                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
2023                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
2024                     }
2025
2026                     //segmentation
2027                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
2028                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2029                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2030                     }
2031                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
2032                         for(y=0; y<16; y++)
2033                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
2034                     }
2035                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2036                         int dm= 1 << (mv_sample_log2-2);
2037                         for(i=0; i<4; i++){
2038                             int sx= mb_x*16 + 8*(i&1);
2039                             int sy= mb_y*16 + 8*(i>>1);
2040                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2041                             //FIXME bidir
2042                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2043                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2044                                 for(y=0; y<8; y++)
2045                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2046                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2047                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2048                         }
2049                     }
2050
2051                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2052                         // hmm
2053                     }
2054                 }
2055                 s->mbskip_table[mb_index]=0;
2056             }
2057         }
2058     }
2059 }
2060
2061 #ifdef CONFIG_ENCODERS
2062
2063 static int get_sae(uint8_t *src, int ref, int stride){
2064     int x,y;
2065     int acc=0;
2066
2067     for(y=0; y<16; y++){
2068         for(x=0; x<16; x++){
2069             acc+= FFABS(src[x+y*stride] - ref);
2070         }
2071     }
2072
2073     return acc;
2074 }
2075
2076 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2077     int x, y, w, h;
2078     int acc=0;
2079
2080     w= s->width &~15;
2081     h= s->height&~15;
2082
2083     for(y=0; y<h; y+=16){
2084         for(x=0; x<w; x+=16){
2085             int offset= x + y*stride;
2086             int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2087             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2088             int sae = get_sae(src + offset, mean, stride);
2089
2090             acc+= sae + 500 < sad;
2091         }
2092     }
2093     return acc;
2094 }
2095
2096
2097 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2098     AVFrame *pic=NULL;
2099     int64_t pts;
2100     int i;
2101     const int encoding_delay= s->max_b_frames;
2102     int direct=1;
2103
2104     if(pic_arg){
2105         pts= pic_arg->pts;
2106         pic_arg->display_picture_number= s->input_picture_number++;
2107
2108         if(pts != AV_NOPTS_VALUE){
2109             if(s->user_specified_pts != AV_NOPTS_VALUE){
2110                 int64_t time= pts;
2111                 int64_t last= s->user_specified_pts;
2112
2113                 if(time <= last){
2114                     av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2115                     return -1;
2116                 }
2117             }
2118             s->user_specified_pts= pts;
2119         }else{
2120             if(s->user_specified_pts != AV_NOPTS_VALUE){
2121                 s->user_specified_pts=
2122                 pts= s->user_specified_pts + 1;
2123                 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2124             }else{
2125                 pts= pic_arg->display_picture_number;
2126             }
2127         }
2128     }
2129
2130   if(pic_arg){
2131     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2132     if(pic_arg->linesize[0] != s->linesize) direct=0;
2133     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2134     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2135
2136 //    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2137
2138     if(direct){
2139         i= ff_find_unused_picture(s, 1);
2140
2141         pic= (AVFrame*)&s->picture[i];
2142         pic->reference= 3;
2143
2144         for(i=0; i<4; i++){
2145             pic->data[i]= pic_arg->data[i];
2146             pic->linesize[i]= pic_arg->linesize[i];
2147         }
2148         alloc_picture(s, (Picture*)pic, 1);
2149     }else{
2150         i= ff_find_unused_picture(s, 0);
2151
2152         pic= (AVFrame*)&s->picture[i];
2153         pic->reference= 3;
2154
2155         alloc_picture(s, (Picture*)pic, 0);
2156
2157         if(   pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2158            && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2159            && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2160        // empty
2161         }else{
2162             int h_chroma_shift, v_chroma_shift;
2163             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2164
2165             for(i=0; i<3; i++){
2166                 int src_stride= pic_arg->linesize[i];
2167                 int dst_stride= i ? s->uvlinesize : s->linesize;
2168                 int h_shift= i ? h_chroma_shift : 0;
2169                 int v_shift= i ? v_chroma_shift : 0;
2170                 int w= s->width >>h_shift;
2171                 int h= s->height>>v_shift;
2172                 uint8_t *src= pic_arg->data[i];
2173                 uint8_t *dst= pic->data[i];
2174
2175                 if(!s->avctx->rc_buffer_size)
2176                     dst +=INPLACE_OFFSET;
2177
2178                 if(src_stride==dst_stride)
2179                     memcpy(dst, src, src_stride*h);
2180                 else{
2181                     while(h--){
2182                         memcpy(dst, src, w);
2183                         dst += dst_stride;
2184                         src += src_stride;
2185                     }
2186                 }
2187             }
2188         }
2189     }
2190     copy_picture_attributes(s, pic, pic_arg);
2191     pic->pts= pts; //we set this here to avoid modifiying pic_arg
2192   }
2193
2194     /* shift buffer entries */
2195     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2196         s->input_picture[i-1]= s->input_picture[i];
2197
2198     s->input_picture[encoding_delay]= (Picture*)pic;
2199
2200     return 0;
2201 }
2202
2203 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2204     int x, y, plane;
2205     int score=0;
2206     int64_t score64=0;
2207
2208     for(plane=0; plane<3; plane++){
2209         const int stride= p->linesize[plane];
2210         const int bw= plane ? 1 : 2;
2211         for(y=0; y<s->mb_height*bw; y++){
2212             for(x=0; x<s->mb_width*bw; x++){
2213                 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2214                 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);
2215
2216                 switch(s->avctx->frame_skip_exp){
2217                     case 0: score= FFMAX(score, v); break;
2218                     case 1: score+= FFABS(v);break;
2219                     case 2: score+= v*v;break;
2220                     case 3: score64+= FFABS(v*v*(int64_t)v);break;
2221                     case 4: score64+= v*v*(int64_t)(v*v);break;
2222                 }
2223             }
2224         }
2225     }
2226
2227     if(score) score64= score;
2228
2229     if(score64 < s->avctx->frame_skip_threshold)
2230         return 1;
2231     if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2232         return 1;
2233     return 0;
2234 }
2235
2236 static int estimate_best_b_count(MpegEncContext *s){
2237     AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2238     AVCodecContext *c= avcodec_alloc_context();
2239     AVFrame input[FF_MAX_B_FRAMES+2];
2240     const int scale= s->avctx->brd_scale;
2241     int i, j, out_size, p_lambda, b_lambda, lambda2;
2242     int outbuf_size= s->width * s->height; //FIXME
2243     uint8_t *outbuf= av_malloc(outbuf_size);
2244     int64_t best_rd= INT64_MAX;
2245     int best_b_count= -1;
2246
2247     assert(scale>=0 && scale <=3);
2248
2249 //    emms_c();
2250     p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2251     b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2252     if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2253     lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2254
2255     c->width = s->width >> scale;
2256     c->height= s->height>> scale;
2257     c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2258     c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2259     c->mb_decision= s->avctx->mb_decision;
2260     c->me_cmp= s->avctx->me_cmp;
2261     c->mb_cmp= s->avctx->mb_cmp;
2262     c->me_sub_cmp= s->avctx->me_sub_cmp;
2263     c->pix_fmt = PIX_FMT_YUV420P;
2264     c->time_base= s->avctx->time_base;
2265     c->max_b_frames= s->max_b_frames;
2266
2267     if (avcodec_open(c, codec) < 0)
2268         return -1;
2269
2270     for(i=0; i<s->max_b_frames+2; i++){
2271         int ysize= c->width*c->height;
2272         int csize= (c->width/2)*(c->height/2);
2273         Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2274
2275         avcodec_get_frame_defaults(&input[i]);
2276         input[i].data[0]= av_malloc(ysize + 2*csize);
2277         input[i].data[1]= input[i].data[0] + ysize;
2278         input[i].data[2]= input[i].data[1] + csize;
2279         input[i].linesize[0]= c->width;
2280         input[i].linesize[1]=
2281         input[i].linesize[2]= c->width/2;
2282
2283         if(pre_input_ptr && (!i || s->input_picture[i-1])) {
2284             pre_input= *pre_input_ptr;
2285
2286             if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) {
2287                 pre_input.data[0]+=INPLACE_OFFSET;
2288                 pre_input.data[1]+=INPLACE_OFFSET;
2289                 pre_input.data[2]+=INPLACE_OFFSET;
2290             }
2291
2292             s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2293             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);
2294             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);
2295         }
2296     }
2297
2298     for(j=0; j<s->max_b_frames+1; j++){
2299         int64_t rd=0;
2300
2301         if(!s->input_picture[j])
2302             break;
2303
2304         c->error[0]= c->error[1]= c->error[2]= 0;
2305
2306         input[0].pict_type= I_TYPE;
2307         input[0].quality= 1 * FF_QP2LAMBDA;
2308         out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2309 //        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2310
2311         for(i=0; i<s->max_b_frames+1; i++){
2312             int is_p= i % (j+1) == j || i==s->max_b_frames;
2313
2314             input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2315             input[i+1].quality= is_p ? p_lambda : b_lambda;
2316             out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2317             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2318         }
2319
2320         /* get the delayed frames */
2321         while(out_size){
2322             out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2323             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2324         }
2325
2326         rd += c->error[0] + c->error[1] + c->error[2];
2327
2328         if(rd < best_rd){
2329             best_rd= rd;
2330             best_b_count= j;
2331         }
2332     }
2333
2334     av_freep(&outbuf);
2335     avcodec_close(c);
2336     av_freep(&c);
2337
2338     for(i=0; i<s->max_b_frames+2; i++){
2339         av_freep(&input[i].data[0]);
2340     }
2341
2342     return best_b_count;
2343 }
2344
2345 static void select_input_picture(MpegEncContext *s){
2346     int i;
2347
2348     for(i=1; i<MAX_PICTURE_COUNT; i++)
2349         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2350     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2351
2352     /* set next picture type & ordering */
2353     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2354         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2355             s->reordered_input_picture[0]= s->input_picture[0];
2356             s->reordered_input_picture[0]->pict_type= I_TYPE;
2357             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2358         }else{
2359             int b_frames;
2360
2361             if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2362                 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2363                 //FIXME check that te gop check above is +-1 correct
2364 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2365
2366                     if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2367                         for(i=0; i<4; i++)
2368                             s->input_picture[0]->data[i]= NULL;
2369                         s->input_picture[0]->type= 0;
2370                     }else{
2371                         assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2372                                || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2373
2374                         s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2375                     }
2376
2377                     emms_c();
2378                     ff_vbv_update(s, 0);
2379
2380                     goto no_output_pic;
2381                 }
2382             }
2383
2384             if(s->flags&CODEC_FLAG_PASS2){
2385                 for(i=0; i<s->max_b_frames+1; i++){
2386                     int pict_num= s->input_picture[0]->display_picture_number + i;
2387
2388                     if(pict_num >= s->rc_context.num_entries)
2389                         break;
2390                     if(!s->input_picture[i]){
2391                         s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2392                         break;
2393                     }
2394
2395                     s->input_picture[i]->pict_type=
2396                         s->rc_context.entry[pict_num].new_pict_type;
2397                 }
2398             }
2399
2400             if(s->avctx->b_frame_strategy==0){
2401                 b_frames= s->max_b_frames;
2402                 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2403             }else if(s->avctx->b_frame_strategy==1){
2404                 for(i=1; i<s->max_b_frames+1; i++){
2405                     if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2406                         s->input_picture[i]->b_frame_score=
2407                             get_intra_count(s, s->input_picture[i  ]->data[0],
2408                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
2409                     }
2410                 }
2411                 for(i=0; i<s->max_b_frames+1; i++){
2412                     if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2413                 }
2414
2415                 b_frames= FFMAX(0, i-1);
2416
2417                 /* reset scores */
2418                 for(i=0; i<b_frames+1; i++){
2419                     s->input_picture[i]->b_frame_score=0;
2420                 }
2421             }else if(s->avctx->b_frame_strategy==2){
2422                 b_frames= estimate_best_b_count(s);
2423             }else{
2424                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2425                 b_frames=0;
2426             }
2427
2428             emms_c();
2429 //static int b_count=0;
2430 //b_count+= b_frames;
2431 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2432
2433             for(i= b_frames - 1; i>=0; i--){
2434                 int type= s->input_picture[i]->pict_type;
2435                 if(type && type != B_TYPE)
2436                     b_frames= i;
2437             }
2438             if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2439                 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2440             }
2441
2442             if(s->picture_in_gop_number + b_frames >= s->gop_size){
2443               if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2444                     b_frames= s->gop_size - s->picture_in_gop_number - 1;
2445               }else{
2446                 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2447                     b_frames=0;
2448                 s->input_picture[b_frames]->pict_type= I_TYPE;
2449               }
2450             }
2451
2452             if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2453                && b_frames
2454                && s->input_picture[b_frames]->pict_type== I_TYPE)
2455                 b_frames--;
2456
2457             s->reordered_input_picture[0]= s->input_picture[b_frames];
2458             if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2459                 s->reordered_input_picture[0]->pict_type= P_TYPE;
2460             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2461             for(i=0; i<b_frames; i++){
2462                 s->reordered_input_picture[i+1]= s->input_picture[i];
2463                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2464                 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2465             }
2466         }
2467     }
2468 no_output_pic:
2469     if(s->reordered_input_picture[0]){
2470         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2471
2472         copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2473
2474         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){
2475             // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2476
2477             int i= ff_find_unused_picture(s, 0);
2478             Picture *pic= &s->picture[i];
2479
2480             pic->reference              = s->reordered_input_picture[0]->reference;
2481             alloc_picture(s, pic, 0);
2482
2483             /* mark us unused / free shared pic */
2484             if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
2485                 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
2486             for(i=0; i<4; i++)
2487                 s->reordered_input_picture[0]->data[i]= NULL;
2488             s->reordered_input_picture[0]->type= 0;
2489
2490             copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2491
2492             s->current_picture_ptr= pic;
2493         }else{
2494             // input is not a shared pix -> reuse buffer for current_pix
2495
2496             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2497                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2498
2499             s->current_picture_ptr= s->reordered_input_picture[0];
2500             for(i=0; i<4; i++){
2501                 s->new_picture.data[i]+= INPLACE_OFFSET;
2502             }
2503         }
2504         copy_picture(&s->current_picture, s->current_picture_ptr);
2505
2506         s->picture_number= s->new_picture.display_picture_number;
2507 //printf("dpn:%d\n", s->picture_number);
2508     }else{
2509        memset(&s->new_picture, 0, sizeof(Picture));
2510     }
2511 }
2512
2513 int MPV_encode_picture(AVCodecContext *avctx,
2514                        unsigned char *buf, int buf_size, void *data)
2515 {
2516     MpegEncContext *s = avctx->priv_data;
2517     AVFrame *pic_arg = data;
2518     int i, stuffing_count;
2519
2520     for(i=0; i<avctx->thread_count; i++){
2521         int start_y= s->thread_context[i]->start_mb_y;
2522         int   end_y= s->thread_context[i]->  end_mb_y;
2523         int h= s->mb_height;
2524         uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2525         uint8_t *end  = buf + (size_t)(((int64_t) buf_size)*  end_y/h);
2526
2527         init_put_bits(&s->thread_context[i]->pb, start, end - start);
2528     }
2529
2530     s->picture_in_gop_number++;
2531
2532     if(load_input_picture(s, pic_arg) < 0)
2533         return -1;
2534
2535     select_input_picture(s);
2536
2537     /* output? */
2538     if(s->new_picture.data[0]){
2539         s->pict_type= s->new_picture.pict_type;
2540 //emms_c();
2541 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2542         MPV_frame_start(s, avctx);
2543 vbv_retry:
2544         if (encode_picture(s, s->picture_number) < 0)
2545             return -1;
2546
2547         avctx->real_pict_num  = s->picture_number;
2548         avctx->header_bits = s->header_bits;
2549         avctx->mv_bits     = s->mv_bits;
2550         avctx->misc_bits   = s->misc_bits;
2551         avctx->i_tex_bits  = s->i_tex_bits;
2552         avctx->p_tex_bits  = s->p_tex_bits;
2553         avctx->i_count     = s->i_count;
2554         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2555         avctx->skip_count  = s->skip_count;
2556
2557         MPV_frame_end(s);
2558
2559         if (s->out_format == FMT_MJPEG)
2560             mjpeg_picture_trailer(s);
2561
2562         if(avctx->rc_buffer_size){
2563             RateControlContext *rcc= &s->rc_context;
2564             int max_size= rcc->buffer_index/3;
2565
2566             if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
2567                 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
2568                 if(s->adaptive_quant){
2569                     int i;
2570                     for(i=0; i<s->mb_height*s->mb_stride; i++)
2571                         s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale);
2572                 }
2573                 s->mb_skipped = 0;        //done in MPV_frame_start()
2574                 if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it
2575                     if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2576                         s->no_rounding ^= 1;
2577                 }
2578                 if(s->pict_type!=B_TYPE){
2579                     s->time_base= s->last_time_base;
2580                     s->last_non_b_time= s->time - s->pp_time;
2581                 }
2582 //                av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
2583                 for(i=0; i<avctx->thread_count; i++){
2584                     PutBitContext *pb= &s->thread_context[i]->pb;
2585                     init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
2586                 }
2587                 goto vbv_retry;
2588             }
2589
2590             assert(s->avctx->rc_max_rate);
2591         }
2592
2593         if(s->flags&CODEC_FLAG_PASS1)
2594             ff_write_pass1_stats(s);
2595
2596         for(i=0; i<4; i++){
2597             s->current_picture_ptr->error[i]= s->current_picture.error[i];
2598             avctx->error[i] += s->current_picture_ptr->error[i];
2599         }
2600
2601         if(s->flags&CODEC_FLAG_PASS1)
2602             assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2603         flush_put_bits(&s->pb);
2604         s->frame_bits  = put_bits_count(&s->pb);
2605
2606         stuffing_count= ff_vbv_update(s, s->frame_bits);
2607         if(stuffing_count){
2608             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2609                 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2610                 return -1;
2611             }
2612
2613             switch(s->codec_id){
2614             case CODEC_ID_MPEG1VIDEO:
2615             case CODEC_ID_MPEG2VIDEO:
2616                 while(stuffing_count--){
2617                     put_bits(&s->pb, 8, 0);
2618                 }
2619             break;
2620             case CODEC_ID_MPEG4:
2621                 put_bits(&s->pb, 16, 0);
2622                 put_bits(&s->pb, 16, 0x1C3);
2623                 stuffing_count -= 4;
2624                 while(stuffing_count--){
2625                     put_bits(&s->pb, 8, 0xFF);
2626                 }
2627             break;
2628             default:
2629                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2630             }
2631             flush_put_bits(&s->pb);
2632             s->frame_bits  = put_bits_count(&s->pb);
2633         }
2634
2635         /* update mpeg1/2 vbv_delay for CBR */
2636         if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2637            && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2638             int vbv_delay;
2639
2640             assert(s->repeat_first_field==0);
2641
2642             vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2643             assert(vbv_delay < 0xFFFF);
2644
2645             s->vbv_delay_ptr[0] &= 0xF8;
2646             s->vbv_delay_ptr[0] |= vbv_delay>>13;
2647             s->vbv_delay_ptr[1]  = vbv_delay>>5;
2648             s->vbv_delay_ptr[2] &= 0x07;
2649             s->vbv_delay_ptr[2] |= vbv_delay<<3;
2650         }
2651         s->total_bits += s->frame_bits;
2652         avctx->frame_bits  = s->frame_bits;
2653     }else{
2654         assert((pbBufPtr(&s->pb) == s->pb.buf));
2655         s->frame_bits=0;
2656     }
2657     assert((s->frame_bits&7)==0);
2658
2659     return s->frame_bits/8;
2660 }
2661
2662 #endif //CONFIG_ENCODERS
2663
2664 static inline void gmc1_motion(MpegEncContext *s,
2665                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2666                                uint8_t **ref_picture)
2667 {
2668     uint8_t *ptr;
2669     int offset, src_x, src_y, linesize, uvlinesize;
2670     int motion_x, motion_y;
2671     int emu=0;
2672
2673     motion_x= s->sprite_offset[0][0];
2674     motion_y= s->sprite_offset[0][1];
2675     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2676     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2677     motion_x<<=(3-s->sprite_warping_accuracy);
2678     motion_y<<=(3-s->sprite_warping_accuracy);
2679     src_x = av_clip(src_x, -16, s->width);
2680     if (src_x == s->width)
2681         motion_x =0;
2682     src_y = av_clip(src_y, -16, s->height);
2683     if (src_y == s->height)
2684         motion_y =0;
2685
2686     linesize = s->linesize;
2687     uvlinesize = s->uvlinesize;
2688
2689     ptr = ref_picture[0] + (src_y * linesize) + src_x;
2690
2691     if(s->flags&CODEC_FLAG_EMU_EDGE){
2692         if(   (unsigned)src_x >= s->h_edge_pos - 17
2693            || (unsigned)src_y >= s->v_edge_pos - 17){
2694             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2695             ptr= s->edge_emu_buffer;
2696         }
2697     }
2698
2699     if((motion_x|motion_y)&7){
2700         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2701         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2702     }else{
2703         int dxy;
2704
2705         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2706         if (s->no_rounding){
2707             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2708         }else{
2709             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2710         }
2711     }
2712
2713     if(s->flags&CODEC_FLAG_GRAY) return;
2714
2715     motion_x= s->sprite_offset[1][0];
2716     motion_y= s->sprite_offset[1][1];
2717     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2718     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2719     motion_x<<=(3-s->sprite_warping_accuracy);
2720     motion_y<<=(3-s->sprite_warping_accuracy);
2721     src_x = av_clip(src_x, -8, s->width>>1);
2722     if (src_x == s->width>>1)
2723         motion_x =0;
2724     src_y = av_clip(src_y, -8, s->height>>1);
2725     if (src_y == s->height>>1)
2726         motion_y =0;
2727
2728     offset = (src_y * uvlinesize) + src_x;
2729     ptr = ref_picture[1] + offset;
2730     if(s->flags&CODEC_FLAG_EMU_EDGE){
2731         if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2732            || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2733             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);
2734             ptr= s->edge_emu_buffer;
2735             emu=1;
2736         }
2737     }
2738     s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2739
2740     ptr = ref_picture[2] + offset;
2741     if(emu){
2742         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);
2743         ptr= s->edge_emu_buffer;
2744     }
2745     s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2746
2747     return;
2748 }
2749
2750 static inline void gmc_motion(MpegEncContext *s,
2751                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2752                                uint8_t **ref_picture)
2753 {
2754     uint8_t *ptr;
2755     int linesize, uvlinesize;
2756     const int a= s->sprite_warping_accuracy;
2757     int ox, oy;
2758
2759     linesize = s->linesize;
2760     uvlinesize = s->uvlinesize;
2761
2762     ptr = ref_picture[0];
2763
2764     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2765     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2766
2767     s->dsp.gmc(dest_y, ptr, linesize, 16,
2768            ox,
2769            oy,
2770            s->sprite_delta[0][0], s->sprite_delta[0][1],
2771            s->sprite_delta[1][0], s->sprite_delta[1][1],
2772            a+1, (1<<(2*a+1)) - s->no_rounding,
2773            s->h_edge_pos, s->v_edge_pos);
2774     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2775            ox + s->sprite_delta[0][0]*8,
2776            oy + s->sprite_delta[1][0]*8,
2777            s->sprite_delta[0][0], s->sprite_delta[0][1],
2778            s->sprite_delta[1][0], s->sprite_delta[1][1],
2779            a+1, (1<<(2*a+1)) - s->no_rounding,
2780            s->h_edge_pos, s->v_edge_pos);
2781
2782     if(s->flags&CODEC_FLAG_GRAY) return;
2783
2784     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2785     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2786
2787     ptr = ref_picture[1];
2788     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2789            ox,
2790            oy,
2791            s->sprite_delta[0][0], s->sprite_delta[0][1],
2792            s->sprite_delta[1][0], s->sprite_delta[1][1],
2793            a+1, (1<<(2*a+1)) - s->no_rounding,
2794            s->h_edge_pos>>1, s->v_edge_pos>>1);
2795
2796     ptr = ref_picture[2];
2797     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2798            ox,
2799            oy,
2800            s->sprite_delta[0][0], s->sprite_delta[0][1],
2801            s->sprite_delta[1][0], s->sprite_delta[1][1],
2802            a+1, (1<<(2*a+1)) - s->no_rounding,
2803            s->h_edge_pos>>1, s->v_edge_pos>>1);
2804 }
2805
2806 /**
2807  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2808  * @param buf destination buffer
2809  * @param src source buffer
2810  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2811  * @param block_w width of block
2812  * @param block_h height of block
2813  * @param src_x x coordinate of the top left sample of the block in the source buffer
2814  * @param src_y y coordinate of the top left sample of the block in the source buffer
2815  * @param w width of the source buffer
2816  * @param h height of the source buffer
2817  */
2818 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2819                                     int src_x, int src_y, int w, int h){
2820     int x, y;
2821     int start_y, start_x, end_y, end_x;
2822
2823     if(src_y>= h){
2824         src+= (h-1-src_y)*linesize;
2825         src_y=h-1;
2826     }else if(src_y<=-block_h){
2827         src+= (1-block_h-src_y)*linesize;
2828         src_y=1-block_h;
2829     }
2830     if(src_x>= w){
2831         src+= (w-1-src_x);
2832         src_x=w-1;
2833     }else if(src_x<=-block_w){
2834         src+= (1-block_w-src_x);
2835         src_x=1-block_w;
2836     }
2837
2838     start_y= FFMAX(0, -src_y);
2839     start_x= FFMAX(0, -src_x);
2840     end_y= FFMIN(block_h, h-src_y);
2841     end_x= FFMIN(block_w, w-src_x);
2842
2843     // copy existing part
2844     for(y=start_y; y<end_y; y++){
2845         for(x=start_x; x<end_x; x++){
2846             buf[x + y*linesize]= src[x + y*linesize];
2847         }
2848     }
2849
2850     //top
2851     for(y=0; y<start_y; y++){
2852         for(x=start_x; x<end_x; x++){
2853             buf[x + y*linesize]= buf[x + start_y*linesize];
2854         }
2855     }
2856
2857     //bottom
2858     for(y=end_y; y<block_h; y++){
2859         for(x=start_x; x<end_x; x++){
2860             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2861         }
2862     }
2863
2864     for(y=0; y<block_h; y++){
2865        //left
2866         for(x=0; x<start_x; x++){
2867             buf[x + y*linesize]= buf[start_x + y*linesize];
2868         }
2869
2870        //right
2871         for(x=end_x; x<block_w; x++){
2872             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2873         }
2874     }
2875 }
2876
2877 static inline int hpel_motion(MpegEncContext *s,
2878                                   uint8_t *dest, uint8_t *src,
2879                                   int field_based, int field_select,
2880                                   int src_x, int src_y,
2881                                   int width, int height, int stride,
2882                                   int h_edge_pos, int v_edge_pos,
2883                                   int w, int h, op_pixels_func *pix_op,
2884                                   int motion_x, int motion_y)
2885 {
2886     int dxy;
2887     int emu=0;
2888
2889     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2890     src_x += motion_x >> 1;
2891     src_y += motion_y >> 1;
2892
2893     /* WARNING: do no forget half pels */
2894     src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu?
2895     if (src_x == width)
2896         dxy &= ~1;
2897     src_y = av_clip(src_y, -16, height);
2898     if (src_y == height)
2899         dxy &= ~2;
2900     src += src_y * stride + src_x;
2901
2902     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2903         if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2904            || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2905             ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2906                              src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2907             src= s->edge_emu_buffer;
2908             emu=1;
2909         }
2910     }
2911     if(field_select)
2912         src += s->linesize;
2913     pix_op[dxy](dest, src, stride, h);
2914     return emu;
2915 }
2916
2917 static inline int hpel_motion_lowres(MpegEncContext *s,
2918                                   uint8_t *dest, uint8_t *src,
2919                                   int field_based, int field_select,
2920                                   int src_x, int src_y,
2921                                   int width, int height, int stride,
2922                                   int h_edge_pos, int v_edge_pos,
2923                                   int w, int h, h264_chroma_mc_func *pix_op,
2924                                   int motion_x, int motion_y)
2925 {
2926     const int lowres= s->avctx->lowres;
2927     const int s_mask= (2<<lowres)-1;
2928     int emu=0;
2929     int sx, sy;
2930
2931     if(s->quarter_sample){
2932         motion_x/=2;
2933         motion_y/=2;
2934     }
2935
2936     sx= motion_x & s_mask;
2937     sy= motion_y & s_mask;
2938     src_x += motion_x >> (lowres+1);
2939     src_y += motion_y >> (lowres+1);
2940
2941     src += src_y * stride + src_x;
2942
2943     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2944        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2945         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2946                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2947         src= s->edge_emu_buffer;
2948         emu=1;
2949     }
2950
2951     sx <<= 2 - lowres;
2952     sy <<= 2 - lowres;
2953     if(field_select)
2954         src += s->linesize;
2955     pix_op[lowres](dest, src, stride, h, sx, sy);
2956     return emu;
2957 }
2958
2959 /* apply one mpeg motion vector to the three components */
2960 static av_always_inline void mpeg_motion(MpegEncContext *s,
2961                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2962                                int field_based, int bottom_field, int field_select,
2963                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2964                                int motion_x, int motion_y, int h)
2965 {
2966     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2967     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2968
2969 #if 0
2970 if(s->quarter_sample)
2971 {
2972     motion_x>>=1;
2973     motion_y>>=1;
2974 }
2975 #endif
2976
2977     v_edge_pos = s->v_edge_pos >> field_based;
2978     linesize   = s->current_picture.linesize[0] << field_based;
2979     uvlinesize = s->current_picture.linesize[1] << field_based;
2980
2981     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2982     src_x = s->mb_x* 16               + (motion_x >> 1);
2983     src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2984
2985     if (s->out_format == FMT_H263) {
2986         if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2987             mx = (motion_x>>1)|(motion_x&1);
2988             my = motion_y >>1;
2989             uvdxy = ((my & 1) << 1) | (mx & 1);
2990             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2991             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2992         }else{
2993             uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2994             uvsrc_x = src_x>>1;
2995             uvsrc_y = src_y>>1;
2996         }
2997     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2998         mx = motion_x / 4;
2999         my = motion_y / 4;
3000         uvdxy = 0;
3001         uvsrc_x = s->mb_x*8 + mx;
3002         uvsrc_y = s->mb_y*8 + my;
3003     } else {
3004         if(s->chroma_y_shift){
3005             mx = motion_x / 2;
3006             my = motion_y / 2;
3007             uvdxy = ((my & 1) << 1) | (mx & 1);
3008             uvsrc_x = s->mb_x* 8               + (mx >> 1);
3009             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
3010         } else {
3011             if(s->chroma_x_shift){
3012             //Chroma422
3013                 mx = motion_x / 2;
3014                 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
3015                 uvsrc_x = s->mb_x* 8           + (mx >> 1);
3016                 uvsrc_y = src_y;
3017             } else {
3018             //Chroma444
3019                 uvdxy = dxy;
3020                 uvsrc_x = src_x;
3021                 uvsrc_y = src_y;
3022             }
3023         }
3024     }
3025
3026     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3027     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3028     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3029
3030     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
3031        || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
3032             if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
3033                s->codec_id == CODEC_ID_MPEG1VIDEO){
3034                 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
3035                 return ;
3036             }
3037             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3038                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3039             ptr_y = s->edge_emu_buffer;
3040             if(!(s->flags&CODEC_FLAG_GRAY)){
3041                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3042                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3043                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3044                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3045                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3046                 ptr_cb= uvbuf;
3047                 ptr_cr= uvbuf+16;
3048             }
3049     }
3050
3051     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3052         dest_y += s->linesize;
3053         dest_cb+= s->uvlinesize;
3054         dest_cr+= s->uvlinesize;
3055     }
3056
3057     if(field_select){
3058         ptr_y += s->linesize;
3059         ptr_cb+= s->uvlinesize;
3060         ptr_cr+= s->uvlinesize;
3061     }
3062
3063     pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3064
3065     if(!(s->flags&CODEC_FLAG_GRAY)){
3066         pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
3067         pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
3068     }
3069 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
3070     if(s->out_format == FMT_H261){
3071         ff_h261_loop_filter(s);
3072     }
3073 #endif
3074 }
3075
3076 /* apply one mpeg motion vector to the three components */
3077 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
3078                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3079                                int field_based, int bottom_field, int field_select,
3080                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3081                                int motion_x, int motion_y, int h)
3082 {
3083     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3084     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3085     const int lowres= s->avctx->lowres;
3086     const int block_s= 8>>lowres;
3087     const int s_mask= (2<<lowres)-1;
3088     const int h_edge_pos = s->h_edge_pos >> lowres;
3089     const int v_edge_pos = s->v_edge_pos >> lowres;
3090     linesize   = s->current_picture.linesize[0] << field_based;
3091     uvlinesize = s->current_picture.linesize[1] << field_based;
3092
3093     if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3094         motion_x/=2;
3095         motion_y/=2;
3096     }
3097
3098     if(field_based){
3099         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3100     }
3101
3102     sx= motion_x & s_mask;
3103     sy= motion_y & s_mask;
3104     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
3105     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3106
3107     if (s->out_format == FMT_H263) {
3108         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3109         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3110         uvsrc_x = src_x>>1;
3111         uvsrc_y = src_y>>1;
3112     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3113         mx = motion_x / 4;
3114         my = motion_y / 4;
3115         uvsx = (2*mx) & s_mask;
3116         uvsy = (2*my) & s_mask;
3117         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
3118         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
3119     } else {
3120         mx = motion_x / 2;
3121         my = motion_y / 2;
3122         uvsx = mx & s_mask;
3123         uvsy = my & s_mask;
3124         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
3125         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3126     }
3127
3128     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
3129     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3130     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3131
3132     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
3133        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3134             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3135                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3136             ptr_y = s->edge_emu_buffer;
3137             if(!(s->flags&CODEC_FLAG_GRAY)){
3138                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3139                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3140                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3141                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3142                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3143                 ptr_cb= uvbuf;
3144                 ptr_cr= uvbuf+16;
3145             }
3146     }
3147
3148     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3149         dest_y += s->linesize;
3150         dest_cb+= s->uvlinesize;
3151         dest_cr+= s->uvlinesize;
3152     }
3153
3154     if(field_select){
3155         ptr_y += s->linesize;
3156         ptr_cb+= s->uvlinesize;
3157         ptr_cr+= s->uvlinesize;
3158     }
3159
3160     sx <<= 2 - lowres;
3161     sy <<= 2 - lowres;
3162     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3163
3164     if(!(s->flags&CODEC_FLAG_GRAY)){
3165         uvsx <<= 2 - lowres;
3166         uvsy <<= 2 - lowres;
3167         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3168         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3169     }
3170     //FIXME h261 lowres loop filter
3171 }
3172
3173 //FIXME move to dsputil, avg variant, 16x16 version
3174 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3175     int x;
3176     uint8_t * const top   = src[1];
3177     uint8_t * const left  = src[2];
3178     uint8_t * const mid   = src[0];
3179     uint8_t * const right = src[3];
3180     uint8_t * const bottom= src[4];
3181 #define OBMC_FILTER(x, t, l, m, r, b)\
3182     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3183 #define OBMC_FILTER4(x, t, l, m, r, b)\
3184     OBMC_FILTER(x         , t, l, m, r, b);\
3185     OBMC_FILTER(x+1       , t, l, m, r, b);\
3186     OBMC_FILTER(x  +stride, t, l, m, r, b);\
3187     OBMC_FILTER(x+1+stride, t, l, m, r, b);
3188
3189     x=0;
3190     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
3191     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3192     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3193     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3194     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3195     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3196     x+= stride;
3197     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
3198     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3199     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3200     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3201     x+= stride;
3202     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
3203     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3204     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3205     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3206     x+= 2*stride;
3207     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
3208     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3209     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3210     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3211     x+= 2*stride;
3212     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
3213     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3214     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3215     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3216     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3217     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3218     x+= stride;
3219     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
3220     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3221     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3222     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3223 }
3224
3225 /* obmc for 1 8x8 luma block */
3226 static inline void obmc_motion(MpegEncContext *s,
3227                                uint8_t *dest, uint8_t *src,
3228                                int src_x, int src_y,
3229                                op_pixels_func *pix_op,
3230                                int16_t mv[5][2]/* mid top left right bottom*/)
3231 #define MID    0
3232 {
3233     int i;
3234     uint8_t *ptr[5];
3235
3236     assert(s->quarter_sample==0);
3237
3238     for(i=0; i<5; i++){
3239         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3240             ptr[i]= ptr[MID];
3241         }else{
3242             ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3243             hpel_motion(s, ptr[i], src, 0, 0,
3244                         src_x, src_y,
3245                         s->width, s->height, s->linesize,
3246                         s->h_edge_pos, s->v_edge_pos,
3247                         8, 8, pix_op,
3248                         mv[i][0], mv[i][1]);
3249         }
3250     }
3251
3252     put_obmc(dest, ptr, s->linesize);
3253 }
3254
3255 static inline void qpel_motion(MpegEncContext *s,
3256                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3257                                int field_based, int bottom_field, int field_select,
3258                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3259                                qpel_mc_func (*qpix_op)[16],
3260                                int motion_x, int motion_y, int h)
3261 {
3262     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3263     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3264
3265     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3266     src_x = s->mb_x *  16                 + (motion_x >> 2);
3267     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3268
3269     v_edge_pos = s->v_edge_pos >> field_based;
3270     linesize = s->linesize << field_based;
3271     uvlinesize = s->uvlinesize << field_based;
3272
3273     if(field_based){
3274         mx= motion_x/2;
3275         my= motion_y>>1;
3276     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3277         static const int rtab[8]= {0,0,1,1,0,0,0,1};
3278         mx= (motion_x>>1) + rtab[motion_x&7];
3279         my= (motion_y>>1) + rtab[motion_y&7];
3280     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3281         mx= (motion_x>>1)|(motion_x&1);
3282         my= (motion_y>>1)|(motion_y&1);
3283     }else{
3284         mx= motion_x/2;
3285         my= motion_y/2;
3286     }
3287     mx= (mx>>1)|(mx&1);
3288     my= (my>>1)|(my&1);
3289
3290     uvdxy= (mx&1) | ((my&1)<<1);
3291     mx>>=1;
3292     my>>=1;
3293
3294     uvsrc_x = s->mb_x *  8                 + mx;
3295     uvsrc_y = s->mb_y * (8 >> field_based) + my;
3296
3297     ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3298     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3299     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3300
3301     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3302        || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3303         ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3304                          src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3305         ptr_y= s->edge_emu_buffer;
3306         if(!(s->flags&CODEC_FLAG_GRAY)){
3307             uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3308             ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3309                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3310             ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3311                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3312             ptr_cb= uvbuf;
3313             ptr_cr= uvbuf + 16;
3314         }
3315     }
3316
3317     if(!field_based)
3318         qpix_op[0][dxy](dest_y, ptr_y, linesize);
3319     else{
3320         if(bottom_field){
3321             dest_y += s->linesize;
3322             dest_cb+= s->uvlinesize;
3323             dest_cr+= s->uvlinesize;
3324         }
3325
3326         if(field_select){
3327             ptr_y  += s->linesize;
3328             ptr_cb += s->uvlinesize;
3329             ptr_cr += s->uvlinesize;
3330         }
3331         //damn interlaced mode
3332         //FIXME boundary mirroring is not exactly correct here
3333         qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3334         qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3335     }
3336     if(!(s->flags&CODEC_FLAG_GRAY)){
3337         pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3338         pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3339     }
3340 }
3341
3342 inline int ff_h263_round_chroma(int x){
3343     if (x >= 0)
3344         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3345     else {
3346         x = -x;
3347         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3348     }
3349 }
3350
3351 /**
3352  * h263 chorma 4mv motion compensation.
3353  */
3354 static inline void chroma_4mv_motion(MpegEncContext *s,
3355                                      uint8_t *dest_cb, uint8_t *dest_cr,
3356                                      uint8_t **ref_picture,
3357                                      op_pixels_func *pix_op,
3358                                      int mx, int my){
3359     int dxy, emu=0, src_x, src_y, offset;
3360     uint8_t *ptr;
3361
3362     /* In case of 8X8, we construct a single chroma motion vector
3363        with a special rounding */
3364     mx= ff_h263_round_chroma(mx);
3365     my= ff_h263_round_chroma(my);
3366
3367     dxy = ((my & 1) << 1) | (mx & 1);
3368     mx >>= 1;
3369     my >>= 1;
3370
3371     src_x = s->mb_x * 8 + mx;
3372     src_y = s->mb_y * 8 + my;
3373     src_x = av_clip(src_x, -8, s->width/2);
3374     if (src_x == s->width/2)
3375         dxy &= ~1;
3376     src_y = av_clip(src_y, -8, s->height/2);
3377     if (src_y == s->height/2)
3378         dxy &= ~2;
3379
3380     offset = (src_y * (s->uvlinesize)) + src_x;
3381     ptr = ref_picture[1] + offset;
3382     if(s->flags&CODEC_FLAG_EMU_EDGE){
3383         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3384            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3385             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);
3386             ptr= s->edge_emu_buffer;
3387             emu=1;
3388         }
3389     }
3390     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3391
3392     ptr = ref_picture[2] + offset;
3393     if(emu){
3394         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);
3395         ptr= s->edge_emu_buffer;
3396     }
3397     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3398 }
3399
3400 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3401                                      uint8_t *dest_cb, uint8_t *dest_cr,
3402                                      uint8_t **ref_picture,
3403                                      h264_chroma_mc_func *pix_op,
3404                                      int mx, int my){
3405     const int lowres= s->avctx->lowres;
3406     const int block_s= 8>>lowres;
3407     const int s_mask= (2<<lowres)-1;
3408     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3409     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3410     int emu=0, src_x, src_y, offset, sx, sy;
3411     uint8_t *ptr;
3412
3413     if(s->quarter_sample){
3414         mx/=2;
3415         my/=2;
3416     }
3417
3418     /* In case of 8X8, we construct a single chroma motion vector
3419        with a special rounding */
3420     mx= ff_h263_round_chroma(mx);
3421     my= ff_h263_round_chroma(my);
3422
3423     sx= mx & s_mask;
3424     sy= my & s_mask;
3425     src_x = s->mb_x*block_s + (mx >> (lowres+1));
3426     src_y = s->mb_y*block_s + (my >> (lowres+1));
3427
3428     offset = src_y * s->uvlinesize + src_x;
3429     ptr = ref_picture[1] + offset;
3430     if(s->flags&CODEC_FLAG_EMU_EDGE){
3431         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3432            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3433             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3434             ptr= s->edge_emu_buffer;
3435             emu=1;
3436         }
3437     }
3438     sx <<= 2 - lowres;
3439     sy <<= 2 - lowres;
3440     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3441
3442     ptr = ref_picture[2] + offset;
3443     if(emu){
3444         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3445         ptr= s->edge_emu_buffer;
3446     }
3447     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3448 }
3449
3450 static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3451     /* fetch pixels for estimated mv 4 macroblocks ahead
3452      * optimized for 64byte cache lines */
3453     const int shift = s->quarter_sample ? 2 : 1;
3454     const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3455     const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3456     int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3457     s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3458     off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3459     s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3460 }
3461
3462 /**
3463  * motion compensation of a single macroblock
3464  * @param s context
3465  * @param dest_y luma destination pointer
3466  * @param dest_cb chroma cb/u destination pointer
3467  * @param dest_cr chroma cr/v destination pointer
3468  * @param dir direction (0->forward, 1->backward)
3469  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3470  * @param pic_op halfpel motion compensation function (average or put normally)
3471  * @param pic_op qpel motion compensation function (average or put normally)
3472  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3473  */
3474 static inline void MPV_motion(MpegEncContext *s,
3475                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3476                               int dir, uint8_t **ref_picture,
3477                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3478 {
3479     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3480     int mb_x, mb_y, i;
3481     uint8_t *ptr, *dest;
3482
3483     mb_x = s->mb_x;
3484     mb_y = s->mb_y;
3485
3486     prefetch_motion(s, ref_picture, dir);
3487
3488     if(s->obmc && s->pict_type != B_TYPE){
3489         int16_t mv_cache[4][4][2];
3490         const int xy= s->mb_x + s->mb_y*s->mb_stride;
3491         const int mot_stride= s->b8_stride;
3492         const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3493
3494         assert(!s->mb_skipped);
3495
3496         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3497         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3498         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3499
3500         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3501             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3502         }else{
3503             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3504         }
3505
3506         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3507             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3508             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3509         }else{
3510             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3511             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3512         }
3513
3514         if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3515             *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];