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