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