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