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