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