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