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