b5949e60edf0a40c0c4f7999c48166f106f1547e
[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     //FIXME figure out why mpeg1/2 need this !!!
3331     if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3332         ff_set_mpeg4_time(s, s->picture_number); 
3333 #endif
3334         
3335     s->scene_change_score=0;
3336     
3337     s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
3338     
3339     if(s->pict_type==I_TYPE){
3340         if(s->msmpeg4_version >= 3) s->no_rounding=1;
3341         else                        s->no_rounding=0;
3342     }else if(s->pict_type!=B_TYPE){
3343         if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3344             s->no_rounding ^= 1;          
3345     }
3346     
3347     /* Estimate motion for every MB */
3348     s->mb_intra=0; //for the rate distoration & bit compare functions
3349     if(s->pict_type != I_TYPE){
3350         if(s->pict_type != B_TYPE){
3351             if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3352                 s->me.pre_pass=1;
3353                 s->me.dia_size= s->avctx->pre_dia_size;
3354
3355                 for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3356                     for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3357                         s->mb_x = mb_x;
3358                         s->mb_y = mb_y;
3359                         ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3360                     }
3361                 }
3362                 s->me.pre_pass=0;
3363             }
3364         }
3365
3366         s->me.dia_size= s->avctx->dia_size;
3367         for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3368             s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3369             s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3370             s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3371             s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3372             for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3373                 s->mb_x = mb_x;
3374                 s->mb_y = mb_y;
3375                 s->block_index[0]+=2;
3376                 s->block_index[1]+=2;
3377                 s->block_index[2]+=2;
3378                 s->block_index[3]+=2;
3379                 
3380                 /* compute motion vector & mb_type and store in context */
3381                 if(s->pict_type==B_TYPE)
3382                     ff_estimate_b_frame_motion(s, mb_x, mb_y);
3383                 else
3384                     ff_estimate_p_frame_motion(s, mb_x, mb_y);
3385             }
3386         }
3387     }else /* if(s->pict_type == I_TYPE) */{
3388         /* I-Frame */
3389         //FIXME do we need to zero them?
3390         memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3391         memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3392         memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3393         
3394         if(!s->fixed_qscale){
3395             /* finding spatial complexity for I-frame rate control */
3396             for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3397                 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3398                     int xx = mb_x * 16;
3399                     int yy = mb_y * 16;
3400                     uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3401                     int varc;
3402                     int sum = s->dsp.pix_sum(pix, s->linesize);
3403     
3404                     varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3405
3406                     s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3407                     s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3408                     s->current_picture.mb_var_sum    += varc;
3409                 }
3410             }
3411         }
3412     }
3413     emms_c();
3414
3415     if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
3416         s->pict_type= I_TYPE;
3417         memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3418 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3419     }
3420
3421     if(!s->umvplus){
3422         if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3423             s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3424         
3425             ff_fix_long_p_mvs(s);
3426         }
3427
3428         if(s->pict_type==B_TYPE){
3429             int a, b;
3430
3431             a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3432             b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3433             s->f_code = FFMAX(a, b);
3434
3435             a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3436             b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3437             s->b_code = FFMAX(a, b);
3438
3439             ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3440             ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3441             ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3442             ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3443         }
3444     }
3445     
3446     if (s->fixed_qscale) 
3447         s->frame_qscale = s->current_picture.quality;
3448     else
3449         s->frame_qscale = ff_rate_estimate_qscale(s);
3450
3451     if(s->adaptive_quant){
3452 #ifdef CONFIG_RISKY
3453         switch(s->codec_id){
3454         case CODEC_ID_MPEG4:
3455             ff_clean_mpeg4_qscales(s);
3456             break;
3457         case CODEC_ID_H263:
3458         case CODEC_ID_H263P:
3459         case CODEC_ID_FLV1:
3460             ff_clean_h263_qscales(s);
3461             break;
3462         }
3463 #endif
3464
3465         s->qscale= s->current_picture.qscale_table[0];
3466     }else
3467         s->qscale= (int)(s->frame_qscale + 0.5);
3468         
3469     if (s->out_format == FMT_MJPEG) {
3470         /* for mjpeg, we do include qscale in the matrix */
3471         s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3472         for(i=1;i<64;i++){
3473             int j= s->dsp.idct_permutation[i];
3474
3475             s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3476         }
3477         convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
3478                        s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3479     }
3480     
3481     //FIXME var duplication
3482     s->current_picture.key_frame= s->pict_type == I_TYPE;
3483     s->current_picture.pict_type= s->pict_type;
3484
3485     if(s->current_picture.key_frame)
3486         s->picture_in_gop_number=0;
3487
3488     s->last_bits= get_bit_count(&s->pb);
3489     switch(s->out_format) {
3490     case FMT_MJPEG:
3491         mjpeg_picture_header(s);
3492         break;
3493 #ifdef CONFIG_RISKY
3494     case FMT_H263:
3495         if (s->codec_id == CODEC_ID_WMV2) 
3496             ff_wmv2_encode_picture_header(s, picture_number);
3497         else if (s->h263_msmpeg4) 
3498             msmpeg4_encode_picture_header(s, picture_number);
3499         else if (s->h263_pred)
3500             mpeg4_encode_picture_header(s, picture_number);
3501         else if (s->h263_rv10) 
3502             rv10_encode_picture_header(s, picture_number);
3503         else if (s->codec_id == CODEC_ID_FLV1)
3504             ff_flv_encode_picture_header(s, picture_number);
3505         else
3506             h263_encode_picture_header(s, picture_number);
3507         break;
3508 #endif
3509     case FMT_MPEG1:
3510         mpeg1_encode_picture_header(s, picture_number);
3511         break;
3512     case FMT_H264:
3513         break;
3514     }
3515     bits= get_bit_count(&s->pb);
3516     s->header_bits= bits - s->last_bits;
3517     s->last_bits= bits;
3518     s->mv_bits=0;
3519     s->misc_bits=0;
3520     s->i_tex_bits=0;
3521     s->p_tex_bits=0;
3522     s->i_count=0;
3523     s->f_count=0;
3524     s->b_count=0;
3525     s->skip_count=0;
3526
3527     for(i=0; i<3; i++){
3528         /* init last dc values */
3529         /* note: quant matrix value (8) is implied here */
3530         s->last_dc[i] = 128;
3531         
3532         s->current_picture_ptr->error[i] = 0;
3533     }
3534     s->mb_skip_run = 0;
3535     s->last_mv[0][0][0] = 0;
3536     s->last_mv[0][0][1] = 0;
3537     s->last_mv[1][0][0] = 0;
3538     s->last_mv[1][0][1] = 0;
3539      
3540     s->last_mv_dir = 0;
3541
3542 #ifdef CONFIG_RISKY
3543     switch(s->codec_id){
3544     case CODEC_ID_H263:
3545     case CODEC_ID_H263P:
3546     case CODEC_ID_FLV1:
3547         s->gob_index = ff_h263_get_gob_height(s);
3548         break;
3549     case CODEC_ID_MPEG4:
3550         if(s->partitioned_frame)
3551             ff_mpeg4_init_partitions(s);
3552         break;
3553     }
3554 #endif
3555
3556     s->resync_mb_x=0;
3557     s->resync_mb_y=0;
3558     s->first_slice_line = 1;
3559     s->ptr_lastgob = s->pb.buf;
3560     for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3561         s->mb_x=0;
3562         s->mb_y= mb_y;
3563
3564         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3565         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3566         ff_init_block_index(s);
3567         
3568         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3569             const int xy= mb_y*s->mb_stride + mb_x;
3570             int mb_type= s->mb_type[xy];
3571 //            int d;
3572             int dmin= INT_MAX;
3573
3574             s->mb_x = mb_x;
3575             ff_update_block_index(s);
3576
3577             /* write gob / video packet header  */
3578 #ifdef CONFIG_RISKY
3579             if(s->rtp_mode && mb_y + mb_x>0){
3580                 int current_packet_size, is_gob_start;
3581                 
3582                 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3583                 is_gob_start=0;
3584                 
3585                 if(s->codec_id==CODEC_ID_MPEG4){
3586                     if(current_packet_size >= s->rtp_payload_size){
3587
3588                         if(s->partitioned_frame){
3589                             ff_mpeg4_merge_partitions(s);
3590                             ff_mpeg4_init_partitions(s);
3591                         }
3592                         ff_mpeg4_encode_video_packet_header(s);
3593
3594                         if(s->flags&CODEC_FLAG_PASS1){
3595                             int bits= get_bit_count(&s->pb);
3596                             s->misc_bits+= bits - s->last_bits;
3597                             s->last_bits= bits;
3598                         }
3599                         ff_mpeg4_clean_buffers(s);
3600                         is_gob_start=1;
3601                     }
3602                 }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3603                     if(   current_packet_size >= s->rtp_payload_size 
3604                        && s->mb_skip_run==0){
3605                         ff_mpeg1_encode_slice_header(s);
3606                         ff_mpeg1_clean_buffers(s);
3607                         is_gob_start=1;
3608                     }
3609                 }else if(s->codec_id==CODEC_ID_MPEG2VIDEO){
3610                     if(   (   current_packet_size >= s->rtp_payload_size || mb_x==0)
3611                        && s->mb_skip_run==0){
3612                         ff_mpeg1_encode_slice_header(s);
3613                         ff_mpeg1_clean_buffers(s);
3614                         is_gob_start=1;
3615                     }
3616                 }else{
3617                     if(current_packet_size >= s->rtp_payload_size
3618                        && s->mb_x==0 && s->mb_y%s->gob_index==0){
3619                        
3620                         h263_encode_gob_header(s, mb_y);                       
3621                         is_gob_start=1;
3622                     }
3623                 }
3624
3625                 if(is_gob_start){
3626                     s->ptr_lastgob = pbBufPtr(&s->pb);
3627                     s->first_slice_line=1;
3628                     s->resync_mb_x=mb_x;
3629                     s->resync_mb_y=mb_y;
3630                 }
3631             }
3632 #endif
3633
3634             if(  (s->resync_mb_x   == s->mb_x)
3635                && s->resync_mb_y+1 == s->mb_y){
3636                 s->first_slice_line=0; 
3637             }
3638
3639             s->mb_skiped=0;
3640
3641             if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3642                 int next_block=0;
3643                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3644
3645                 copy_context_before_encode(&backup_s, s, -1);
3646                 backup_s.pb= s->pb;
3647                 best_s.data_partitioning= s->data_partitioning;
3648                 best_s.partitioned_frame= s->partitioned_frame;
3649                 if(s->data_partitioning){
3650                     backup_s.pb2= s->pb2;
3651                     backup_s.tex_pb= s->tex_pb;
3652                 }
3653
3654                 if(mb_type&MB_TYPE_INTER){
3655                     s->mv_dir = MV_DIR_FORWARD;
3656                     s->mv_type = MV_TYPE_16X16;
3657                     s->mb_intra= 0;
3658                     s->mv[0][0][0] = s->p_mv_table[xy][0];
3659                     s->mv[0][0][1] = s->p_mv_table[xy][1];
3660                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
3661                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3662                 }
3663                 if(mb_type&MB_TYPE_INTER4V){                 
3664                     s->mv_dir = MV_DIR_FORWARD;
3665                     s->mv_type = MV_TYPE_8X8;
3666                     s->mb_intra= 0;
3667                     for(i=0; i<4; i++){
3668                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3669                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3670                     }
3671                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
3672                                  &dmin, &next_block, 0, 0);
3673                 }
3674                 if(mb_type&MB_TYPE_FORWARD){
3675                     s->mv_dir = MV_DIR_FORWARD;
3676                     s->mv_type = MV_TYPE_16X16;
3677                     s->mb_intra= 0;
3678                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3679                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3680                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
3681                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3682                 }
3683                 if(mb_type&MB_TYPE_BACKWARD){
3684                     s->mv_dir = MV_DIR_BACKWARD;
3685                     s->mv_type = MV_TYPE_16X16;
3686                     s->mb_intra= 0;
3687                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3688                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3689                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
3690                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3691                 }
3692                 if(mb_type&MB_TYPE_BIDIR){
3693                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3694                     s->mv_type = MV_TYPE_16X16;
3695                     s->mb_intra= 0;
3696                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3697                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3698                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3699                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3700                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
3701                                  &dmin, &next_block, 0, 0);
3702                 }
3703                 if(mb_type&MB_TYPE_DIRECT){
3704                     int mx= s->b_direct_mv_table[xy][0];
3705                     int my= s->b_direct_mv_table[xy][1];
3706                     
3707                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3708                     s->mb_intra= 0;
3709 #ifdef CONFIG_RISKY
3710                     ff_mpeg4_set_direct_mv(s, mx, my);
3711 #endif
3712                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
3713                                  &dmin, &next_block, mx, my);
3714                 }
3715                 if(mb_type&MB_TYPE_INTRA){
3716                     s->mv_dir = 0;
3717                     s->mv_type = MV_TYPE_16X16;
3718                     s->mb_intra= 1;
3719                     s->mv[0][0][0] = 0;
3720                     s->mv[0][0][1] = 0;
3721                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
3722                                  &dmin, &next_block, 0, 0);
3723                     if(s->h263_pred || s->h263_aic){
3724                         if(best_s.mb_intra)
3725                             s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3726                         else
3727                             ff_clean_intra_table_entries(s); //old mode?
3728                     }
3729                 }
3730                 copy_context_after_encode(s, &best_s, -1);
3731                 
3732                 pb_bits_count= get_bit_count(&s->pb);
3733                 flush_put_bits(&s->pb);
3734                 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3735                 s->pb= backup_s.pb;
3736                 
3737                 if(s->data_partitioning){
3738                     pb2_bits_count= get_bit_count(&s->pb2);
3739                     flush_put_bits(&s->pb2);
3740                     ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3741                     s->pb2= backup_s.pb2;
3742                     
3743                     tex_pb_bits_count= get_bit_count(&s->tex_pb);
3744                     flush_put_bits(&s->tex_pb);
3745                     ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3746                     s->tex_pb= backup_s.tex_pb;
3747                 }
3748                 s->last_bits= get_bit_count(&s->pb);
3749                 
3750                 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3751                     ff_h263_update_motion_val(s);
3752         
3753                 if(next_block==0){
3754                     s->dsp.put_pixels_tab[0][0](s->dest[0], s->me.scratchpad     , s->linesize  ,16);
3755                     s->dsp.put_pixels_tab[1][0](s->dest[1], s->me.scratchpad + 16, s->uvlinesize, 8);
3756                     s->dsp.put_pixels_tab[1][0](s->dest[2], s->me.scratchpad + 24, s->uvlinesize, 8);
3757                 }
3758
3759                 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3760                     MPV_decode_mb(s, s->block);
3761             } else {
3762                 int motion_x, motion_y;
3763                 int intra_score;
3764                 int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3765                 
3766               if(s->avctx->mb_decision==FF_MB_DECISION_SIMPLE && s->pict_type==P_TYPE){ //FIXME check if the mess is usefull at all
3767                 /* get luma score */
3768                 if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3769                     intra_score= (s->current_picture.mb_var[mb_x + mb_y*s->mb_stride]<<8) - 500; //FIXME dont scale it down so we dont have to fix it
3770                 }else{
3771                     uint8_t *dest_y;
3772
3773                     int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3774                     mean*= 0x01010101;
3775                     
3776                     dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3777                 
3778                     for(i=0; i<16; i++){
3779                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3780                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3781                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3782                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3783                     }
3784
3785                     s->mb_intra=1;
3786                     intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3787                                         
3788 /*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8, 
3789                         s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3790                         s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3791                 }
3792                 
3793                 /* get chroma score */
3794                 if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3795                     int i;
3796                     
3797                     s->mb_intra=1;
3798                     for(i=1; i<3; i++){
3799                         uint8_t *dest_c;
3800                         int mean;
3801                         
3802                         if(s->out_format == FMT_H263){
3803                             mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3804                         }else{
3805                             mean= (s->last_dc[i] + 4)>>3;
3806                         }
3807                         dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3808                         
3809                         mean*= 0x01010101;
3810                         for(i=0; i<8; i++){
3811                             *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3812                             *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3813                         }
3814                         
3815                         intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3816                     }                
3817                 }
3818
3819                 /* bias */
3820                 switch(s->avctx->mb_cmp&0xFF){
3821                 default:
3822                 case FF_CMP_SAD:
3823                     intra_score+= 32*s->qscale;
3824                     break;
3825                 case FF_CMP_SSE:
3826                     intra_score+= 24*s->qscale*s->qscale;
3827                     break;
3828                 case FF_CMP_SATD:
3829                     intra_score+= 96*s->qscale;
3830                     break;
3831                 case FF_CMP_DCT:
3832                     intra_score+= 48*s->qscale;
3833                     break;
3834                 case FF_CMP_BIT:
3835                     intra_score+= 16;
3836                     break;
3837                 case FF_CMP_PSNR:
3838                 case FF_CMP_RD:
3839                     intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3840                     break;
3841                 }
3842
3843                 if(intra_score < inter_score)
3844                     mb_type= MB_TYPE_INTRA;
3845               }  
3846                 
3847                 s->mv_type=MV_TYPE_16X16;
3848                 // only one MB-Type possible
3849                 
3850                 switch(mb_type){
3851                 case MB_TYPE_INTRA:
3852                     s->mv_dir = 0;
3853                     s->mb_intra= 1;
3854                     motion_x= s->mv[0][0][0] = 0;
3855                     motion_y= s->mv[0][0][1] = 0;
3856                     break;
3857                 case MB_TYPE_INTER:
3858                     s->mv_dir = MV_DIR_FORWARD;
3859                     s->mb_intra= 0;
3860                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3861                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3862                     break;
3863                 case MB_TYPE_INTER4V:
3864                     s->mv_dir = MV_DIR_FORWARD;
3865                     s->mv_type = MV_TYPE_8X8;
3866                     s->mb_intra= 0;
3867                     for(i=0; i<4; i++){
3868                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3869                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3870                     }
3871                     motion_x= motion_y= 0;
3872                     break;
3873                 case MB_TYPE_DIRECT:
3874                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3875                     s->mb_intra= 0;
3876                     motion_x=s->b_direct_mv_table[xy][0];
3877                     motion_y=s->b_direct_mv_table[xy][1];
3878 #ifdef CONFIG_RISKY
3879                     ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3880 #endif
3881                     break;
3882                 case MB_TYPE_BIDIR:
3883                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3884                     s->mb_intra= 0;
3885                     motion_x=0;
3886                     motion_y=0;
3887                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3888                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3889                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3890                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3891                     break;
3892                 case MB_TYPE_BACKWARD:
3893                     s->mv_dir = MV_DIR_BACKWARD;
3894                     s->mb_intra= 0;
3895                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3896                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3897                     break;
3898                 case MB_TYPE_FORWARD:
3899                     s->mv_dir = MV_DIR_FORWARD;
3900                     s->mb_intra= 0;
3901                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3902                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3903 //                    printf(" %d %d ", motion_x, motion_y);
3904                     break;
3905                 default:
3906                     motion_x=motion_y=0; //gcc warning fix
3907                     printf("illegal MB type\n");
3908                 }
3909
3910                 encode_mb(s, motion_x, motion_y);
3911
3912                 // RAL: Update last macrobloc type
3913                 s->last_mv_dir = s->mv_dir;
3914             
3915                 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3916                     ff_h263_update_motion_val(s);
3917
3918                 MPV_decode_mb(s, s->block);
3919             }
3920
3921             /* clean the MV table in IPS frames for direct mode in B frames */
3922             if(s->mb_intra /* && I,P,S_TYPE */){
3923                 s->p_mv_table[xy][0]=0;
3924                 s->p_mv_table[xy][1]=0;
3925             }
3926             
3927             if(s->flags&CODEC_FLAG_PSNR){
3928                 int w= 16;
3929                 int h= 16;
3930
3931                 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3932                 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3933
3934                 s->current_picture_ptr->error[0] += sse(
3935                     s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3936                     s->dest[0], w, h, s->linesize);
3937                 s->current_picture_ptr->error[1] += sse(
3938                     s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3939                     s->dest[1], w>>1, h>>1, s->uvlinesize);
3940                 s->current_picture_ptr->error[2] += sse(
3941                     s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3942                     s->dest[2], w>>1, h>>1, s->uvlinesize);
3943             }
3944 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3945         }
3946     }
3947     emms_c();
3948
3949 #ifdef CONFIG_RISKY
3950     if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3951         ff_mpeg4_merge_partitions(s);
3952
3953     if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3954         msmpeg4_encode_ext_header(s);
3955
3956     if(s->codec_id==CODEC_ID_MPEG4) 
3957         ff_mpeg4_stuffing(&s->pb);
3958 #endif
3959
3960     //if (s->gob_number)
3961     //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3962     
3963     /* Send the last GOB if RTP */    
3964     if (s->rtp_mode) {
3965         flush_put_bits(&s->pb);
3966         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3967         /* Call the RTP callback to send the last GOB */
3968         if (s->rtp_callback)
3969             s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3970         s->ptr_lastgob = pbBufPtr(&s->pb);
3971         //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3972     }
3973 }
3974
3975 static int dct_quantize_trellis_c(MpegEncContext *s, 
3976                         DCTELEM *block, int n,
3977                         int qscale, int *overflow){
3978     const int *qmat;
3979     const uint8_t *scantable= s->intra_scantable.scantable;
3980     int max=0;
3981     unsigned int threshold1, threshold2;
3982     int bias=0;
3983     int run_tab[65];
3984     int level_tab[65];
3985     int score_tab[65];
3986     int last_run=0;
3987     int last_level=0;
3988     int last_score= 0;
3989     int last_i= 0;
3990     int coeff[3][64];
3991     int coeff_count[64];
3992     int lambda, qmul, qadd, start_i, last_non_zero, i;
3993     const int esc_length= s->ac_esc_length;
3994     uint8_t * length;
3995     uint8_t * last_length;
3996     int score_limit=0;
3997     int left_limit= 0;
3998         
3999     s->dsp.fdct (block);
4000
4001     qmul= qscale*16;
4002     qadd= ((qscale-1)|1)*8;
4003
4004     if (s->mb_intra) {
4005         int q;
4006         if (!s->h263_aic) {
4007             if (n < 4)
4008                 q = s->y_dc_scale;
4009             else
4010                 q = s->c_dc_scale;
4011             q = q << 3;
4012         } else{
4013             /* For AIC we skip quant/dequant of INTRADC */
4014             q = 1 << 3;
4015             qadd=0;
4016         }
4017             
4018         /* note: block[0] is assumed to be positive */
4019         block[0] = (block[0] + (q >> 1)) / q;
4020         start_i = 1;
4021         last_non_zero = 0;
4022         qmat = s->q_intra_matrix[qscale];
4023         if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4024             bias= 1<<(QMAT_SHIFT-1);
4025         length     = s->intra_ac_vlc_length;
4026         last_length= s->intra_ac_vlc_last_length;
4027     } else {
4028         start_i = 0;
4029         last_non_zero = -1;
4030         qmat = s->q_inter_matrix[qscale];
4031         length     = s->inter_ac_vlc_length;
4032         last_length= s->inter_ac_vlc_last_length;
4033     }
4034
4035     threshold1= (1<<QMAT_SHIFT) - bias - 1;
4036     threshold2= (threshold1<<1);
4037
4038     for(i=start_i; i<64; i++) {
4039         const int j = scantable[i];
4040         const int k= i-start_i;
4041         int level = block[j];
4042         level = level * qmat[j];
4043
4044 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
4045 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
4046         if(((unsigned)(level+threshold1))>threshold2){
4047             if(level>0){
4048                 level= (bias + level)>>QMAT_SHIFT;
4049                 coeff[0][k]= level;
4050                 coeff[1][k]= level-1;
4051 //                coeff[2][k]= level-2;
4052             }else{
4053                 level= (bias - level)>>QMAT_SHIFT;
4054                 coeff[0][k]= -level;
4055                 coeff[1][k]= -level+1;
4056 //                coeff[2][k]= -level+2;
4057             }
4058             coeff_count[k]= FFMIN(level, 2);
4059             max |=level;
4060             last_non_zero = i;
4061         }else{
4062             coeff[0][k]= (level>>31)|1;
4063             coeff_count[k]= 1;
4064         }
4065     }
4066     
4067     *overflow= s->max_qcoeff < max; //overflow might have happend
4068     
4069     if(last_non_zero < start_i){
4070         memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4071         return last_non_zero;
4072     }
4073
4074     lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
4075         
4076  &nb