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