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