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