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