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