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