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