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