adaptive quantization for h263
[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 #include "avcodec.h"
22 #include "dsputil.h"
23 #include "mpegvideo.h"
24
25 #ifdef USE_FASTMEMCPY
26 #include "fastmemcpy.h"
27 #endif
28
29 static void encode_picture(MpegEncContext *s, int picture_number);
30 static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
31                                    DCTELEM *block, int n, int qscale);
32 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
33                                    DCTELEM *block, int n, int qscale);
34 static void dct_unquantize_h263_c(MpegEncContext *s, 
35                                   DCTELEM *block, int n, int qscale);
36 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);
37 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
38
39 void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
40 static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
41                                     int src_x, int src_y, int w, int h);
42
43 #define EDGE_WIDTH 16
44
45 /* enable all paranoid tests for rounding, overflows, etc... */
46 //#define PARANOID
47
48 //#define DEBUG
49
50
51 /* for jpeg fast DCT */
52 #define CONST_BITS 14
53
54 static const unsigned short aanscales[64] = {
55     /* precomputed values scaled up by 14 bits */
56     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
57     22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
58     21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
59     19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
60     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
61     12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
62     8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
63     4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
64 };
65
66 static UINT8 h263_chroma_roundtab[16] = {
67     0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
68 };
69
70 static UINT16 default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
71 static UINT8 default_fcode_tab[MAX_MV*2+1];
72
73 extern UINT8 zigzag_end[64];
74
75 /* default motion estimation */
76 int motion_estimation_method = ME_EPZS;
77
78 static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
79                            const UINT16 *quant_matrix, int bias)
80 {
81     int qscale;
82
83     for(qscale=1; qscale<32; qscale++){
84         int i;
85         if (s->fdct == ff_jpeg_fdct_islow) {
86             for(i=0;i<64;i++) {
87                 const int j= block_permute_op(i);
88                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
89                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
90                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
91                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
92                 
93                 qmat[qscale][j] = (int)((UINT64_C(1) << QMAT_SHIFT) / 
94                                 (qscale * quant_matrix[j]));
95             }
96         } else if (s->fdct == fdct_ifast) {
97             for(i=0;i<64;i++) {
98                 const int j= block_permute_op(i);
99                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
100                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
101                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
102                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
103                 
104                 qmat[qscale][j] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / 
105                                 (aanscales[i] * qscale * quant_matrix[j]));
106             }
107         } else {
108             for(i=0;i<64;i++) {
109                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
110                    So 16           <= qscale * quant_matrix[i]             <= 7905
111                    so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
112                    so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
113                 */
114                 qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
115                 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[block_permute_op(i)]);
116
117                 if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
118                 qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
119             }
120         }
121     }
122 }
123 // move into common.c perhaps 
124 #define CHECKED_ALLOCZ(p, size)\
125 {\
126     p= av_mallocz(size);\
127     if(p==NULL){\
128         perror("malloc");\
129         goto fail;\
130     }\
131 }
132
133 /* init common structure for both encoder and decoder */
134 int MPV_common_init(MpegEncContext *s)
135 {
136     int c_size, i;
137     UINT8 *pict;
138
139     s->dct_unquantize_h263 = dct_unquantize_h263_c;
140     s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
141     s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
142     s->dct_quantize= dct_quantize_c;
143
144     if(s->avctx->dct_algo==FF_DCT_FASTINT)
145         s->fdct = fdct_ifast;
146     else
147         s->fdct = ff_jpeg_fdct_islow;
148         
149 #ifdef HAVE_MMX
150     MPV_common_init_mmx(s);
151 #endif
152 #ifdef ARCH_ALPHA
153     MPV_common_init_axp(s);
154 #endif
155 #ifdef HAVE_MLIB
156     MPV_common_init_mlib(s);
157 #endif
158
159     s->mb_width = (s->width + 15) / 16;
160     s->mb_height = (s->height + 15) / 16;
161     
162     /* set default edge pos, will be overriden in decode_header if needed */
163     s->h_edge_pos= s->mb_width*16;
164     s->v_edge_pos= s->mb_height*16;
165
166     s->mb_num = s->mb_width * s->mb_height;
167     if(!(s->flags&CODEC_FLAG_DR1)){
168       s->linesize   = s->mb_width * 16 + 2 * EDGE_WIDTH;
169       s->uvlinesize = s->mb_width * 8  +     EDGE_WIDTH;
170
171       for(i=0;i<3;i++) {
172         int w, h, shift, pict_start;
173
174         w = s->linesize;
175         h = s->mb_height * 16 + 2 * EDGE_WIDTH;
176         shift = (i == 0) ? 0 : 1;
177         c_size = (s->linesize>>shift) * (h >> shift);
178         pict_start = (s->linesize>>shift) * (EDGE_WIDTH >> shift) + (EDGE_WIDTH >> shift);
179
180         CHECKED_ALLOCZ(pict, c_size)
181         s->last_picture_base[i] = pict;
182         s->last_picture[i] = pict + pict_start;
183         if(i>0) memset(s->last_picture_base[i], 128, c_size);
184     
185         CHECKED_ALLOCZ(pict, c_size)
186         s->next_picture_base[i] = pict;
187         s->next_picture[i] = pict + pict_start;
188         if(i>0) memset(s->next_picture_base[i], 128, c_size);
189         
190         if (s->has_b_frames || s->codec_id==CODEC_ID_MPEG4) {
191         /* Note the MPEG4 stuff is here cuz of buggy encoders which dont set the low_delay flag but 
192            do low-delay encoding, so we cant allways distinguish b-frame containing streams from low_delay streams */
193             CHECKED_ALLOCZ(pict, c_size)
194             s->aux_picture_base[i] = pict;
195             s->aux_picture[i] = pict + pict_start;
196             if(i>0) memset(s->aux_picture_base[i], 128, c_size);
197         }
198       }
199       s->ip_buffer_count= 2;
200     }
201     
202     CHECKED_ALLOCZ(s->edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
203     
204     if (s->encoding) {
205         int j;
206         int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
207         
208         CHECKED_ALLOCZ(s->mb_var   , s->mb_num * sizeof(INT16))
209         CHECKED_ALLOCZ(s->mc_mb_var, s->mb_num * sizeof(INT16))
210         CHECKED_ALLOCZ(s->mb_mean  , s->mb_num * sizeof(INT8))
211
212         /* Allocate MV tables */
213         CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(INT16))
214         CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(INT16))
215         CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(INT16))
216         CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
217         CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
218         CHECKED_ALLOCZ(s->b_direct_forw_mv_table, mv_table_size * 2 * sizeof(INT16))
219         CHECKED_ALLOCZ(s->b_direct_back_mv_table, mv_table_size * 2 * sizeof(INT16))
220         CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(INT16))
221
222         CHECKED_ALLOCZ(s->me_scratchpad,  s->linesize*16*3*sizeof(uint8_t))
223         
224         CHECKED_ALLOCZ(s->me_map      , ME_MAP_SIZE*sizeof(uint32_t))
225         CHECKED_ALLOCZ(s->me_score_map, ME_MAP_SIZE*sizeof(uint16_t))
226
227         if(s->max_b_frames){
228             for(j=0; j<REORDER_BUFFER_SIZE; j++){
229                 int i;
230                 for(i=0;i<3;i++) {
231                     int w, h, shift;
232
233                     w = s->linesize;
234                     h = s->mb_height * 16;
235                     shift = (i == 0) ? 0 : 1;
236                     c_size = (w >> shift) * (h >> shift);
237
238                     CHECKED_ALLOCZ(pict, c_size);
239                     s->picture_buffer[j][i] = pict;
240                 }
241             }
242         }
243
244         if(s->codec_id==CODEC_ID_MPEG4){
245             CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
246             CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
247         }
248         
249         if(s->msmpeg4_version){
250             CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
251         }
252         CHECKED_ALLOCZ(s->avctx->stats_out, 256);
253     }
254     
255     if (s->out_format == FMT_H263 || s->encoding) {
256         int size;
257         /* Allocate MB type table */
258         CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(UINT8))
259
260         /* MV prediction */
261         size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
262         CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
263     }
264
265     if(s->codec_id==CODEC_ID_MPEG4){
266         /* 4mv and interlaced direct mode decoding tables */
267         CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
268         CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
269         CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
270     }
271
272     if (s->h263_pred || s->h263_plus) {
273         int y_size, c_size, i, size;
274         
275         /* dc values */
276
277         y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
278         c_size = (s->mb_width + 2) * (s->mb_height + 2);
279         size = y_size + 2 * c_size;
280         CHECKED_ALLOCZ(s->dc_val[0], size * sizeof(INT16));
281         s->dc_val[1] = s->dc_val[0] + y_size;
282         s->dc_val[2] = s->dc_val[1] + c_size;
283         for(i=0;i<size;i++)
284             s->dc_val[0][i] = 1024;
285
286         /* ac values */
287         CHECKED_ALLOCZ(s->ac_val[0], size * sizeof(INT16) * 16);
288         s->ac_val[1] = s->ac_val[0] + y_size;
289         s->ac_val[2] = s->ac_val[1] + c_size;
290         
291         /* cbp values */
292         CHECKED_ALLOCZ(s->coded_block, y_size);
293         
294         /* divx501 bitstream reorder buffer */
295         CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
296         
297         /* cbp, ac_pred, pred_dir */
298         CHECKED_ALLOCZ(s->cbp_table  , s->mb_num * sizeof(UINT8))
299         CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
300     }
301     CHECKED_ALLOCZ(s->qscale_table  , s->mb_num * sizeof(UINT8))
302     
303     /* which mb is a intra block */
304     CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
305     memset(s->mbintra_table, 1, s->mb_num);
306     
307     /* default structure is frame */
308     s->picture_structure = PICT_FRAME;
309     
310     /* init macroblock skip table */
311     CHECKED_ALLOCZ(s->mbskip_table, s->mb_num);
312     
313     s->block= s->blocks[0];
314
315     s->context_initialized = 1;
316     return 0;
317  fail:
318     MPV_common_end(s);
319     return -1;
320 }
321
322
323 //extern int sads;
324
325 /* init common structure for both encoder and decoder */
326 void MPV_common_end(MpegEncContext *s)
327 {
328     int i;
329
330     av_freep(&s->mb_type);
331     av_freep(&s->mb_var);
332     av_freep(&s->mc_mb_var);
333     av_freep(&s->mb_mean);
334     av_freep(&s->p_mv_table);
335     av_freep(&s->b_forw_mv_table);
336     av_freep(&s->b_back_mv_table);
337     av_freep(&s->b_bidir_forw_mv_table);
338     av_freep(&s->b_bidir_back_mv_table);
339     av_freep(&s->b_direct_forw_mv_table);
340     av_freep(&s->b_direct_back_mv_table);
341     av_freep(&s->b_direct_mv_table);
342     av_freep(&s->motion_val);
343     av_freep(&s->dc_val[0]);
344     av_freep(&s->ac_val[0]);
345     av_freep(&s->coded_block);
346     av_freep(&s->mbintra_table);
347     av_freep(&s->cbp_table);
348     av_freep(&s->pred_dir_table);
349     av_freep(&s->qscale_table);
350     av_freep(&s->me_scratchpad);
351     av_freep(&s->me_map);
352     av_freep(&s->me_score_map);
353     
354     av_freep(&s->mbskip_table);
355     av_freep(&s->bitstream_buffer);
356     av_freep(&s->tex_pb_buffer);
357     av_freep(&s->pb2_buffer);
358     av_freep(&s->edge_emu_buffer);
359     av_freep(&s->co_located_type_table);
360     av_freep(&s->field_mv_table);
361     av_freep(&s->field_select_table);
362     av_freep(&s->avctx->stats_out);
363     av_freep(&s->ac_stats);
364     
365     for(i=0;i<3;i++) {
366         int j;
367         if(!(s->flags&CODEC_FLAG_DR1)){
368             av_freep(&s->last_picture_base[i]);
369             av_freep(&s->next_picture_base[i]);
370             av_freep(&s->aux_picture_base[i]);
371         }
372         s->last_picture_base[i]=
373         s->next_picture_base[i]=
374         s->aux_picture_base [i] = NULL;
375         s->last_picture[i]=
376         s->next_picture[i]=
377         s->aux_picture [i] = NULL;
378
379         for(j=0; j<REORDER_BUFFER_SIZE; j++){
380             av_freep(&s->picture_buffer[j][i]);
381         }
382     }
383     s->context_initialized = 0;
384 }
385
386 /* init video encoder */
387 int MPV_encode_init(AVCodecContext *avctx)
388 {
389     MpegEncContext *s = avctx->priv_data;
390     int i;
391
392     avctx->pix_fmt = PIX_FMT_YUV420P;
393
394     s->bit_rate = avctx->bit_rate;
395     s->bit_rate_tolerance = avctx->bit_rate_tolerance;
396     s->frame_rate = avctx->frame_rate;
397     s->width = avctx->width;
398     s->height = avctx->height;
399     if(avctx->gop_size > 600){
400         fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
401         avctx->gop_size=600;
402     }
403     s->gop_size = avctx->gop_size;
404     s->rtp_mode = avctx->rtp_mode;
405     s->rtp_payload_size = avctx->rtp_payload_size;
406     if (avctx->rtp_callback)
407         s->rtp_callback = avctx->rtp_callback;
408     s->qmin= avctx->qmin;
409     s->qmax= avctx->qmax;
410     s->max_qdiff= avctx->max_qdiff;
411     s->qcompress= avctx->qcompress;
412     s->qblur= avctx->qblur;
413     s->avctx = avctx;
414     s->aspect_ratio_info= avctx->aspect_ratio_info;
415     if (avctx->aspect_ratio_info == FF_ASPECT_EXTENDED)
416     {
417         s->aspected_width = avctx->aspected_width;
418         s->aspected_height = avctx->aspected_height;
419     }
420     s->flags= avctx->flags;
421     s->max_b_frames= avctx->max_b_frames;
422     s->b_frame_strategy= avctx->b_frame_strategy;
423     s->codec_id= avctx->codec->id;
424     s->luma_elim_threshold  = avctx->luma_elim_threshold;
425     s->chroma_elim_threshold= avctx->chroma_elim_threshold;
426     s->strict_std_compliance= avctx->strict_std_compliance;
427     s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
428     s->mpeg_quant= avctx->mpeg_quant;
429
430     if (s->gop_size <= 1) {
431         s->intra_only = 1;
432         s->gop_size = 12;
433     } else {
434         s->intra_only = 0;
435     }
436
437     /* ME algorithm */
438     if (avctx->me_method == 0)
439         /* For compatibility */
440         s->me_method = motion_estimation_method;
441     else
442         s->me_method = avctx->me_method;
443
444     /* Fixed QSCALE */
445     s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
446     
447     s->adaptive_quant= (   s->avctx->lumi_masking
448                         || s->avctx->dark_masking
449                         || s->avctx->temporal_cplx_masking 
450                         || s->avctx->spatial_cplx_masking
451                         || s->avctx->p_masking)
452                        && !s->fixed_qscale;
453
454     switch(avctx->codec->id) {
455     case CODEC_ID_MPEG1VIDEO:
456         s->out_format = FMT_MPEG1;
457         avctx->delay=0; //FIXME not sure, should check the spec
458         break;
459     case CODEC_ID_MJPEG:
460         s->out_format = FMT_MJPEG;
461         s->intra_only = 1; /* force intra only for jpeg */
462         s->mjpeg_write_tables = 1; /* write all tables */
463         s->mjpeg_data_only_frames = 0; /* write all the needed headers */
464         s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
465         s->mjpeg_vsample[1] = 1; /* the only currently supported values */
466         s->mjpeg_vsample[2] = 1; 
467         s->mjpeg_hsample[0] = 2;
468         s->mjpeg_hsample[1] = 1; 
469         s->mjpeg_hsample[2] = 1; 
470         if (mjpeg_init(s) < 0)
471             return -1;
472         avctx->delay=0;
473         break;
474     case CODEC_ID_H263:
475         if (h263_get_picture_format(s->width, s->height) == 7) {
476             printf("Input picture size isn't suitable for h263 codec! try h263+\n");
477             return -1;
478         }
479         s->out_format = FMT_H263;
480         avctx->delay=0;
481         break;
482     case CODEC_ID_H263P:
483         s->out_format = FMT_H263;
484         s->rtp_mode = 1;
485         s->rtp_payload_size = 1200; 
486         s->h263_plus = 1;
487         s->unrestricted_mv = 1;
488         s->h263_aic = 1;
489         
490         /* These are just to be sure */
491         s->umvplus = 0;
492         s->umvplus_dec = 0;
493         avctx->delay=0;
494         break;
495     case CODEC_ID_RV10:
496         s->out_format = FMT_H263;
497         s->h263_rv10 = 1;
498         avctx->delay=0;
499         break;
500     case CODEC_ID_MPEG4:
501         s->out_format = FMT_H263;
502         s->h263_pred = 1;
503         s->unrestricted_mv = 1;
504         s->has_b_frames= s->max_b_frames ? 1 : 0;
505         s->low_delay=0;
506         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); 
507         break;
508     case CODEC_ID_MSMPEG4V1:
509         s->out_format = FMT_H263;
510         s->h263_msmpeg4 = 1;
511         s->h263_pred = 1;
512         s->unrestricted_mv = 1;
513         s->msmpeg4_version= 1;
514         avctx->delay=0;
515         break;
516     case CODEC_ID_MSMPEG4V2:
517         s->out_format = FMT_H263;
518         s->h263_msmpeg4 = 1;
519         s->h263_pred = 1;
520         s->unrestricted_mv = 1;
521         s->msmpeg4_version= 2;
522         avctx->delay=0;
523         break;
524     case CODEC_ID_MSMPEG4V3:
525         s->out_format = FMT_H263;
526         s->h263_msmpeg4 = 1;
527         s->h263_pred = 1;
528         s->unrestricted_mv = 1;
529         s->msmpeg4_version= 3;
530         avctx->delay=0;
531         break;
532     case CODEC_ID_WMV1:
533         s->out_format = FMT_H263;
534         s->h263_msmpeg4 = 1;
535         s->h263_pred = 1;
536         s->unrestricted_mv = 1;
537         s->msmpeg4_version= 4;
538         avctx->delay=0;
539         break;
540     case CODEC_ID_WMV2:
541         s->out_format = FMT_H263;
542         s->h263_msmpeg4 = 1;
543         s->h263_pred = 1;
544         s->unrestricted_mv = 1;
545         s->msmpeg4_version= 5;
546         avctx->delay=0;
547         break;
548     default:
549         return -1;
550     }
551     
552     { /* set up some save defaults, some codecs might override them later */
553         static int done=0;
554         if(!done){
555             int i;
556             done=1;
557             memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
558             memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
559
560             for(i=-16; i<16; i++){
561                 default_fcode_tab[i + MAX_MV]= 1;
562             }
563         }
564     }
565     s->mv_penalty= default_mv_penalty;
566     s->fcode_tab= default_fcode_tab;
567     s->y_dc_scale_table=
568     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
569  
570     if (s->out_format == FMT_H263)
571         h263_encode_init(s);
572     else if (s->out_format == FMT_MPEG1)
573         ff_mpeg1_encode_init(s);
574     if(s->msmpeg4_version)
575         ff_msmpeg4_encode_init(s);
576
577     /* dont use mv_penalty table for crap MV as it would be confused */
578     if (s->me_method < ME_EPZS) s->mv_penalty = default_mv_penalty;
579
580     s->encoding = 1;
581
582     /* init */
583     if (MPV_common_init(s) < 0)
584         return -1;
585     
586     /* init default q matrix */
587     for(i=0;i<64;i++) {
588         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
589             s->intra_matrix[i] = ff_mpeg4_default_intra_matrix[i];
590             s->inter_matrix[i] = ff_mpeg4_default_non_intra_matrix[i];
591         }else if(s->out_format == FMT_H263){
592             s->intra_matrix[i] =
593             s->inter_matrix[i] = ff_mpeg1_default_non_intra_matrix[i];
594         }else{ /* mpeg1 */
595             s->intra_matrix[i] = ff_mpeg1_default_intra_matrix[i];
596             s->inter_matrix[i] = ff_mpeg1_default_non_intra_matrix[i];
597         }
598     }
599
600     /* precompute matrix */
601     /* for mjpeg, we do include qscale in the matrix */
602     if (s->out_format != FMT_MJPEG) {
603         convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias, 
604                        s->intra_matrix, s->intra_quant_bias);
605         convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias, 
606                        s->inter_matrix, s->inter_quant_bias);
607     }
608
609     if(ff_rate_control_init(s) < 0)
610         return -1;
611
612     s->picture_number = 0;
613     s->picture_in_gop_number = 0;
614     s->fake_picture_number = 0;
615     /* motion detector init */
616     s->f_code = 1;
617     s->b_code = 1;
618
619     return 0;
620 }
621
622 int MPV_encode_end(AVCodecContext *avctx)
623 {
624     MpegEncContext *s = avctx->priv_data;
625
626 #ifdef STATS
627     print_stats();
628 #endif
629
630     ff_rate_control_uninit(s);
631
632     MPV_common_end(s);
633     if (s->out_format == FMT_MJPEG)
634         mjpeg_close(s);
635       
636     return 0;
637 }
638
639 /* draw the edges of width 'w' of an image of size width, height */
640 //FIXME check that this is ok for mpeg4 interlaced
641 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
642 {
643     UINT8 *ptr, *last_line;
644     int i;
645
646     last_line = buf + (height - 1) * wrap;
647     for(i=0;i<w;i++) {
648         /* top and bottom */
649         memcpy(buf - (i + 1) * wrap, buf, width);
650         memcpy(last_line + (i + 1) * wrap, last_line, width);
651     }
652     /* left and right */
653     ptr = buf;
654     for(i=0;i<height;i++) {
655         memset(ptr - w, ptr[0], w);
656         memset(ptr + width, ptr[width-1], w);
657         ptr += wrap;
658     }
659     /* corners */
660     for(i=0;i<w;i++) {
661         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
662         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
663         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
664         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
665     }
666 }
667
668 /* generic function for encode/decode called before a frame is coded/decoded */
669 void MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
670 {
671     int i;
672     UINT8 *tmp;
673
674     s->mb_skiped = 0;
675     s->decoding_error=0;
676     avctx->mbskip_table= s->mbskip_table;
677
678     if(avctx->flags&CODEC_FLAG_DR1){
679         avctx->get_buffer_callback(avctx, s->width, s->height, s->pict_type);
680
681         s->linesize  = avctx->dr_stride;
682         s->uvlinesize= avctx->dr_uvstride;
683         s->ip_buffer_count= avctx->dr_ip_buffer_count;
684     }
685     avctx->dr_ip_buffer_count= s->ip_buffer_count;
686     
687     if (s->pict_type == B_TYPE) {
688         for(i=0;i<3;i++) {
689             if(avctx->flags&CODEC_FLAG_DR1)
690                 s->aux_picture[i]= avctx->dr_buffer[i];
691             
692             //FIXME the following should never be needed, the decoder should drop b frames if no reference is available
693             if(s->next_picture[i]==NULL)
694                 s->next_picture[i]= s->aux_picture[i];
695             if(s->last_picture[i]==NULL)
696                 s->last_picture[i]= s->next_picture[i];
697
698             s->current_picture[i] = s->aux_picture[i];
699         }
700     } else {
701         for(i=0;i<3;i++) {
702             /* swap next and last */
703             if(avctx->flags&CODEC_FLAG_DR1)
704                 tmp= avctx->dr_buffer[i];
705             else
706                 tmp = s->last_picture[i];
707
708             s->last_picture[i] = s->next_picture[i];
709             s->next_picture[i] = tmp;
710             s->current_picture[i] = tmp;
711
712             if(s->last_picture[i]==NULL)
713                 s->last_picture[i]= s->next_picture[i];
714
715             s->last_dr_opaque= s->next_dr_opaque;
716             s->next_dr_opaque= avctx->dr_opaque_frame;
717
718             if(s->has_b_frames && s->last_dr_opaque && s->codec_id!=CODEC_ID_SVQ1)
719                 avctx->dr_opaque_frame= s->last_dr_opaque;
720             else
721                 avctx->dr_opaque_frame= s->next_dr_opaque;
722         }
723     }
724     /* set dequantizer, we cant do it during init as it might change for mpeg4
725        and we cant do it in the header decode as init isnt called for mpeg4 there yet */
726     if(s->out_format == FMT_H263){
727         if(s->mpeg_quant)
728             s->dct_unquantize = s->dct_unquantize_mpeg2;
729         else
730             s->dct_unquantize = s->dct_unquantize_h263;
731     }else 
732         s->dct_unquantize = s->dct_unquantize_mpeg1;
733 }
734
735 /* generic function for encode/decode called after a frame has been coded/decoded */
736 void MPV_frame_end(MpegEncContext *s)
737 {
738     s->avctx->key_frame   = (s->pict_type == I_TYPE);
739     s->avctx->pict_type   = s->pict_type;
740
741     /* draw edge for correct motion prediction if outside */
742     if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
743         draw_edges(s->current_picture[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
744         draw_edges(s->current_picture[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
745         draw_edges(s->current_picture[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
746     }
747     emms_c();
748     
749     s->last_pict_type    = s->pict_type;
750     if(s->pict_type!=B_TYPE){
751         s->last_non_b_pict_type= s->pict_type;
752         s->num_available_buffers++;
753         if(s->num_available_buffers>2) s->num_available_buffers= 2;
754     }
755 }
756
757 /* reorder input for encoding */
758 void reorder_input(MpegEncContext *s, AVPicture *pict)
759 {
760     int i, j, index;
761             
762     if(s->max_b_frames > FF_MAX_B_FRAMES) s->max_b_frames= FF_MAX_B_FRAMES;
763
764 //        delay= s->max_b_frames+1; (or 0 if no b frames cuz decoder diff)
765
766     for(j=0; j<REORDER_BUFFER_SIZE-1; j++){
767         s->coded_order[j]= s->coded_order[j+1];
768     }
769     s->coded_order[j].picture[0]= s->coded_order[j].picture[1]= s->coded_order[j].picture[2]= NULL; //catch uninitalized buffers
770     s->coded_order[j].pict_type=0;
771
772     switch(s->input_pict_type){
773     default: 
774     case I_TYPE:
775     case S_TYPE:
776     case P_TYPE:
777         index= s->max_b_frames - s->b_frames_since_non_b;
778         s->b_frames_since_non_b=0;
779         break;            
780     case B_TYPE:
781         index= s->max_b_frames + 1;
782         s->b_frames_since_non_b++;
783         break;          
784     }
785 //printf("index:%d type:%d strides: %d %d\n", index, s->input_pict_type, pict->linesize[0], s->linesize);
786     if(   (index==0 || (s->flags&CODEC_FLAG_INPUT_PRESERVED))
787        && pict->linesize[0] == s->linesize
788        && pict->linesize[1] == s->uvlinesize
789        && pict->linesize[2] == s->uvlinesize){
790 //printf("ptr\n");
791         for(i=0; i<3; i++){
792             s->coded_order[index].picture[i]= pict->data[i];
793         }
794     }else{
795 //printf("copy\n");
796         for(i=0; i<3; i++){
797             uint8_t *src = pict->data[i];
798             uint8_t *dest;
799             int src_wrap = pict->linesize[i];
800             int dest_wrap = s->linesize;
801             int w = s->width;
802             int h = s->height;
803
804             if(index==0) dest= s->last_picture[i]+16; //is current_picture indeed but the switch hapens after reordering
805             else         dest= s->picture_buffer[s->picture_buffer_index][i];
806
807             if (i >= 1) {
808                 dest_wrap >>= 1;
809                 w >>= 1;
810                 h >>= 1;
811             }
812
813             s->coded_order[index].picture[i]= dest;
814             for(j=0;j<h;j++) {
815                 memcpy(dest, src, w);
816                 dest += dest_wrap;
817                 src += src_wrap;
818             }
819         }
820         if(index!=0){
821             s->picture_buffer_index++;
822             if(s->picture_buffer_index >= REORDER_BUFFER_SIZE) s->picture_buffer_index=0;
823         }
824     }
825     s->coded_order[index].pict_type = s->input_pict_type;
826     s->coded_order[index].qscale    = s->input_qscale;
827     s->coded_order[index].force_type= s->force_input_type;
828     s->coded_order[index].picture_in_gop_number= s->input_picture_in_gop_number;
829     s->coded_order[index].picture_number= s->input_picture_number;
830
831     for(i=0; i<3; i++){
832         s->new_picture[i]= s->coded_order[0].picture[i];
833     }
834 }
835
836 int MPV_encode_picture(AVCodecContext *avctx,
837                        unsigned char *buf, int buf_size, void *data)
838 {
839     MpegEncContext *s = avctx->priv_data;
840     AVPicture *pict = data;
841
842     s->input_qscale = avctx->quality;
843
844     init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
845
846     if(avctx->flags&CODEC_FLAG_TYPE){
847         s->input_pict_type=
848         s->force_input_type= avctx->key_frame ? I_TYPE : P_TYPE;
849     }else if(s->flags&CODEC_FLAG_PASS2){
850         s->input_pict_type=
851         s->force_input_type= s->rc_context.entry[s->input_picture_number].new_pict_type;
852     }else{
853         s->force_input_type=0;
854         if (!s->intra_only) {
855             /* first picture of GOP is intra */
856             if (s->input_picture_in_gop_number % s->gop_size==0){
857                 s->input_pict_type = I_TYPE;
858             }else if(s->max_b_frames==0){
859                 s->input_pict_type = P_TYPE;
860             }else{
861                 if(s->b_frames_since_non_b < s->max_b_frames) //FIXME more IQ
862                     s->input_pict_type = B_TYPE;
863                 else
864                     s->input_pict_type = P_TYPE;
865             }
866         } else {
867             s->input_pict_type = I_TYPE;
868         }
869     }
870
871     if(s->input_pict_type==I_TYPE)
872         s->input_picture_in_gop_number=0;
873     
874     reorder_input(s, pict);
875     
876     /* output? */
877     if(s->coded_order[0].picture[0]){
878
879         s->pict_type= s->coded_order[0].pict_type;
880         if (s->fixed_qscale) /* the ratecontrol needs the last qscale so we dont touch it for CBR */
881             s->qscale= s->coded_order[0].qscale;
882         s->force_type= s->coded_order[0].force_type;
883         s->picture_in_gop_number= s->coded_order[0].picture_in_gop_number;
884         s->picture_number= s->coded_order[0].picture_number;
885
886         MPV_frame_start(s, avctx);
887
888         encode_picture(s, s->picture_number);
889         
890         avctx->real_pict_num  = s->picture_number;
891         avctx->header_bits = s->header_bits;
892         avctx->mv_bits     = s->mv_bits;
893         avctx->misc_bits   = s->misc_bits;
894         avctx->i_tex_bits  = s->i_tex_bits;
895         avctx->p_tex_bits  = s->p_tex_bits;
896         avctx->i_count     = s->i_count;
897         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
898         avctx->skip_count  = s->skip_count;
899
900         MPV_frame_end(s);
901
902         if (s->out_format == FMT_MJPEG)
903             mjpeg_picture_trailer(s);
904
905         if(!s->fixed_qscale)
906             avctx->quality = s->qscale;
907         
908         if(s->flags&CODEC_FLAG_PASS1)
909             ff_write_pass1_stats(s);
910     
911     }
912
913     s->input_picture_number++;
914     s->input_picture_in_gop_number++;
915
916     flush_put_bits(&s->pb);
917     s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
918     
919     s->total_bits += s->frame_bits;
920     avctx->frame_bits  = s->frame_bits;
921 //printf("fcode: %d, type: %d, head: %d, mv: %d, misc: %d, frame: %d, itex: %d, ptex: %d\n", 
922 //s->f_code, avctx->key_frame, s->header_bits, s->mv_bits, s->misc_bits, s->frame_bits, s->i_tex_bits, s->p_tex_bits);
923 #if 0 //dump some stats to stats.txt for testing/debuging
924 if(s->max_b_frames==0)
925 {
926     static FILE *f=NULL;
927     if(!f) f= fopen("stats.txt", "wb");
928     get_psnr(pict->data, s->current_picture,
929              pict->linesize, s->linesize, avctx);
930     fprintf(f, "%7d, %7d, %2.4f\n", pbBufPtr(&s->pb) - s->pb.buf, s->qscale, avctx->psnr_y);
931 }
932 #endif
933
934     if (avctx->get_psnr) {
935         /* At this point pict->data should have the original frame   */
936         /* an s->current_picture should have the coded/decoded frame */
937         get_psnr(pict->data, s->current_picture,
938                  pict->linesize, s->linesize, avctx);
939 //        printf("%f\n", avctx->psnr_y);
940     }
941     return pbBufPtr(&s->pb) - s->pb.buf;
942 }
943
944 static inline void gmc1_motion(MpegEncContext *s,
945                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
946                                int dest_offset,
947                                UINT8 **ref_picture, int src_offset,
948                                int h)
949 {
950     UINT8 *ptr;
951     int offset, src_x, src_y, linesize, uvlinesize;
952     int motion_x, motion_y;
953     int emu=0;
954
955     if(s->real_sprite_warping_points>1) printf("more than 1 warp point isnt supported\n");
956     motion_x= s->sprite_offset[0][0];
957     motion_y= s->sprite_offset[0][1];
958     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
959     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
960     motion_x<<=(3-s->sprite_warping_accuracy);
961     motion_y<<=(3-s->sprite_warping_accuracy);
962     src_x = clip(src_x, -16, s->width);
963     if (src_x == s->width)
964         motion_x =0;
965     src_y = clip(src_y, -16, s->height);
966     if (src_y == s->height)
967         motion_y =0;
968     
969     linesize = s->linesize;
970     uvlinesize = s->uvlinesize;
971     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
972
973     dest_y+=dest_offset;
974     if(s->flags&CODEC_FLAG_EMU_EDGE){
975         if(src_x<0 || src_y<0 || src_x + (motion_x&15) + 16 > s->h_edge_pos
976                               || src_y + (motion_y&15) + h  > s->v_edge_pos){
977             emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
978             ptr= s->edge_emu_buffer;
979             emu=1;
980         }
981     }
982     gmc1(dest_y  , ptr  , linesize, h, motion_x&15, motion_y&15, s->no_rounding);
983     gmc1(dest_y+8, ptr+8, linesize, h, motion_x&15, motion_y&15, s->no_rounding);
984
985     motion_x= s->sprite_offset[1][0];
986     motion_y= s->sprite_offset[1][1];
987     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
988     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
989     motion_x<<=(3-s->sprite_warping_accuracy);
990     motion_y<<=(3-s->sprite_warping_accuracy);
991     src_x = clip(src_x, -8, s->width>>1);
992     if (src_x == s->width>>1)
993         motion_x =0;
994     src_y = clip(src_y, -8, s->height>>1);
995     if (src_y == s->height>>1)
996         motion_y =0;
997
998     offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
999     ptr = ref_picture[1] + offset;
1000     if(emu){
1001         emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1002         ptr= s->edge_emu_buffer;
1003     }
1004     gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
1005     
1006     ptr = ref_picture[2] + offset;
1007     if(emu){
1008         emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1009         ptr= s->edge_emu_buffer;
1010     }
1011     gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
1012     
1013     return;
1014 }
1015
1016 static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
1017                                     int src_x, int src_y, int w, int h){
1018     int x, y;
1019     int start_y, start_x, end_y, end_x;
1020     UINT8 *buf= s->edge_emu_buffer;
1021     
1022     if(src_y>= h){
1023         src+= (h-1-src_y)*linesize;
1024         src_y=h-1;
1025     }else if(src_y<=-block_h){
1026         src+= (1-block_h-src_y)*linesize;
1027         src_y=1-block_h;
1028     }
1029     if(src_x>= w){
1030         src+= (w-1-src_x);
1031         src_x=w-1;
1032     }else if(src_x<=-block_w){
1033         src+= (1-block_w-src_x);
1034         src_x=1-block_w;
1035     }
1036
1037     start_y= MAX(0, -src_y);
1038     start_x= MAX(0, -src_x);
1039     end_y= MIN(block_h, h-src_y);
1040     end_x= MIN(block_w, w-src_x);
1041
1042     // copy existing part
1043     for(y=start_y; y<end_y; y++){
1044         for(x=start_x; x<end_x; x++){
1045             buf[x + y*linesize]= src[x + y*linesize];
1046         }
1047     }
1048
1049     //top
1050     for(y=0; y<start_y; y++){
1051         for(x=start_x; x<end_x; x++){
1052             buf[x + y*linesize]= buf[x + start_y*linesize];
1053         }
1054     }
1055
1056     //bottom
1057     for(y=end_y; y<block_h; y++){
1058         for(x=start_x; x<end_x; x++){
1059             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1060         }
1061     }
1062                                     
1063     for(y=0; y<block_h; y++){
1064        //left
1065         for(x=0; x<start_x; x++){
1066             buf[x + y*linesize]= buf[start_x + y*linesize];
1067         }
1068        
1069        //right
1070         for(x=end_x; x<block_w; x++){
1071             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1072         }
1073     }
1074 }
1075
1076
1077 /* apply one mpeg motion vector to the three components */
1078 static inline void mpeg_motion(MpegEncContext *s,
1079                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1080                                int dest_offset,
1081                                UINT8 **ref_picture, int src_offset,
1082                                int field_based, op_pixels_func (*pix_op)[4],
1083                                int motion_x, int motion_y, int h)
1084 {
1085     UINT8 *ptr;
1086     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1087     int emu=0;
1088 #if 0    
1089 if(s->quarter_sample)
1090 {
1091     motion_x>>=1;
1092     motion_y>>=1;
1093 }
1094 #endif
1095     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1096     src_x = s->mb_x * 16 + (motion_x >> 1);
1097     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1098                 
1099     /* WARNING: do no forget half pels */
1100     height = s->height >> field_based;
1101     v_edge_pos = s->v_edge_pos >> field_based;
1102     src_x = clip(src_x, -16, s->width);
1103     if (src_x == s->width)
1104         dxy &= ~1;
1105     src_y = clip(src_y, -16, height);
1106     if (src_y == height)
1107         dxy &= ~2;
1108     linesize   = s->linesize << field_based;
1109     uvlinesize = s->uvlinesize << field_based;
1110     ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1111     dest_y += dest_offset;
1112
1113     if(s->flags&CODEC_FLAG_EMU_EDGE){
1114         if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1115                               || src_y + (motion_y&1) + h  > v_edge_pos){
1116             emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, v_edge_pos);
1117             ptr= s->edge_emu_buffer;
1118             emu=1;
1119         }
1120     }
1121     pix_op[0][dxy](dest_y, ptr, linesize, h);
1122
1123     if(s->flags&CODEC_FLAG_GRAY) return;
1124
1125     if (s->out_format == FMT_H263) {
1126         dxy = 0;
1127         if ((motion_x & 3) != 0)
1128             dxy |= 1;
1129         if ((motion_y & 3) != 0)
1130             dxy |= 2;
1131         mx = motion_x >> 2;
1132         my = motion_y >> 2;
1133     } else {
1134         mx = motion_x / 2;
1135         my = motion_y / 2;
1136         dxy = ((my & 1) << 1) | (mx & 1);
1137         mx >>= 1;
1138         my >>= 1;
1139     }
1140     
1141     src_x = s->mb_x * 8 + mx;
1142     src_y = s->mb_y * (8 >> field_based) + my;
1143     src_x = clip(src_x, -8, s->width >> 1);
1144     if (src_x == (s->width >> 1))
1145         dxy &= ~1;
1146     src_y = clip(src_y, -8, height >> 1);
1147     if (src_y == (height >> 1))
1148         dxy &= ~2;
1149     offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1150     ptr = ref_picture[1] + offset;
1151     if(emu){
1152         emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1153         ptr= s->edge_emu_buffer;
1154     }
1155     pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1156
1157     ptr = ref_picture[2] + offset;
1158     if(emu){
1159         emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1160         ptr= s->edge_emu_buffer;
1161     }
1162     pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1163 }
1164
1165 static inline void qpel_motion(MpegEncContext *s,
1166                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1167                                int dest_offset,
1168                                UINT8 **ref_picture, int src_offset,
1169                                int field_based, op_pixels_func (*pix_op)[4],
1170                                qpel_mc_func (*qpix_op)[16],
1171                                int motion_x, int motion_y, int h)
1172 {
1173     UINT8 *ptr;
1174     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1175     int emu=0;
1176
1177     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1178     src_x = s->mb_x * 16 + (motion_x >> 2);
1179     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1180
1181     height = s->height >> field_based;
1182     v_edge_pos = s->v_edge_pos >> field_based;
1183     src_x = clip(src_x, -16, s->width);
1184     if (src_x == s->width)
1185         dxy &= ~3;
1186     src_y = clip(src_y, -16, height);
1187     if (src_y == height)
1188         dxy &= ~12;
1189     linesize = s->linesize << field_based;
1190     uvlinesize = s->uvlinesize << field_based;
1191     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1192     dest_y += dest_offset;
1193 //printf("%d %d %d\n", src_x, src_y, dxy);
1194     
1195     if(s->flags&CODEC_FLAG_EMU_EDGE){
1196         if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1197                               || src_y + (motion_y&3) + h  > v_edge_pos){
1198             emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, v_edge_pos);
1199             ptr= s->edge_emu_buffer;
1200             emu=1;
1201         }
1202     }
1203     if(!field_based)
1204         qpix_op[0][dxy](dest_y, ptr, linesize);
1205     else{
1206         //damn interlaced mode
1207         //FIXME boundary mirroring is not exactly correct here
1208         qpix_op[1][dxy](dest_y  , ptr  , linesize);
1209         qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1210     }
1211
1212     if(s->flags&CODEC_FLAG_GRAY) return;
1213
1214     if(field_based){
1215         mx= motion_x/2;
1216         my= motion_y>>1;
1217     }else if(s->divx_version){
1218         mx= (motion_x>>1)|(motion_x&1);
1219         my= (motion_y>>1)|(motion_y&1);
1220     }else{
1221         mx= motion_x/2;
1222         my= motion_y/2;
1223     }
1224     mx= (mx>>1)|(mx&1);
1225     my= (my>>1)|(my&1);
1226     dxy= (mx&1) | ((my&1)<<1);
1227     mx>>=1;
1228     my>>=1;
1229
1230     src_x = s->mb_x * 8 + mx;
1231     src_y = s->mb_y * (8 >> field_based) + my;
1232     src_x = clip(src_x, -8, s->width >> 1);
1233     if (src_x == (s->width >> 1))
1234         dxy &= ~1;
1235     src_y = clip(src_y, -8, height >> 1);
1236     if (src_y == (height >> 1))
1237         dxy &= ~2;
1238
1239     offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1240     ptr = ref_picture[1] + offset;
1241     if(emu){
1242         emulated_edge_mc(s, ptr,  uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1243         ptr= s->edge_emu_buffer;
1244     }
1245     pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1246     
1247     ptr = ref_picture[2] + offset;
1248     if(emu){
1249         emulated_edge_mc(s, ptr,  uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1250         ptr= s->edge_emu_buffer;
1251     }
1252     pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1253 }
1254
1255
1256 static inline void MPV_motion(MpegEncContext *s, 
1257                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1258                               int dir, UINT8 **ref_picture, 
1259                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1260 {
1261     int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1262     int mb_x, mb_y, i;
1263     UINT8 *ptr, *dest;
1264     int emu=0;
1265
1266     mb_x = s->mb_x;
1267     mb_y = s->mb_y;
1268
1269     switch(s->mv_type) {
1270     case MV_TYPE_16X16:
1271         if(s->mcsel){
1272             gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1273                         ref_picture, 0,
1274                         16);
1275         }else if(s->quarter_sample){
1276             qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1277                         ref_picture, 0,
1278                         0, pix_op, qpix_op,
1279                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
1280         }else{
1281             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1282                         ref_picture, 0,
1283                         0, pix_op,
1284                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
1285         }           
1286         break;
1287     case MV_TYPE_8X8:
1288         mx = 0;
1289         my = 0;
1290         if(s->quarter_sample){
1291             for(i=0;i<4;i++) {
1292                 motion_x = s->mv[dir][i][0];
1293                 motion_y = s->mv[dir][i][1];
1294
1295                 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1296                 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1297                 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1298                     
1299                 /* WARNING: do no forget half pels */
1300                 src_x = clip(src_x, -16, s->width);
1301                 if (src_x == s->width)
1302                     dxy &= ~3;
1303                 src_y = clip(src_y, -16, s->height);
1304                 if (src_y == s->height)
1305                     dxy &= ~12;
1306                     
1307                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1308                 if(s->flags&CODEC_FLAG_EMU_EDGE){
1309                     if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1310                                           || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1311                         emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1312                         ptr= s->edge_emu_buffer;
1313                     }
1314                 }
1315                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1316                 qpix_op[1][dxy](dest, ptr, s->linesize);
1317
1318                 mx += s->mv[dir][i][0]/2;
1319                 my += s->mv[dir][i][1]/2;
1320             }
1321         }else{
1322             for(i=0;i<4;i++) {
1323                 motion_x = s->mv[dir][i][0];
1324                 motion_y = s->mv[dir][i][1];
1325
1326                 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1327                 src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1328                 src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1329                     
1330                 /* WARNING: do no forget half pels */
1331                 src_x = clip(src_x, -16, s->width);
1332                 if (src_x == s->width)
1333                     dxy &= ~1;
1334                 src_y = clip(src_y, -16, s->height);
1335                 if (src_y == s->height)
1336                     dxy &= ~2;
1337                     
1338                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1339                 if(s->flags&CODEC_FLAG_EMU_EDGE){
1340                     if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1341                                           || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1342                         emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1343                         ptr= s->edge_emu_buffer;
1344                     }
1345                 }
1346                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1347                 pix_op[1][dxy](dest, ptr, s->linesize, 8);
1348
1349                 mx += s->mv[dir][i][0];
1350                 my += s->mv[dir][i][1];
1351             }
1352         }
1353
1354         if(s->flags&CODEC_FLAG_GRAY) break;
1355         /* In case of 8X8, we construct a single chroma motion vector
1356            with a special rounding */
1357         for(i=0;i<4;i++) {
1358         }
1359         if (mx >= 0)
1360             mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1361         else {
1362             mx = -mx;
1363             mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1364         }
1365         if (my >= 0)
1366             my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1367         else {
1368             my = -my;
1369             my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1370         }
1371         dxy = ((my & 1) << 1) | (mx & 1);
1372         mx >>= 1;
1373         my >>= 1;
1374
1375         src_x = mb_x * 8 + mx;
1376         src_y = mb_y * 8 + my;
1377         src_x = clip(src_x, -8, s->width/2);
1378         if (src_x == s->width/2)
1379             dxy &= ~1;
1380         src_y = clip(src_y, -8, s->height/2);
1381         if (src_y == s->height/2)
1382             dxy &= ~2;
1383         
1384         offset = (src_y * (s->uvlinesize)) + src_x;
1385         ptr = ref_picture[1] + offset;
1386         if(s->flags&CODEC_FLAG_EMU_EDGE){
1387                 if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1388                                       || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1389                     emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1390                     ptr= s->edge_emu_buffer;
1391                     emu=1;
1392                 }
1393             }
1394         pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1395
1396         ptr = ref_picture[2] + offset;
1397         if(emu){
1398             emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1399             ptr= s->edge_emu_buffer;
1400         }
1401         pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
1402         break;
1403     case MV_TYPE_FIELD:
1404         if (s->picture_structure == PICT_FRAME) {
1405             if(s->quarter_sample){
1406                 /* top field */
1407                 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1408                             ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1409                             1, pix_op, qpix_op,
1410                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
1411                 /* bottom field */
1412                 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1413                             ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1414                             1, pix_op, qpix_op,
1415                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
1416             }else{
1417                 /* top field */       
1418                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1419                             ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1420                             1, pix_op,
1421                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
1422                 /* bottom field */
1423                 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1424                             ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1425                             1, pix_op,
1426                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
1427             }
1428         } else {
1429             
1430
1431         }
1432         break;
1433     }
1434 }
1435
1436
1437 /* put block[] to dest[] */
1438 static inline void put_dct(MpegEncContext *s, 
1439                            DCTELEM *block, int i, UINT8 *dest, int line_size)
1440 {
1441     if (!s->mpeg2)
1442         s->dct_unquantize(s, block, i, s->qscale);
1443     ff_idct_put (dest, line_size, block);
1444 }
1445
1446 /* add block[] to dest[] */
1447 static inline void add_dct(MpegEncContext *s, 
1448                            DCTELEM *block, int i, UINT8 *dest, int line_size)
1449 {
1450     if (s->block_last_index[i] >= 0) {
1451         ff_idct_add (dest, line_size, block);
1452     }
1453 }
1454
1455 static inline void add_dequant_dct(MpegEncContext *s, 
1456                            DCTELEM *block, int i, UINT8 *dest, int line_size)
1457 {
1458     if (s->block_last_index[i] >= 0) {
1459         s->dct_unquantize(s, block, i, s->qscale);
1460
1461         ff_idct_add (dest, line_size, block);
1462     }
1463 }
1464
1465 /**
1466  * cleans dc, ac, coded_block for the current non intra MB
1467  */
1468 void ff_clean_intra_table_entries(MpegEncContext *s)
1469 {
1470     int wrap = s->block_wrap[0];
1471     int xy = s->block_index[0];
1472     
1473     s->dc_val[0][xy           ] = 
1474     s->dc_val[0][xy + 1       ] = 
1475     s->dc_val[0][xy     + wrap] =
1476     s->dc_val[0][xy + 1 + wrap] = 1024;
1477     /* ac pred */
1478     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(INT16));
1479     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
1480     if (s->msmpeg4_version>=3) {
1481         s->coded_block[xy           ] =
1482         s->coded_block[xy + 1       ] =
1483         s->coded_block[xy     + wrap] =
1484         s->coded_block[xy + 1 + wrap] = 0;
1485     }
1486     /* chroma */
1487     wrap = s->block_wrap[4];
1488     xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
1489     s->dc_val[1][xy] =
1490     s->dc_val[2][xy] = 1024;
1491     /* ac pred */
1492     memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
1493     memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
1494     
1495     s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1496 }
1497
1498 /* generic function called after a macroblock has been parsed by the
1499    decoder or after it has been encoded by the encoder.
1500
1501    Important variables used:
1502    s->mb_intra : true if intra macroblock
1503    s->mv_dir   : motion vector direction
1504    s->mv_type  : motion vector type
1505    s->mv       : motion vector
1506    s->interlaced_dct : true if interlaced dct used (mpeg2)
1507  */
1508 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1509 {
1510     int mb_x, mb_y;
1511     const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
1512
1513     mb_x = s->mb_x;
1514     mb_y = s->mb_y;
1515
1516 #ifdef FF_POSTPROCESS
1517     /* Obsolete. Exists for compatibility with mplayer only. */
1518     quant_store[mb_y][mb_x]=s->qscale;
1519     //printf("[%02d][%02d] %d\n",mb_x,mb_y,s->qscale);
1520 #else
1521     /* even more obsolete, exists for mplayer xp only */
1522     if(s->avctx->quant_store) s->avctx->quant_store[mb_y*s->avctx->qstride+mb_x] = s->qscale;
1523 #endif
1524     s->qscale_table[mb_xy]= s->qscale;
1525
1526     /* update DC predictors for P macroblocks */
1527     if (!s->mb_intra) {
1528         if (s->h263_pred || s->h263_aic) {
1529             if(s->mbintra_table[mb_xy])
1530                 ff_clean_intra_table_entries(s);
1531         } else {
1532             s->last_dc[0] =
1533             s->last_dc[1] =
1534             s->last_dc[2] = 128 << s->intra_dc_precision;
1535         }
1536     }
1537     else if (s->h263_pred || s->h263_aic)
1538         s->mbintra_table[mb_xy]=1;
1539
1540     /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
1541     if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
1542         
1543         const int wrap = s->block_wrap[0];
1544         const int xy = s->block_index[0];
1545         const int mb_index= s->mb_x + s->mb_y*s->mb_width;
1546         if(s->mv_type == MV_TYPE_8X8){
1547             s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
1548         } else {
1549             int motion_x, motion_y;
1550             if (s->mb_intra) {
1551                 motion_x = 0;
1552                 motion_y = 0;
1553                 if(s->co_located_type_table)
1554                     s->co_located_type_table[mb_index]= 0;
1555             } else if (s->mv_type == MV_TYPE_16X16) {
1556                 motion_x = s->mv[0][0][0];
1557                 motion_y = s->mv[0][0][1];
1558                 if(s->co_located_type_table)
1559                     s->co_located_type_table[mb_index]= 0;
1560             } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1561                 int i;
1562                 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1563                 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1564                 motion_x = (motion_x>>1) | (motion_x&1);
1565                 for(i=0; i<2; i++){
1566                     s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
1567                     s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
1568                     s->field_select_table[mb_index][i]= s->field_select[0][i];
1569                 }
1570                 s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
1571             }
1572             /* no update if 8X8 because it has been done during parsing */
1573             s->motion_val[xy][0] = motion_x;
1574             s->motion_val[xy][1] = motion_y;
1575             s->motion_val[xy + 1][0] = motion_x;
1576             s->motion_val[xy + 1][1] = motion_y;
1577             s->motion_val[xy + wrap][0] = motion_x;
1578             s->motion_val[xy + wrap][1] = motion_y;
1579             s->motion_val[xy + 1 + wrap][0] = motion_x;
1580             s->motion_val[xy + 1 + wrap][1] = motion_y;
1581         }
1582     }
1583     
1584     if (!(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) {
1585         UINT8 *dest_y, *dest_cb, *dest_cr;
1586         int dct_linesize, dct_offset;
1587         op_pixels_func (*op_pix)[4];
1588         qpel_mc_func (*op_qpix)[16];
1589
1590         /* avoid copy if macroblock skipped in last frame too 
1591            dont touch it for B-frames as they need the skip info from the next p-frame */
1592         if (s->pict_type != B_TYPE) {
1593             UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
1594             if (s->mb_skiped) {
1595                 s->mb_skiped = 0;
1596
1597                 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
1598                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1599
1600                 /* if previous was skipped too, then nothing to do ! 
1601                    skip only during decoding as we might trash the buffers during encoding a bit */
1602                 if (*mbskip_ptr >= s->ip_buffer_count  && !s->encoding) 
1603                     goto the_end;
1604             } else {
1605                 *mbskip_ptr = 0; /* not skipped */
1606             }
1607         }
1608
1609         dest_y = s->current_picture [0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
1610         dest_cb = s->current_picture[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1611         dest_cr = s->current_picture[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1612
1613         if (s->interlaced_dct) {
1614             dct_linesize = s->linesize * 2;
1615             dct_offset = s->linesize;
1616         } else {
1617             dct_linesize = s->linesize;
1618             dct_offset = s->linesize * 8;
1619         }
1620
1621         if (!s->mb_intra) {
1622             /* motion handling */
1623             /* decoding or more than one mb_type (MC was allready done otherwise) */
1624             if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
1625                 if ((!s->no_rounding) || s->pict_type==B_TYPE){                
1626                     op_pix = put_pixels_tab;
1627                     op_qpix= put_qpel_pixels_tab;
1628                 }else{
1629                     op_pix = put_no_rnd_pixels_tab;
1630                     op_qpix= put_no_rnd_qpel_pixels_tab;
1631                 }
1632
1633                 if (s->mv_dir & MV_DIR_FORWARD) {
1634                     MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
1635                     op_pix = avg_pixels_tab;
1636                     op_qpix= avg_qpel_pixels_tab;
1637                 }
1638                 if (s->mv_dir & MV_DIR_BACKWARD) {
1639                     MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
1640                 }
1641             }
1642
1643             /* skip dequant / idct if we are really late ;) */
1644             if(s->hurry_up>1) goto the_end;
1645
1646             /* add dct residue */
1647             if(s->encoding || !(s->mpeg2 || s->h263_msmpeg4 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1648                 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
1649                 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1650                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1651                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1652
1653                 if(!(s->flags&CODEC_FLAG_GRAY)){
1654                     add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1655                     add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1656                 }
1657             } else {
1658                 add_dct(s, block[0], 0, dest_y, dct_linesize);
1659                 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1660                 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1661                 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1662
1663                 if(!(s->flags&CODEC_FLAG_GRAY)){
1664                     add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1665                     add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1666                 }
1667             }
1668         } else {
1669             /* dct only in intra block */
1670             put_dct(s, block[0], 0, dest_y, dct_linesize);
1671             put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1672             put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1673             put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1674
1675             if(!(s->flags&CODEC_FLAG_GRAY)){
1676                 put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1677                 put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1678             }
1679         }
1680     }
1681  the_end:
1682     emms_c(); //FIXME remove
1683 }
1684
1685 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
1686 {
1687     static const char tab[64]=
1688         {3,2,2,1,1,1,1,1,
1689          1,1,1,1,1,1,1,1,
1690          1,1,1,1,1,1,1,1,
1691          0,0,0,0,0,0,0,0,
1692          0,0,0,0,0,0,0,0,
1693          0,0,0,0,0,0,0,0,
1694          0,0,0,0,0,0,0,0,
1695          0,0,0,0,0,0,0,0};
1696     int score=0;
1697     int run=0;
1698     int i;
1699     DCTELEM *block= s->block[n];
1700     const int last_index= s->block_last_index[n];
1701     int skip_dc;
1702
1703     if(threshold<0){
1704         skip_dc=0;
1705         threshold= -threshold;
1706     }else
1707         skip_dc=1;
1708
1709     /* are all which we could set to zero are allready zero? */
1710     if(last_index<=skip_dc - 1) return;
1711
1712     for(i=0; i<=last_index; i++){
1713         const int j = zigzag_direct[i];
1714         const int level = ABS(block[j]);
1715         if(level==1){
1716             if(skip_dc && i==0) continue;
1717             score+= tab[run];
1718             run=0;
1719         }else if(level>1){
1720             return;
1721         }else{
1722             run++;
1723         }
1724     }
1725     if(score >= threshold) return;
1726     for(i=skip_dc; i<=last_index; i++){
1727         const int j = zigzag_direct[i];
1728         block[j]=0;
1729     }
1730     if(block[0]) s->block_last_index[n]= 0;
1731     else         s->block_last_index[n]= -1;
1732 }
1733
1734 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
1735 {
1736     int i;
1737     const int maxlevel= s->max_qcoeff;
1738     const int minlevel= s->min_qcoeff;
1739         
1740     for(i=0;i<=last_index; i++){
1741         const int j = zigzag_direct[i];
1742         int level = block[j];
1743        
1744         if     (level>maxlevel) level=maxlevel;
1745         else if(level<minlevel) level=minlevel;
1746         block[j]= level;
1747     }
1748 }
1749
1750 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
1751 {
1752     const int mb_x= s->mb_x;
1753     const int mb_y= s->mb_y;
1754     int i;
1755     int skip_dct[6];
1756 #if 0
1757         if (s->interlaced_dct) {
1758             dct_linesize = s->linesize * 2;
1759             dct_offset = s->linesize;
1760         } else {
1761             dct_linesize = s->linesize;
1762             dct_offset = s->linesize * 8;
1763         }
1764 #endif
1765     for(i=0; i<6; i++) skip_dct[i]=0;
1766     
1767     if(s->adaptive_quant){
1768         s->dquant= s->qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
1769         if(s->codec_id==CODEC_ID_MPEG4){
1770             if     (s->dquant> 2) s->dquant= 2;
1771             else if(s->dquant<-2) s->dquant=-2;
1772         
1773             if(!s->mb_intra){
1774                 assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
1775
1776                 if(s->mv_dir&MV_DIRECT)
1777                     s->dquant=0;
1778             }
1779         }
1780         s->qscale+= s->dquant;
1781         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1782         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1783     }
1784
1785     if (s->mb_intra) {
1786         UINT8 *ptr;
1787         int wrap;
1788         int emu=0;
1789
1790         wrap = s->linesize;
1791         ptr = s->new_picture[0] + (mb_y * 16 * wrap) + mb_x * 16;
1792         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
1793             emulated_edge_mc(s, ptr, wrap, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
1794             ptr= s->edge_emu_buffer;
1795             emu=1;
1796         }
1797         get_pixels(s->block[0], ptr               , wrap);
1798         get_pixels(s->block[1], ptr            + 8, wrap);
1799         get_pixels(s->block[2], ptr + 8 * wrap    , wrap);
1800         get_pixels(s->block[3], ptr + 8 * wrap + 8, wrap);
1801
1802         if(s->flags&CODEC_FLAG_GRAY){
1803             skip_dct[4]= 1;
1804             skip_dct[5]= 1;
1805         }else{
1806             wrap >>=1;
1807             ptr = s->new_picture[1] + (mb_y * 8 * wrap) + mb_x * 8;
1808             if(emu){
1809                 emulated_edge_mc(s, ptr, wrap, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
1810                 ptr= s->edge_emu_buffer;
1811             }
1812             get_pixels(s->block[4], ptr, wrap);
1813
1814             ptr = s->new_picture[2] + (mb_y * 8 * wrap) + mb_x * 8;
1815             if(emu){
1816                 emulated_edge_mc(s, ptr, wrap, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
1817                 ptr= s->edge_emu_buffer;
1818             }
1819             get_pixels(s->block[5], ptr, wrap);
1820         }
1821     }else{
1822         op_pixels_func (*op_pix)[4];
1823         qpel_mc_func (*op_qpix)[16];
1824         UINT8 *dest_y, *dest_cb, *dest_cr;
1825         UINT8 *ptr_y, *ptr_cb, *ptr_cr;
1826         int wrap_y, wrap_c;
1827         int emu=0;
1828
1829         dest_y  = s->current_picture[0] + (mb_y * 16 * s->linesize       ) + mb_x * 16;
1830         dest_cb = s->current_picture[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
1831         dest_cr = s->current_picture[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
1832         wrap_y = s->linesize;
1833         wrap_c = wrap_y>>1;
1834         ptr_y  = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
1835         ptr_cb = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
1836         ptr_cr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
1837
1838         if ((!s->no_rounding) || s->pict_type==B_TYPE){
1839             op_pix = put_pixels_tab;
1840             op_qpix= put_qpel_pixels_tab;
1841         }else{
1842             op_pix = put_no_rnd_pixels_tab;
1843             op_qpix= put_no_rnd_qpel_pixels_tab;
1844         }
1845
1846         if (s->mv_dir & MV_DIR_FORWARD) {
1847             MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
1848             op_pix = avg_pixels_tab;
1849             op_qpix= avg_qpel_pixels_tab;
1850         }
1851         if (s->mv_dir & MV_DIR_BACKWARD) {
1852             MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
1853         }
1854
1855         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
1856             emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
1857             ptr_y= s->edge_emu_buffer;
1858             emu=1;
1859         }
1860         diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
1861         diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
1862         diff_pixels(s->block[2], ptr_y + 8 * wrap_y    , dest_y + 8 * wrap_y    , wrap_y);
1863         diff_pixels(s->block[3], ptr_y + 8 * wrap_y + 8, dest_y + 8 * wrap_y + 8, wrap_y);
1864         
1865         if(s->flags&CODEC_FLAG_GRAY){
1866             skip_dct[4]= 1;
1867             skip_dct[5]= 1;
1868         }else{
1869             if(emu){
1870                 emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
1871                 ptr_cb= s->edge_emu_buffer;
1872             }
1873             diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1874             if(emu){
1875                 emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
1876                 ptr_cr= s->edge_emu_buffer;
1877             }
1878             diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1879         }
1880
1881         /* pre quantization */         
1882         if(s->mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
1883             if(pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
1884             if(pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
1885             if(pix_abs8x8(ptr_y + 8*wrap_y    , dest_y + 8*wrap_y    , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
1886             if(pix_abs8x8(ptr_y + 8*wrap_y + 8, dest_y + 8*wrap_y + 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
1887             if(pix_abs8x8(ptr_cb              , dest_cb              , wrap_y) < 20*s->qscale) skip_dct[4]= 1;
1888             if(pix_abs8x8(ptr_cr              , dest_cr              , wrap_y) < 20*s->qscale) skip_dct[5]= 1;
1889 #if 0
1890 {
1891  static int stat[7];
1892  int num=0;
1893  for(i=0; i<6; i++)
1894   if(skip_dct[i]) num++;
1895  stat[num]++;
1896  
1897  if(s->mb_x==0 && s->mb_y==0){
1898   for(i=0; i<7; i++){
1899    printf("%6d %1d\n", stat[i], i);
1900   }
1901  }
1902 }
1903 #endif
1904         }
1905
1906     }
1907             
1908 #if 0
1909             {
1910                 float adap_parm;
1911                 
1912                 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
1913                             ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
1914             
1915                 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 
1916                         (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P', 
1917                         s->qscale, adap_parm, s->qscale*adap_parm,
1918                         s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
1919             }
1920 #endif
1921     /* DCT & quantize */
1922     if(s->out_format==FMT_MJPEG){
1923         for(i=0;i<6;i++) {
1924             int overflow;
1925             s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
1926             if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
1927         }
1928     }else{
1929         for(i=0;i<6;i++) {
1930             if(!skip_dct[i]){
1931                 int overflow;
1932                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
1933             // FIXME we could decide to change to quantizer instead of clipping
1934             // JS: I don't think that would be a good idea it could lower quality instead
1935             //     of improve it. Just INTRADC clipping deserves changes in quantizer
1936                 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
1937             }else
1938                 s->block_last_index[i]= -1;
1939         }
1940         if(s->luma_elim_threshold && !s->mb_intra)
1941             for(i=0; i<4; i++)
1942                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
1943         if(s->chroma_elim_threshold && !s->mb_intra)
1944             for(i=4; i<6; i++)
1945                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
1946     }
1947
1948     if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
1949         s->block_last_index[4]=
1950         s->block_last_index[5]= 0;
1951         s->block[4][0]=
1952         s->block[5][0]= 128;
1953     }
1954
1955     /* huffman encode */
1956     switch(s->out_format) {
1957     case FMT_MPEG1:
1958         mpeg1_encode_mb(s, s->block, motion_x, motion_y);
1959         break;
1960     case FMT_H263:
1961         if (s->h263_msmpeg4)
1962             msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
1963         else if(s->h263_pred)
1964             mpeg4_encode_mb(s, s->block, motion_x, motion_y);
1965         else
1966             h263_encode_mb(s, s->block, motion_x, motion_y);
1967         break;
1968     case FMT_MJPEG:
1969         mjpeg_encode_mb(s, s->block);
1970         break;
1971     }
1972 }
1973
1974 void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
1975 {
1976     int bytes= length>>4;
1977     int bits= length&15;
1978     int i;
1979
1980     if(length==0) return;
1981
1982     for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
1983     put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
1984 }
1985
1986 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
1987     int i;
1988
1989     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
1990
1991     /* mpeg1 */
1992     d->mb_incr= s->mb_incr;
1993     for(i=0; i<3; i++)
1994         d->last_dc[i]= s->last_dc[i];
1995     
1996     /* statistics */
1997     d->mv_bits= s->mv_bits;
1998     d->i_tex_bits= s->i_tex_bits;
1999     d->p_tex_bits= s->p_tex_bits;
2000     d->i_count= s->i_count;
2001     d->f_count= s->f_count;
2002     d->b_count= s->b_count;
2003     d->skip_count= s->skip_count;
2004     d->misc_bits= s->misc_bits;
2005     d->last_bits= 0;
2006
2007     d->mb_skiped= s->mb_skiped;
2008 }
2009
2010 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2011     int i;
2012
2013     memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
2014     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2015     
2016     /* mpeg1 */
2017     d->mb_incr= s->mb_incr;
2018     for(i=0; i<3; i++)
2019         d->last_dc[i]= s->last_dc[i];
2020     
2021     /* statistics */
2022     d->mv_bits= s->mv_bits;
2023     d->i_tex_bits= s->i_tex_bits;
2024     d->p_tex_bits= s->p_tex_bits;
2025     d->i_count= s->i_count;
2026     d->f_count= s->f_count;
2027     d->b_count= s->b_count;
2028     d->skip_count= s->skip_count;
2029     d->misc_bits= s->misc_bits;
2030
2031     d->mb_intra= s->mb_intra;
2032     d->mb_skiped= s->mb_skiped;
2033     d->mv_type= s->mv_type;
2034     d->mv_dir= s->mv_dir;
2035     d->pb= s->pb;
2036     if(s->data_partitioning){
2037         d->pb2= s->pb2;
2038         d->tex_pb= s->tex_pb;
2039     }
2040     d->block= s->block;
2041     for(i=0; i<6; i++)
2042         d->block_last_index[i]= s->block_last_index[i];
2043 }
2044
2045 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
2046                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2047                            int *dmin, int *next_block, int motion_x, int motion_y)
2048 {
2049     int bits_count;
2050     
2051     copy_context_before_encode(s, backup, type);
2052
2053     s->block= s->blocks[*next_block];
2054     s->pb= pb[*next_block];
2055     if(s->data_partitioning){
2056         s->pb2   = pb2   [*next_block];
2057         s->tex_pb= tex_pb[*next_block];
2058     }
2059
2060     encode_mb(s, motion_x, motion_y);
2061
2062     bits_count= get_bit_count(&s->pb);
2063     if(s->data_partitioning){
2064         bits_count+= get_bit_count(&s->pb2);
2065         bits_count+= get_bit_count(&s->tex_pb);
2066     }
2067
2068     if(bits_count<*dmin){
2069         *dmin= bits_count;
2070         *next_block^=1;
2071
2072         copy_context_after_encode(best, s, type);
2073     }
2074 }
2075
2076 static void encode_picture(MpegEncContext *s, int picture_number)
2077 {
2078     int mb_x, mb_y, last_gob, pdif = 0;
2079     int i;
2080     int bits;
2081     MpegEncContext best_s, backup_s;
2082     UINT8 bit_buf[2][3000];
2083     UINT8 bit_buf2[2][3000];
2084     UINT8 bit_buf_tex[2][3000];
2085     PutBitContext pb[2], pb2[2], tex_pb[2];
2086
2087     for(i=0; i<2; i++){
2088         init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2089         init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2090         init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2091     }
2092
2093     s->picture_number = picture_number;
2094
2095     s->block_wrap[0]=
2096     s->block_wrap[1]=
2097     s->block_wrap[2]=
2098     s->block_wrap[3]= s->mb_width*2 + 2;
2099     s->block_wrap[4]=
2100     s->block_wrap[5]= s->mb_width + 2;
2101     
2102     /* Reset the average MB variance */
2103     s->mb_var_sum = 0;
2104     s->mc_mb_var_sum = 0;
2105
2106     /* we need to initialize some time vars before we can encode b-frames */
2107     if (s->h263_pred && !s->h263_msmpeg4)
2108         ff_set_mpeg4_time(s, s->picture_number); 
2109
2110     s->scene_change_score=0;
2111     
2112     s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2113
2114     /* Estimate motion for every MB */
2115     if(s->pict_type != I_TYPE){
2116         for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2117             s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2118             s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2119             s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2120             s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2121             for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2122                 s->mb_x = mb_x;
2123                 s->mb_y = mb_y;
2124                 s->block_index[0]+=2;
2125                 s->block_index[1]+=2;
2126                 s->block_index[2]+=2;
2127                 s->block_index[3]+=2;
2128
2129                 /* compute motion vector & mb_type and store in context */
2130                 if(s->pict_type==B_TYPE)
2131                     ff_estimate_b_frame_motion(s, mb_x, mb_y);
2132                 else
2133                     ff_estimate_p_frame_motion(s, mb_x, mb_y);
2134 //                s->mb_type[mb_y*s->mb_width + mb_x]=MB_TYPE_INTER;
2135             }
2136         }
2137         emms_c();
2138     }else /* if(s->pict_type == I_TYPE) */{
2139         /* I-Frame */
2140         //FIXME do we need to zero them?
2141         memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2142         memset(s->p_mv_table   , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
2143         memset(s->mb_type      , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2144         
2145         if(!s->fixed_qscale){
2146             /* finding spatial complexity for I-frame rate control */
2147             for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2148                 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2149                     int xx = mb_x * 16;
2150                     int yy = mb_y * 16;
2151                     uint8_t *pix = s->new_picture[0] + (yy * s->linesize) + xx;
2152                     int varc;
2153                     int sum = pix_sum(pix, s->linesize);
2154     
2155                     sum= (sum+8)>>4;
2156                     varc = (pix_norm1(pix, s->linesize) - sum*sum + 500 + 128)>>8;
2157
2158                     s->mb_var [s->mb_width * mb_y + mb_x] = varc;
2159                     s->mb_mean[s->mb_width * mb_y + mb_x] = (sum+7)>>4;
2160                     s->mb_var_sum    += varc;
2161                 }
2162             }
2163         }
2164     }
2165     if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2166         s->pict_type= I_TYPE;
2167         memset(s->mb_type   , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2168         if(s->max_b_frames==0){
2169             s->input_pict_type= I_TYPE;
2170             s->input_picture_in_gop_number=0;
2171         }
2172 //printf("Scene change detected, encoding as I Frame %d %d\n", s->mb_var_sum, s->mc_mb_var_sum);
2173     }
2174     
2175     if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) 
2176         s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2177         ff_fix_long_p_mvs(s);
2178     if(s->pict_type==B_TYPE){
2179         s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2180         s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2181
2182         ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2183         ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2184         ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2185         ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2186     }
2187     
2188     if (s->fixed_qscale) 
2189         s->frame_qscale = s->avctx->quality;
2190     else
2191         s->frame_qscale = ff_rate_estimate_qscale(s);
2192
2193     if(s->adaptive_quant){
2194         switch(s->codec_id){
2195         case CODEC_ID_MPEG4:
2196             ff_clean_mpeg4_qscales(s);
2197             break;
2198         case CODEC_ID_H263:
2199         case CODEC_ID_H263P:
2200             ff_clean_h263_qscales(s);
2201             break;
2202         }
2203
2204         s->qscale= s->qscale_table[0];
2205     }else
2206         s->qscale= (int)(s->frame_qscale + 0.5);
2207         
2208     if (s->out_format == FMT_MJPEG) {
2209         /* for mjpeg, we do include qscale in the matrix */
2210         s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2211         for(i=1;i<64;i++)
2212             s->intra_matrix[i] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2213         convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, 
2214                        s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias);
2215     }
2216
2217     s->last_bits= get_bit_count(&s->pb);
2218     switch(s->out_format) {
2219     case FMT_MJPEG:
2220         mjpeg_picture_header(s);
2221         break;
2222     case FMT_H263:
2223         if (s->h263_msmpeg4) 
2224             msmpeg4_encode_picture_header(s, picture_number);
2225         else if (s->h263_pred)
2226             mpeg4_encode_picture_header(s, picture_number);
2227         else if (s->h263_rv10) 
2228             rv10_encode_picture_header(s, picture_number);
2229         else
2230             h263_encode_picture_header(s, picture_number);
2231         break;
2232     case FMT_MPEG1:
2233         mpeg1_encode_picture_header(s, picture_number);
2234         break;
2235     }
2236     bits= get_bit_count(&s->pb);
2237     s->header_bits= bits - s->last_bits;
2238     s->last_bits= bits;
2239     s->mv_bits=0;
2240     s->misc_bits=0;
2241     s->i_tex_bits=0;
2242     s->p_tex_bits=0;
2243     s->i_count=0;
2244     s->f_count=0;
2245     s->b_count=0;
2246     s->skip_count=0;
2247
2248     /* init last dc values */
2249     /* note: quant matrix value (8) is implied here */
2250     s->last_dc[0] = 128;
2251     s->last_dc[1] = 128;
2252     s->last_dc[2] = 128;
2253     s->mb_incr = 1;
2254     s->last_mv[0][0][0] = 0;
2255     s->last_mv[0][0][1] = 0;
2256
2257     /* Get the GOB height based on picture height */
2258     if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4) {
2259         if (s->height <= 400)
2260             s->gob_index = 1;
2261         else if (s->height <= 800)
2262             s->gob_index = 2;
2263         else
2264             s->gob_index = 4;
2265     }else if(s->codec_id==CODEC_ID_MPEG4){
2266         s->gob_index = 1;
2267     }
2268
2269     if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
2270         ff_mpeg4_init_partitions(s);
2271
2272     s->resync_mb_x=0;
2273     s->resync_mb_y=0;
2274     for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2275         /* Put GOB header based on RTP MTU for formats which support it per line (H263*)*/
2276         /* TODO: Put all this stuff in a separate generic function */
2277         if (s->rtp_mode) {
2278             if (!mb_y) {
2279                 s->ptr_lastgob = s->pb.buf;
2280                 s->ptr_last_mb_line = s->pb.buf;
2281             } else if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4 && !(mb_y % s->gob_index)) {
2282                 // MN: we could move the space check from h263 -> here, as its not h263 specific
2283                 last_gob = h263_encode_gob_header(s, mb_y);
2284                 if (last_gob) {
2285                     s->first_slice_line = 1;
2286                 }else{
2287                     /*MN: we reset it here instead at the end of each line cuz mpeg4 can have 
2288                           slice lines starting & ending in the middle*/
2289                     s->first_slice_line = 0;
2290                 }
2291             }
2292         }
2293
2294         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2295         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2296         
2297         s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2298         s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2299         s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2300         s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2301         s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
2302         s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
2303         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2304             const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
2305             const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
2306 //            int d;
2307             int dmin=10000000;
2308
2309             s->mb_x = mb_x;
2310             s->mb_y = mb_y;
2311             s->block_index[0]+=2;
2312             s->block_index[1]+=2;
2313             s->block_index[2]+=2;
2314             s->block_index[3]+=2;
2315             s->block_index[4]++;
2316             s->block_index[5]++;
2317             
2318             /* write gob / video packet header for formats which support it at any MB (MPEG4) */
2319             if(s->rtp_mode && s->mb_y>0 && s->codec_id==CODEC_ID_MPEG4){
2320                 int pdif= pbBufPtr(&s->pb) - s->ptr_lastgob;
2321
2322                 //the *2 is there so we stay below the requested size
2323                 if(pdif + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size){ 
2324                     if(s->codec_id==CODEC_ID_MPEG4){
2325                         if(s->data_partitioning && s->pict_type!=B_TYPE){
2326                             ff_mpeg4_merge_partitions(s);
2327                             ff_mpeg4_init_partitions(s);
2328                         }
2329                         ff_mpeg4_encode_video_packet_header(s);
2330
2331                         if(s->flags&CODEC_FLAG_PASS1){
2332                             int bits= get_bit_count(&s->pb);
2333                             s->misc_bits+= bits - s->last_bits;
2334                             s->last_bits= bits;
2335                         }
2336                         ff_mpeg4_clean_buffers(s);
2337                     }
2338                     s->ptr_lastgob = pbBufPtr(&s->pb);
2339                     s->first_slice_line=1;
2340                     s->resync_mb_x=mb_x;
2341                     s->resync_mb_y=mb_y;
2342                 }
2343
2344                 if(  (s->resync_mb_x   == s->mb_x)
2345                    && s->resync_mb_y+1 == s->mb_y){
2346                     s->first_slice_line=0; 
2347                 }
2348             }
2349
2350             if(mb_type & (mb_type-1)){ // more than 1 MB type possible
2351                 int next_block=0;
2352                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2353
2354                 copy_context_before_encode(&backup_s, s, -1);
2355                 backup_s.pb= s->pb;
2356                 best_s.data_partitioning= s->data_partitioning;
2357                 if(s->data_partitioning){
2358                     backup_s.pb2= s->pb2;
2359                     backup_s.tex_pb= s->tex_pb;
2360                 }
2361
2362                 if(mb_type&MB_TYPE_INTER){
2363                     s->mv_dir = MV_DIR_FORWARD;
2364                     s->mv_type = MV_TYPE_16X16;
2365                     s->mb_intra= 0;
2366                     s->mv[0][0][0] = s->p_mv_table[xy][0];
2367                     s->mv[0][0][1] = s->p_mv_table[xy][1];
2368                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb, 
2369                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2370                 }
2371                 if(mb_type&MB_TYPE_INTER4V){                 
2372                     s->mv_dir = MV_DIR_FORWARD;
2373                     s->mv_type = MV_TYPE_8X8;
2374                     s->mb_intra= 0;
2375                     for(i=0; i<4; i++){
2376                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2377                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2378                     }
2379                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb, 
2380                                  &dmin, &next_block, 0, 0);
2381                 }
2382                 if(mb_type&MB_TYPE_FORWARD){
2383                     s->mv_dir = MV_DIR_FORWARD;
2384                     s->mv_type = MV_TYPE_16X16;
2385                     s->mb_intra= 0;
2386                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2387                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2388                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb, 
2389                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2390                 }
2391                 if(mb_type&MB_TYPE_BACKWARD){
2392                     s->mv_dir = MV_DIR_BACKWARD;
2393                     s->mv_type = MV_TYPE_16X16;
2394                     s->mb_intra= 0;
2395                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2396                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2397                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
2398                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2399                 }
2400                 if(mb_type&MB_TYPE_BIDIR){
2401                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2402                     s->mv_type = MV_TYPE_16X16;
2403                     s->mb_intra= 0;
2404                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2405                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2406                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2407                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2408                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb, 
2409                                  &dmin, &next_block, 0, 0);
2410                 }
2411                 if(mb_type&MB_TYPE_DIRECT){
2412                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2413                     s->mv_type = MV_TYPE_16X16; //FIXME
2414                     s->mb_intra= 0;
2415                     s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2416                     s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2417                     s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2418                     s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2419                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 
2420                                  &dmin, &next_block, s->b_direct_mv_table[xy][0], s->b_direct_mv_table[xy][1]);
2421                 }
2422                 if(mb_type&MB_TYPE_INTRA){
2423                     s->mv_dir = MV_DIR_FORWARD;
2424                     s->mv_type = MV_TYPE_16X16;
2425                     s->mb_intra= 1;
2426                     s->mv[0][0][0] = 0;
2427                     s->mv[0][0][1] = 0;
2428                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb, 
2429                                  &dmin, &next_block, 0, 0);
2430                     /* force cleaning of ac/dc pred stuff if needed ... */
2431                     if(s->h263_pred || s->h263_aic)
2432                         s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
2433                 }
2434                 copy_context_after_encode(s, &best_s, -1);
2435                 
2436                 pb_bits_count= get_bit_count(&s->pb);
2437                 flush_put_bits(&s->pb);
2438                 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2439                 s->pb= backup_s.pb;
2440                 
2441                 if(s->data_partitioning){
2442                     pb2_bits_count= get_bit_count(&s->pb2);
2443                     flush_put_bits(&s->pb2);
2444                     ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2445                     s->pb2= backup_s.pb2;
2446                     
2447                     tex_pb_bits_count= get_bit_count(&s->tex_pb);
2448                     flush_put_bits(&s->tex_pb);
2449                     ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2450                     s->tex_pb= backup_s.tex_pb;
2451                 }
2452                 s->last_bits= get_bit_count(&s->pb);
2453             } else {
2454                 int motion_x, motion_y;
2455                 s->mv_type=MV_TYPE_16X16;
2456                 // only one MB-Type possible
2457                 switch(mb_type){
2458                 case MB_TYPE_INTRA:
2459                     s->mv_dir = MV_DIR_FORWARD;
2460                     s->mb_intra= 1;
2461                     motion_x= s->mv[0][0][0] = 0;
2462                     motion_y= s->mv[0][0][1] = 0;
2463                     break;
2464                 case MB_TYPE_INTER:
2465                     s->mv_dir = MV_DIR_FORWARD;
2466                     s->mb_intra= 0;
2467                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2468                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2469                     break;
2470                 case MB_TYPE_INTER4V:
2471                     s->mv_dir = MV_DIR_FORWARD;
2472                     s->mv_type = MV_TYPE_8X8;
2473                     s->mb_intra= 0;
2474                     for(i=0; i<4; i++){
2475                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2476                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2477                     }
2478                     motion_x= motion_y= 0;
2479                     break;
2480                 case MB_TYPE_DIRECT:
2481                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2482                     s->mb_intra= 0;
2483                     motion_x=s->b_direct_mv_table[xy][0];
2484                     motion_y=s->b_direct_mv_table[xy][1];
2485                     s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2486                     s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2487                     s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2488                     s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2489                     break;
2490                 case MB_TYPE_BIDIR:
2491                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2492                     s->mb_intra= 0;
2493                     motion_x=0;
2494                     motion_y=0;
2495                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2496                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2497                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2498                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2499                     break;
2500                 case MB_TYPE_BACKWARD:
2501                     s->mv_dir = MV_DIR_BACKWARD;
2502                     s->mb_intra= 0;
2503                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2504                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2505                     break;
2506                 case MB_TYPE_FORWARD:
2507                     s->mv_dir = MV_DIR_FORWARD;
2508                     s->mb_intra= 0;
2509                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2510                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2511 //                    printf(" %d %d ", motion_x, motion_y);
2512                     break;
2513                 default:
2514                     motion_x=motion_y=0; //gcc warning fix
2515                     printf("illegal MB type\n");
2516                 }
2517                 encode_mb(s, motion_x, motion_y);
2518             }
2519             /* clean the MV table in IPS frames for direct mode in B frames */
2520             if(s->mb_intra /* && I,P,S_TYPE */){
2521                 s->p_mv_table[xy][0]=0;
2522                 s->p_mv_table[xy][1]=0;
2523             }
2524
2525             MPV_decode_mb(s, s->block);
2526 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
2527         }
2528
2529
2530         /* Obtain average GOB size for RTP */
2531         if (s->rtp_mode) {
2532             if (!mb_y)
2533                 s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
2534             else if (!(mb_y % s->gob_index)) {    
2535                 s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
2536                 s->ptr_last_mb_line = pbBufPtr(&s->pb);
2537             }
2538             //fprintf(stderr, "\nMB line: %d\tSize: %u\tAvg. Size: %u", s->mb_y, 
2539             //                    (s->pb.buf_ptr - s->ptr_last_mb_line), s->mb_line_avgsize);
2540             if(s->codec_id!=CODEC_ID_MPEG4) s->first_slice_line = 0; //FIXME clean
2541         }
2542     }
2543     emms_c();
2544
2545     if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
2546         ff_mpeg4_merge_partitions(s);
2547
2548     if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
2549         msmpeg4_encode_ext_header(s);
2550
2551     if(s->codec_id==CODEC_ID_MPEG4) 
2552         ff_mpeg4_stuffing(&s->pb);
2553
2554     //if (s->gob_number)
2555     //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
2556     
2557     /* Send the last GOB if RTP */    
2558     if (s->rtp_mode) {
2559         flush_put_bits(&s->pb);
2560         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
2561         /* Call the RTP callback to send the last GOB */
2562         if (s->rtp_callback)
2563             s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
2564         s->ptr_lastgob = pbBufPtr(&s->pb);
2565         //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
2566     }
2567 }
2568
2569 static int dct_quantize_c(MpegEncContext *s, 
2570                         DCTELEM *block, int n,
2571                         int qscale, int *overflow)
2572 {
2573     int i, j, level, last_non_zero, q;
2574     const int *qmat;
2575     int bias;
2576     int max=0;
2577     unsigned int threshold1, threshold2;
2578     
2579     s->fdct (block);
2580
2581     /* we need this permutation so that we correct the IDCT
2582        permutation. will be moved into DCT code */
2583     block_permute(block);
2584
2585     if (s->mb_intra) {
2586         if (!s->h263_aic) {
2587             if (n < 4)
2588                 q = s->y_dc_scale;
2589             else
2590                 q = s->c_dc_scale;
2591             q = q << 3;
2592         } else
2593             /* For AIC we skip quant/dequant of INTRADC */
2594             q = 1 << 3;
2595             
2596         /* note: block[0] is assumed to be positive */
2597         block[0] = (block[0] + (q >> 1)) / q;
2598         i = 1;
2599         last_non_zero = 0;
2600         qmat = s->q_intra_matrix[qscale];
2601         bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
2602     } else {
2603         i = 0;
2604         last_non_zero = -1;
2605         qmat = s->q_inter_matrix[qscale];
2606         bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
2607     }
2608     threshold1= (1<<QMAT_SHIFT) - bias - 1;
2609     threshold2= (threshold1<<1);
2610
2611     for(;i<64;i++) {
2612         j = zigzag_direct[i];
2613         level = block[j];
2614         level = level * qmat[j];
2615
2616 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
2617 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
2618         if(((unsigned)(level+threshold1))>threshold2){
2619             if(level>0){
2620                 level= (bias + level)>>QMAT_SHIFT;
2621                 block[j]= level;
2622             }else{
2623                 level= (bias - level)>>QMAT_SHIFT;
2624                 block[j]= -level;
2625             }
2626             max |=level;
2627             last_non_zero = i;
2628         }else{
2629             block[j]=0;
2630         }
2631     }
2632     *overflow= s->max_qcoeff < max; //overflow might have happend
2633     
2634     return last_non_zero;
2635 }
2636
2637 static void dct_unquantize_mpeg1_c(MpegEncContext *s, 
2638                                    DCTELEM *block, int n, int qscale)
2639 {
2640     int i, level, nCoeffs;
2641     const UINT16 *quant_matrix;
2642
2643     if(s->alternate_scan) nCoeffs= 64;
2644     else nCoeffs= s->block_last_index[n]+1;
2645     
2646     if (s->mb_intra) {
2647         if (n < 4) 
2648             block[0] = block[0] * s->y_dc_scale;
2649         else
2650             block[0] = block[0] * s->c_dc_scale;
2651         /* XXX: only mpeg1 */
2652         quant_matrix = s->intra_matrix;
2653         for(i=1;i<nCoeffs;i++) {
2654             int j= zigzag_direct[i];
2655             level = block[j];
2656             if (level) {
2657                 if (level < 0) {
2658                     level = -level;
2659                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
2660                     level = (level - 1) | 1;
2661                     level = -level;
2662                 } else {
2663                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
2664                     level = (level - 1) | 1;
2665                 }
2666 #ifdef PARANOID
2667                 if (level < -2048 || level > 2047)
2668                     fprintf(stderr, "unquant error %d %d\n", i, level);
2669 #endif
2670                 block[j] = level;
2671             }
2672         }
2673     } else {
2674         i = 0;
2675         quant_matrix = s->inter_matrix;
2676         for(;i<nCoeffs;i++) {
2677             int j= zigzag_direct[i];
2678             level = block[j];
2679             if (level) {
2680                 if (level < 0) {
2681                     level = -level;
2682                     level = (((level << 1) + 1) * qscale *
2683                              ((int) (quant_matrix[j]))) >> 4;
2684                     level = (level - 1) | 1;
2685                     level = -level;
2686                 } else {
2687                     level = (((level << 1) + 1) * qscale *
2688                              ((int) (quant_matrix[j]))) >> 4;
2689                     level = (level - 1) | 1;
2690                 }
2691 #ifdef PARANOID
2692                 if (level < -2048 || level > 2047)
2693                     fprintf(stderr, "unquant error %d %d\n", i, level);
2694 #endif
2695                 block[j] = level;
2696             }
2697         }
2698     }
2699 }
2700
2701 static void dct_unquantize_mpeg2_c(MpegEncContext *s, 
2702                                    DCTELEM *block, int n, int qscale)
2703 {
2704     int i, level, nCoeffs;
2705     const UINT16 *quant_matrix;
2706
2707     if(s->alternate_scan) nCoeffs= 64;
2708     else nCoeffs= s->block_last_index[n]+1;
2709     
2710     if (s->mb_intra) {
2711         if (n < 4) 
2712             block[0] = block[0] * s->y_dc_scale;
2713         else
2714             block[0] = block[0] * s->c_dc_scale;
2715         quant_matrix = s->intra_matrix;
2716         for(i=1;i<nCoeffs;i++) {
2717             int j= zigzag_direct[i];
2718             level = block[j];
2719             if (level) {
2720                 if (level < 0) {
2721                     level = -level;
2722                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
2723                     level = -level;
2724                 } else {
2725                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
2726                 }
2727 #ifdef PARANOID
2728                 if (level < -2048 || level > 2047)
2729                     fprintf(stderr, "unquant error %d %d\n", i, level);
2730 #endif
2731                 block[j] = level;
2732             }
2733         }
2734     } else {
2735         int sum=-1;
2736         i = 0;
2737         quant_matrix = s->inter_matrix;
2738         for(;i<nCoeffs;i++) {
2739             int j= zigzag_direct[i];
2740             level = block[j];
2741             if (level) {
2742                 if (level < 0) {
2743                     level = -level;
2744                     level = (((level << 1) + 1) * qscale *
2745                              ((int) (quant_matrix[j]))) >> 4;
2746                     level = -level;
2747                 } else {
2748                     level = (((level << 1) + 1) * qscale *
2749                              ((int) (quant_matrix[j]))) >> 4;
2750                 }
2751 #ifdef PARANOID
2752                 if (level < -2048 || level > 2047)
2753                     fprintf(stderr, "unquant error %d %d\n", i, level);
2754 #endif
2755                 block[j] = level;
2756                 sum+=level;
2757             }
2758         }
2759         block[63]^=sum&1;
2760     }
2761 }
2762
2763
2764 static void dct_unquantize_h263_c(MpegEncContext *s, 
2765                                   DCTELEM *block, int n, int qscale)
2766 {
2767     int i, level, qmul, qadd;
2768     int nCoeffs;
2769     
2770     if (s->mb_intra) {
2771         if (!s->h263_aic) {
2772             if (n < 4) 
2773                 block[0] = block[0] * s->y_dc_scale;
2774             else
2775                 block[0] = block[0] * s->c_dc_scale;
2776         }
2777         i = 1;
2778         nCoeffs= 64; //does not allways use zigzag table 
2779     } else {
2780         i = 0;
2781         nCoeffs= zigzag_end[ s->block_last_index[n] ];
2782     }
2783
2784     qmul = s->qscale << 1;
2785     if (s->h263_aic && s->mb_intra)
2786         qadd = 0;
2787     else
2788         qadd = (s->qscale - 1) | 1;
2789
2790     for(;i<nCoeffs;i++) {
2791         level = block[i];
2792         if (level) {
2793             if (level < 0) {
2794                 level = level * qmul - qadd;
2795             } else {
2796                 level = level * qmul + qadd;
2797             }
2798 #ifdef PARANOID
2799                 if (level < -2048 || level > 2047)
2800                     fprintf(stderr, "unquant error %d %d\n", i, level);
2801 #endif
2802             block[i] = level;
2803         }
2804     }
2805 }
2806
2807 static void remove_ac(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y)
2808 {
2809     int dc, dcb, dcr, y, i;
2810     for(i=0; i<4; i++){
2811         dc= s->dc_val[0][mb_x*2+1 + (i&1) + (mb_y*2+1 + (i>>1))*(s->mb_width*2+2)];
2812         for(y=0; y<8; y++){
2813             int x;
2814             for(x=0; x<8; x++){
2815                 dest_y[x + (i&1)*8 + (y + (i>>1)*8)*s->linesize]= dc/8;
2816             }
2817         }
2818     }
2819     dcb = s->dc_val[1][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
2820     dcr= s->dc_val[2][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
2821     for(y=0; y<8; y++){
2822         int x;
2823         for(x=0; x<8; x++){
2824             dest_cb[x + y*(s->uvlinesize)]= dcb/8;
2825             dest_cr[x + y*(s->uvlinesize)]= dcr/8;
2826         }
2827     }
2828 }
2829
2830 /**
2831  * will conceal past errors, and allso drop b frames if needed
2832  *
2833  */
2834 void ff_conceal_past_errors(MpegEncContext *s, int unknown_pos)
2835 {
2836     int mb_x= s->mb_x;
2837     int mb_y= s->mb_y;
2838     int mb_dist=0;
2839     int i, intra_count=0, inter_count=0;
2840     int intra_conceal= s->msmpeg4_version ? 50 : 50; //FIXME finetune
2841     int inter_conceal= s->msmpeg4_version ? 50 : 50;
2842
2843     // for last block
2844     if(mb_x>=s->mb_width)  mb_x= s->mb_width -1;
2845     if(mb_y>=s->mb_height) mb_y= s->mb_height-1;
2846
2847     if(s->decoding_error==0 && unknown_pos){
2848         if(s->data_partitioning && s->pict_type!=B_TYPE)
2849                 s->decoding_error= DECODING_AC_LOST;
2850         else
2851                 s->decoding_error= DECODING_DESYNC;
2852     }
2853
2854     if(s->decoding_error==DECODING_DESYNC && s->pict_type!=B_TYPE) s->next_p_frame_damaged=1;
2855
2856     for(i=mb_x + mb_y*s->mb_width; i>=0; i--){
2857         if(s->mbintra_table[i]) intra_count++;
2858         else                    inter_count++;
2859     }
2860     
2861     if(s->decoding_error==DECODING_AC_LOST){
2862         intra_conceal*=2;
2863         inter_conceal*=2;
2864     }else if(s->decoding_error==DECODING_ACDC_LOST){
2865         intra_conceal*=2;
2866         inter_conceal*=2;
2867     }
2868
2869     if(unknown_pos && (intra_count<inter_count)){
2870         intra_conceal= inter_conceal= s->mb_num; 
2871 //        printf("%d %d\n",intra_count, inter_count);
2872     }
2873
2874     fprintf(stderr, "concealing errors\n");
2875
2876     /* for all MBs from the current one back until the last resync marker */
2877     for(; mb_y>=0 && mb_y>=s->resync_mb_y; mb_y--){
2878         for(; mb_x>=0; mb_x--){
2879             uint8_t *dest_y  = s->current_picture[0] + (mb_y * 16*  s->linesize      ) + mb_x * 16;
2880             uint8_t *dest_cb = s->current_picture[1] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
2881             uint8_t *dest_cr = s->current_picture[2] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
2882             int mb_x_backup= s->mb_x; //FIXME pass xy to mpeg_motion
2883             int mb_y_backup= s->mb_y;
2884             s->mb_x=mb_x;
2885             s->mb_y=mb_y;
2886             if(s->mbintra_table[mb_y*s->mb_width + mb_x] && mb_dist<intra_conceal){
2887                 if(s->decoding_error==DECODING_AC_LOST){
2888                     remove_ac(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
2889 //                    printf("remove ac to %d %d\n", mb_x, mb_y);
2890                 }else{
2891                     mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, 
2892                                 s->last_picture, 0, 0, put_pixels_tab,
2893                                 0/*mx*/, 0/*my*/, 16);
2894                 }
2895             }
2896             else if(!s->mbintra_table[mb_y*s->mb_width + mb_x] && mb_dist<inter_conceal){
2897                 int mx=0;
2898                 int my=0;
2899
2900                 if(s->decoding_error!=DECODING_DESYNC){
2901                     int xy= mb_x*2+1 + (mb_y*2+1)*(s->mb_width*2+2);
2902                     mx= s->motion_val[ xy ][0];
2903                     my= s->motion_val[ xy ][1];
2904                 }
2905
2906                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, 
2907                             s->last_picture, 0, 0, put_pixels_tab,
2908                             mx, my, 16);
2909             }
2910             s->mb_x= mb_x_backup;
2911             s->mb_y= mb_y_backup;
2912
2913             if(mb_x== s->resync_mb_x && mb_y== s->resync_mb_y) return;
2914             if(!s->mbskip_table[mb_x + mb_y*s->mb_width]) mb_dist++;
2915         }
2916         mb_x=s->mb_width-1;
2917     }
2918 }
2919
2920 AVCodec mpeg1video_encoder = {
2921     "mpeg1video",
2922     CODEC_TYPE_VIDEO,
2923     CODEC_ID_MPEG1VIDEO,
2924     sizeof(MpegEncContext),
2925     MPV_encode_init,
2926     MPV_encode_picture,
2927     MPV_encode_end,
2928 };
2929
2930 AVCodec h263_encoder = {
2931     "h263",
2932     CODEC_TYPE_VIDEO,
2933     CODEC_ID_H263,
2934     sizeof(MpegEncContext),
2935     MPV_encode_init,
2936     MPV_encode_picture,
2937     MPV_encode_end,
2938 };
2939
2940 AVCodec h263p_encoder = {
2941     "h263p",
2942     CODEC_TYPE_VIDEO,
2943     CODEC_ID_H263P,
2944     sizeof(MpegEncContext),
2945     MPV_encode_init,
2946     MPV_encode_picture,
2947     MPV_encode_end,
2948 };
2949
2950 AVCodec rv10_encoder = {
2951     "rv10",
2952     CODEC_TYPE_VIDEO,
2953     CODEC_ID_RV10,
2954     sizeof(MpegEncContext),
2955     MPV_encode_init,
2956     MPV_encode_picture,
2957     MPV_encode_end,
2958 };
2959
2960 AVCodec mjpeg_encoder = {
2961     "mjpeg",
2962     CODEC_TYPE_VIDEO,
2963     CODEC_ID_MJPEG,
2964     sizeof(MpegEncContext),
2965     MPV_encode_init,
2966     MPV_encode_picture,
2967     MPV_encode_end,
2968 };
2969
2970 AVCodec mpeg4_encoder = {
2971     "mpeg4",
2972     CODEC_TYPE_VIDEO,
2973     CODEC_ID_MPEG4,
2974     sizeof(MpegEncContext),
2975     MPV_encode_init,
2976     MPV_encode_picture,
2977     MPV_encode_end,
2978 };
2979
2980 AVCodec msmpeg4v1_encoder = {
2981     "msmpeg4v1",
2982     CODEC_TYPE_VIDEO,
2983     CODEC_ID_MSMPEG4V1,
2984     sizeof(MpegEncContext),
2985     MPV_encode_init,
2986     MPV_encode_picture,
2987     MPV_encode_end,
2988 };
2989
2990 AVCodec msmpeg4v2_encoder = {
2991     "msmpeg4v2",
2992     CODEC_TYPE_VIDEO,
2993     CODEC_ID_MSMPEG4V2,
2994     sizeof(MpegEncContext),
2995     MPV_encode_init,
2996     MPV_encode_picture,
2997     MPV_encode_end,
2998 };
2999
3000 AVCodec msmpeg4v3_encoder = {
3001     "msmpeg4",
3002     CODEC_TYPE_VIDEO,
3003     CODEC_ID_MSMPEG4V3,
3004     sizeof(MpegEncContext),
3005     MPV_encode_init,
3006     MPV_encode_picture,
3007     MPV_encode_end,
3008 };
3009
3010 AVCodec wmv1_encoder = {
3011     "wmv1",
3012     CODEC_TYPE_VIDEO,
3013     CODEC_ID_WMV1,
3014     sizeof(MpegEncContext),
3015     MPV_encode_init,
3016     MPV_encode_picture,
3017     MPV_encode_end,
3018 };
3019
3020 AVCodec wmv2_encoder = {
3021     "wmv2",
3022     CODEC_TYPE_VIDEO,
3023     CODEC_ID_WMV2,
3024     sizeof(MpegEncContext),
3025     MPV_encode_init,
3026     MPV_encode_picture,
3027     MPV_encode_end,
3028 };