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