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