git.sesse.net Git - ffmpeg/blob - 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 /**
  23  * @file mpegvideo.c
  24  * The simplest mpeg encoder (well, it was the simplest!).
  25  */
  26
  27 #include <ctype.h>
  28 #include <limits.h>
  29 #include "avcodec.h"
  30 #include "dsputil.h"
  31 #include "mpegvideo.h"
  32
  33 #ifdef USE_FASTMEMCPY
  34 #include "fastmemcpy.h"
  35 #endif
  36
  37 //#undef NDEBUG
  38 //#include <assert.h>
  39
  40 #ifdef CONFIG_ENCODERS
  41 static void encode_picture(MpegEncContext *s, int picture_number);
  42 #endif //CONFIG_ENCODERS
  43 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
  44                                    DCTELEM *block, int n, int qscale);
  45 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
  46                                    DCTELEM *block, int n, int qscale);
  47 static void dct_unquantize_h263_c(MpegEncContext *s,
  48                                   DCTELEM *block, int n, int qscale);
  49 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
  50 #ifdef CONFIG_ENCODERS
  51 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
  52 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
  53 #endif //CONFIG_ENCODERS
  54
  55 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
  56
  57
  58 /* enable all paranoid tests for rounding, overflows, etc... */
  59 //#define PARANOID
  60
  61 //#define DEBUG
  62
  63
  64 /* for jpeg fast DCT */
  65 #define CONST_BITS 14
  66
  67 static const uint16_t aanscales[64] = {
  68     /* precomputed values scaled up by 14 bits */
  69     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  70     22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
  71     21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
  72     19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
  73     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  74     12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
  75     8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
  76     4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
  77 };
  78
  79 static const uint8_t h263_chroma_roundtab[16] = {
  80 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  81     0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
  82 };
  83
  84 #ifdef CONFIG_ENCODERS
  85 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
  86 static uint8_t default_fcode_tab[MAX_MV*2+1];
  87
  88 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
  89
  90 static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
  91                            const uint16_t *quant_matrix, int bias, int qmin, int qmax)
  92 {
  93     int qscale;
  94
  95     for(qscale=qmin; qscale<=qmax; qscale++){
  96         int i;
  97         if (s->dsp.fdct == ff_jpeg_fdct_islow) {
  98             for(i=0;i<64;i++) {
  99                 const int j= s->dsp.idct_permutation[i];
 100                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
 101                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
 102                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
 103                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
 104
 105                 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
 106                                 (qscale * quant_matrix[j]));
 107             }
 108         } else if (s->dsp.fdct == fdct_ifast) {
 109             for(i=0;i<64;i++) {
 110                 const int j= s->dsp.idct_permutation[i];
 111                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
 112                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
 113                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
 114                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
 115
 116                 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
 117                                 (aanscales[i] * qscale * quant_matrix[j]));
 118             }
 119         } else {
 120             for(i=0;i<64;i++) {
 121                 const int j= s->dsp.idct_permutation[i];
 122                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
 123                    So 16           <= qscale * quant_matrix[i]             <= 7905
 124                    so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
 125                    so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
 126                 */
 127                 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
 128 //                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
 129                 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
 130
 131                 if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
 132                 qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
 133             }
 134         }
 135     }
 136 }
 137 #endif //CONFIG_ENCODERS
 138
 139 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
 140     int i;
 141     int end;
 142
 143     st->scantable= src_scantable;
 144
 145     for(i=0; i<64; i++){
 146         int j;
 147         j = src_scantable[i];
 148         st->permutated[i] = permutation[j];
 149 #ifdef ARCH_POWERPC
 150         st->inverse[j] = i;
 151 #endif
 152     }
 153
 154     end=-1;
 155     for(i=0; i<64; i++){
 156         int j;
 157         j = st->permutated[i];
 158         if(j>end) end=j;
 159         st->raster_end[i]= end;
 160     }
 161 }
 162
 163 /* init common dct for both encoder and decoder */
 164 int DCT_common_init(MpegEncContext *s)
 165 {
 166     s->dct_unquantize_h263 = dct_unquantize_h263_c;
 167     s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
 168     s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
 169
 170 #ifdef CONFIG_ENCODERS
 171     s->dct_quantize= dct_quantize_c;
 172 #endif
 173
 174 #ifdef HAVE_MMX
 175     MPV_common_init_mmx(s);
 176 #endif
 177 #ifdef ARCH_ALPHA
 178     MPV_common_init_axp(s);
 179 #endif
 180 #ifdef HAVE_MLIB
 181     MPV_common_init_mlib(s);
 182 #endif
 183 #ifdef HAVE_MMI
 184     MPV_common_init_mmi(s);
 185 #endif
 186 #ifdef ARCH_ARMV4L
 187     MPV_common_init_armv4l(s);
 188 #endif
 189 #ifdef ARCH_POWERPC
 190     MPV_common_init_ppc(s);
 191 #endif
 192
 193 #ifdef CONFIG_ENCODERS
 194     s->fast_dct_quantize= s->dct_quantize;
 195
 196     if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
 197         s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
 198     }
 199
 200 #endif //CONFIG_ENCODERS
 201
 202     /* load & permutate scantables
 203        note: only wmv uses differnt ones
 204     */
 205     ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
 206     ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
 207     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
 208     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
 209
 210     s->picture_structure= PICT_FRAME;
 211
 212     return 0;
 213 }
 214
 215 /**
 216  * allocates a Picture
 217  * The pixels are allocated/set by calling get_buffer() if shared=0
 218  */
 219 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
 220     const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
 221     const int mb_array_size= s->mb_stride*s->mb_height;
 222     int i;
 223
 224     if(shared){
 225         assert(pic->data[0]);
 226         assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
 227         pic->type= FF_BUFFER_TYPE_SHARED;
 228     }else{
 229         int r;
 230
 231         assert(!pic->data[0]);
 232
 233         r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
 234
 235         if(r<0 || !pic->age || !pic->type || !pic->data[0]){
 236             fprintf(stderr, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
 237             return -1;
 238         }
 239
 240         if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
 241             fprintf(stderr, "get_buffer() failed (stride changed)\n");
 242             return -1;
 243         }
 244
 245         if(pic->linesize[1] != pic->linesize[2]){
 246             fprintf(stderr, "get_buffer() failed (uv stride missmatch)\n");
 247             return -1;
 248         }
 249
 250         s->linesize  = pic->linesize[0];
 251         s->uvlinesize= pic->linesize[1];
 252     }
 253
 254     if(pic->qscale_table==NULL){
 255         if (s->encoding) {
 256             CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
 257             CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
 258             CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
 259             CHECKED_ALLOCZ(pic->mb_cmp_score, mb_array_size * sizeof(int32_t))
 260         }
 261
 262         CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
 263         CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
 264         CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(int))
 265         pic->mb_type= pic->mb_type_base + s->mb_stride+1;
 266         if(s->out_format == FMT_H264){
 267             for(i=0; i<2; i++){
 268                 CHECKED_ALLOCZ(pic->motion_val[i], 2 * 16 * s->mb_num * sizeof(uint16_t))
 269                 CHECKED_ALLOCZ(pic->ref_index[i] , 4 * s->mb_num * sizeof(uint8_t))
 270             }
 271         }
 272         pic->qstride= s->mb_stride;
 273     }
 274
 275     //it might be nicer if the application would keep track of these but it would require a API change
 276     memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
 277     s->prev_pict_types[0]= s->pict_type;
 278     if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
 279         pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
 280
 281     return 0;
 282 fail: //for the CHECKED_ALLOCZ macro
 283     return -1;
 284 }
 285
 286 /**
 287  * deallocates a picture
 288  */
 289 static void free_picture(MpegEncContext *s, Picture *pic){
 290     int i;
 291
 292     if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
 293         s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
 294     }
 295
 296     av_freep(&pic->mb_var);
 297     av_freep(&pic->mc_mb_var);
 298     av_freep(&pic->mb_mean);
 299     av_freep(&pic->mb_cmp_score);
 300     av_freep(&pic->mbskip_table);
 301     av_freep(&pic->qscale_table);
 302     av_freep(&pic->mb_type_base);
 303     pic->mb_type= NULL;
 304     for(i=0; i<2; i++){
 305         av_freep(&pic->motion_val[i]);
 306         av_freep(&pic->ref_index[i]);
 307     }
 308
 309     if(pic->type == FF_BUFFER_TYPE_SHARED){
 310         for(i=0; i<4; i++){
 311             pic->base[i]=
 312             pic->data[i]= NULL;
 313         }
 314         pic->type= 0;
 315     }
 316 }
 317
 318 /* init common structure for both encoder and decoder */
 319 int MPV_common_init(MpegEncContext *s)
 320 {
 321     int y_size, c_size, yc_size, i, mb_array_size, x, y;
 322
 323     dsputil_init(&s->dsp, s->avctx);
 324     DCT_common_init(s);
 325
 326     s->flags= s->avctx->flags;
 327
 328     s->mb_width  = (s->width  + 15) / 16;
 329     s->mb_height = (s->height + 15) / 16;
 330     s->mb_stride = s->mb_width + 1;
 331     mb_array_size= s->mb_height * s->mb_stride;
 332
 333     /* set default edge pos, will be overriden in decode_header if needed */
 334     s->h_edge_pos= s->mb_width*16;
 335     s->v_edge_pos= s->mb_height*16;
 336
 337     s->mb_num = s->mb_width * s->mb_height;
 338
 339     s->block_wrap[0]=
 340     s->block_wrap[1]=
 341     s->block_wrap[2]=
 342     s->block_wrap[3]= s->mb_width*2 + 2;
 343     s->block_wrap[4]=
 344     s->block_wrap[5]= s->mb_width + 2;
 345
 346     y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
 347     c_size = (s->mb_width + 2) * (s->mb_height + 2);
 348     yc_size = y_size + 2 * c_size;
 349
 350     /* convert fourcc to upper case */
 351     s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)
 352                         + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
 353                         + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
 354                         + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
 355
 356     CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
 357     s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
 358
 359     s->avctx->coded_frame= (AVFrame*)&s->current_picture;
 360
 361     CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
 362     for(y=0; y<s->mb_height; y++){
 363         for(x=0; x<s->mb_width; x++){
 364             s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
 365         }
 366     }
 367     s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
 368
 369     if (s->encoding) {
 370         int mv_table_size= s->mb_stride * (s->mb_height+2) + 1;
 371
 372         /* Allocate MV tables */
 373         CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
 374         CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
 375         CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
 376         CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
 377         CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
 378         CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
 379         s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
 380         s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
 381         s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
 382         s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
 383         s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
 384         s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
 385
 386         //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
 387         CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t))
 388
 389         CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
 390         CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
 391
 392         if(s->codec_id==CODEC_ID_MPEG4){
 393             CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
 394             CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
 395         }
 396
 397         if(s->msmpeg4_version){
 398             CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
 399         }
 400         CHECKED_ALLOCZ(s->avctx->stats_out, 256);
 401
 402         /* Allocate MB type table */
 403         CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint8_t)) //needed for encoding
 404     }
 405
 406     CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
 407
 408     if (s->out_format == FMT_H263 || s->encoding) {
 409         int size;
 410
 411         /* MV prediction */
 412         size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
 413         CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(int16_t));
 414     }
 415
 416     if(s->codec_id==CODEC_ID_MPEG4){
 417         /* interlaced direct mode decoding tables */
 418         CHECKED_ALLOCZ(s->field_mv_table, mb_array_size*2*2 * sizeof(int16_t))
 419         CHECKED_ALLOCZ(s->field_select_table, mb_array_size*2* sizeof(int8_t))
 420     }
 421     if (s->out_format == FMT_H263) {
 422         /* ac values */
 423         CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
 424         s->ac_val[1] = s->ac_val[0] + y_size;
 425         s->ac_val[2] = s->ac_val[1] + c_size;
 426
 427         /* cbp values */
 428         CHECKED_ALLOCZ(s->coded_block, y_size);
 429
 430         /* divx501 bitstream reorder buffer */
 431         CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
 432
 433         /* cbp, ac_pred, pred_dir */
 434         CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
 435         CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
 436     }
 437
 438     if (s->h263_pred || s->h263_plus || !s->encoding) {
 439         /* dc values */
 440         //MN: we need these for error resilience of intra-frames
 441         CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
 442         s->dc_val[1] = s->dc_val[0] + y_size;
 443         s->dc_val[2] = s->dc_val[1] + c_size;
 444         for(i=0;i<yc_size;i++)
 445             s->dc_val[0][i] = 1024;
 446     }
 447
 448     /* which mb is a intra block */
 449     CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
 450     memset(s->mbintra_table, 1, mb_array_size);
 451
 452     /* default structure is frame */
 453     s->picture_structure = PICT_FRAME;
 454
 455     /* init macroblock skip table */
 456     CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
 457     //Note the +1 is for a quicker mpeg4 slice_end detection
 458     CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
 459
 460     s->block= s->blocks[0];
 461
 462     s->parse_context.state= -1;
 463
 464     s->context_initialized = 1;
 465     return 0;
 466  fail:
 467     MPV_common_end(s);
 468     return -1;
 469 }
 470
 471
 472 //extern int sads;
 473
 474 /* init common structure for both encoder and decoder */
 475 void MPV_common_end(MpegEncContext *s)
 476 {
 477     int i;
 478
 479     av_freep(&s->mb_type);
 480     av_freep(&s->p_mv_table_base);
 481     av_freep(&s->b_forw_mv_table_base);
 482     av_freep(&s->b_back_mv_table_base);
 483     av_freep(&s->b_bidir_forw_mv_table_base);
 484     av_freep(&s->b_bidir_back_mv_table_base);
 485     av_freep(&s->b_direct_mv_table_base);
 486     s->p_mv_table= NULL;
 487     s->b_forw_mv_table= NULL;
 488     s->b_back_mv_table= NULL;
 489     s->b_bidir_forw_mv_table= NULL;
 490     s->b_bidir_back_mv_table= NULL;
 491     s->b_direct_mv_table= NULL;
 492
 493     av_freep(&s->motion_val);
 494     av_freep(&s->dc_val[0]);
 495     av_freep(&s->ac_val[0]);
 496     av_freep(&s->coded_block);
 497     av_freep(&s->mbintra_table);
 498     av_freep(&s->cbp_table);
 499     av_freep(&s->pred_dir_table);
 500     av_freep(&s->me.scratchpad);
 501     av_freep(&s->me.map);
 502     av_freep(&s->me.score_map);
 503
 504     av_freep(&s->mbskip_table);
 505     av_freep(&s->prev_pict_types);
 506     av_freep(&s->bitstream_buffer);
 507     av_freep(&s->tex_pb_buffer);
 508     av_freep(&s->pb2_buffer);
 509     av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
 510     av_freep(&s->field_mv_table);
 511     av_freep(&s->field_select_table);
 512     av_freep(&s->avctx->stats_out);
 513     av_freep(&s->ac_stats);
 514     av_freep(&s->error_status_table);
 515     av_freep(&s->mb_index2xy);
 516
 517     for(i=0; i<MAX_PICTURE_COUNT; i++){
 518         free_picture(s, &s->picture[i]);
 519     }
 520     avcodec_default_free_buffers(s->avctx);
 521     s->context_initialized = 0;
 522 }
 523
 524 #ifdef CONFIG_ENCODERS
 525
 526 /* init video encoder */
 527 int MPV_encode_init(AVCodecContext *avctx)
 528 {
 529     MpegEncContext *s = avctx->priv_data;
 530     int i;
 531
 532     avctx->pix_fmt = PIX_FMT_YUV420P;
 533
 534     s->bit_rate = avctx->bit_rate;
 535     s->bit_rate_tolerance = avctx->bit_rate_tolerance;
 536     s->width = avctx->width;
 537     s->height = avctx->height;
 538     if(avctx->gop_size > 600){
 539         fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
 540         avctx->gop_size=600;
 541     }
 542     s->gop_size = avctx->gop_size;
 543     s->rtp_mode = avctx->rtp_mode;
 544     s->rtp_payload_size = avctx->rtp_payload_size;
 545     if (avctx->rtp_callback)
 546         s->rtp_callback = avctx->rtp_callback;
 547     s->max_qdiff= avctx->max_qdiff;
 548     s->qcompress= avctx->qcompress;
 549     s->qblur= avctx->qblur;
 550     s->avctx = avctx;
 551     s->flags= avctx->flags;
 552     s->max_b_frames= avctx->max_b_frames;
 553     s->b_frame_strategy= avctx->b_frame_strategy;
 554     s->codec_id= avctx->codec->id;
 555     s->luma_elim_threshold  = avctx->luma_elim_threshold;
 556     s->chroma_elim_threshold= avctx->chroma_elim_threshold;
 557     s->strict_std_compliance= avctx->strict_std_compliance;
 558     s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
 559     s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
 560     s->mpeg_quant= avctx->mpeg_quant;
 561
 562     if (s->gop_size <= 1) {
 563         s->intra_only = 1;
 564         s->gop_size = 12;
 565     } else {
 566         s->intra_only = 0;
 567     }
 568
 569     s->me_method = avctx->me_method;
 570
 571     /* Fixed QSCALE */
 572     s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
 573
 574     s->adaptive_quant= (   s->avctx->lumi_masking
 575                         || s->avctx->dark_masking
 576                         || s->avctx->temporal_cplx_masking
 577                         || s->avctx->spatial_cplx_masking
 578                         || s->avctx->p_masking)
 579                        && !s->fixed_qscale;
 580
 581     s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
 582
 583     if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4){
 584         fprintf(stderr, "4MV not supporetd by codec\n");
 585         return -1;
 586     }
 587
 588     if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
 589         fprintf(stderr, "qpel not supporetd by codec\n");
 590         return -1;
 591     }
 592
 593     if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
 594         fprintf(stderr, "data partitioning not supporetd by codec\n");
 595         return -1;
 596     }
 597
 598     if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO){
 599         fprintf(stderr, "b frames not supporetd by codec\n");
 600         return -1;
 601     }
 602
 603     if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
 604         fprintf(stderr, "mpeg2 style quantization not supporetd by codec\n");
 605         return -1;
 606     }
 607
 608     if(s->codec_id==CODEC_ID_MJPEG){
 609         s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
 610         s->inter_quant_bias= 0;
 611     }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO){
 612         s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
 613         s->inter_quant_bias= 0;
 614     }else{
 615         s->intra_quant_bias=0;
 616         s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
 617     }
 618
 619     if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
 620         s->intra_quant_bias= avctx->intra_quant_bias;
 621     if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
 622         s->inter_quant_bias= avctx->inter_quant_bias;
 623
 624     switch(avctx->codec->id) {
 625     case CODEC_ID_MPEG1VIDEO:
 626         s->out_format = FMT_MPEG1;
 627         s->low_delay= 0; //s->max_b_frames ? 0 : 1;
 628         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
 629         break;
 630     case CODEC_ID_MJPEG:
 631         s->out_format = FMT_MJPEG;
 632         s->intra_only = 1; /* force intra only for jpeg */
 633         s->mjpeg_write_tables = 1; /* write all tables */
 634         s->mjpeg_data_only_frames = 0; /* write all the needed headers */
 635         s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
 636         s->mjpeg_vsample[1] = 1; /* the only currently supported values */
 637         s->mjpeg_vsample[2] = 1;
 638         s->mjpeg_hsample[0] = 2;
 639         s->mjpeg_hsample[1] = 1;
 640         s->mjpeg_hsample[2] = 1;
 641         if (mjpeg_init(s) < 0)
 642             return -1;
 643         avctx->delay=0;
 644         s->low_delay=1;
 645         break;
 646 #ifdef CONFIG_RISKY
 647     case CODEC_ID_H263:
 648         if (h263_get_picture_format(s->width, s->height) == 7) {
 649             printf("Input picture size isn't suitable for h263 codec! try h263+\n");
 650             return -1;
 651         }
 652         s->out_format = FMT_H263;
 653         avctx->delay=0;
 654         s->low_delay=1;
 655         break;
 656     case CODEC_ID_H263P:
 657         s->out_format = FMT_H263;
 658         s->h263_plus = 1;
 659         /* Fx */
 660         s->unrestricted_mv=(avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
 661         s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
 662         /* /Fx */
 663         /* These are just to be sure */
 664         s->umvplus = 1;
 665         avctx->delay=0;
 666         s->low_delay=1;
 667         break;
 668     case CODEC_ID_RV10:
 669         s->out_format = FMT_H263;
 670         s->h263_rv10 = 1;
 671         avctx->delay=0;
 672         s->low_delay=1;
 673         break;
 674     case CODEC_ID_MPEG4:
 675         s->out_format = FMT_H263;
 676         s->h263_pred = 1;
 677         s->unrestricted_mv = 1;
 678         s->low_delay= s->max_b_frames ? 0 : 1;
 679         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
 680         break;
 681     case CODEC_ID_MSMPEG4V1:
 682         s->out_format = FMT_H263;
 683         s->h263_msmpeg4 = 1;
 684         s->h263_pred = 1;
 685         s->unrestricted_mv = 1;
 686         s->msmpeg4_version= 1;
 687         avctx->delay=0;
 688         s->low_delay=1;
 689         break;
 690     case CODEC_ID_MSMPEG4V2:
 691         s->out_format = FMT_H263;
 692         s->h263_msmpeg4 = 1;
 693         s->h263_pred = 1;
 694         s->unrestricted_mv = 1;
 695         s->msmpeg4_version= 2;
 696         avctx->delay=0;
 697         s->low_delay=1;
 698         break;
 699     case CODEC_ID_MSMPEG4V3:
 700         s->out_format = FMT_H263;
 701         s->h263_msmpeg4 = 1;
 702         s->h263_pred = 1;
 703         s->unrestricted_mv = 1;
 704         s->msmpeg4_version= 3;
 705         s->flipflop_rounding=1;
 706         avctx->delay=0;
 707         s->low_delay=1;
 708         break;
 709     case CODEC_ID_WMV1:
 710         s->out_format = FMT_H263;
 711         s->h263_msmpeg4 = 1;
 712         s->h263_pred = 1;
 713         s->unrestricted_mv = 1;
 714         s->msmpeg4_version= 4;
 715         s->flipflop_rounding=1;
 716         avctx->delay=0;
 717         s->low_delay=1;
 718         break;
 719     case CODEC_ID_WMV2:
 720         s->out_format = FMT_H263;
 721         s->h263_msmpeg4 = 1;
 722         s->h263_pred = 1;
 723         s->unrestricted_mv = 1;
 724         s->msmpeg4_version= 5;
 725         s->flipflop_rounding=1;
 726         avctx->delay=0;
 727         s->low_delay=1;
 728         break;
 729 #endif
 730     default:
 731         return -1;
 732     }
 733
 734     { /* set up some save defaults, some codecs might override them later */
 735         static int done=0;
 736         if(!done){
 737             int i;
 738             done=1;
 739
 740             default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
 741             memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
 742             memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
 743
 744             for(i=-16; i<16; i++){
 745                 default_fcode_tab[i + MAX_MV]= 1;
 746             }
 747         }
 748     }
 749     s->me.mv_penalty= default_mv_penalty;
 750     s->fcode_tab= default_fcode_tab;
 751     s->y_dc_scale_table=
 752     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 753
 754     /* dont use mv_penalty table for crap MV as it would be confused */
 755     //FIXME remove after fixing / removing old ME
 756     if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
 757
 758     s->encoding = 1;
 759
 760     /* init */
 761     if (MPV_common_init(s) < 0)
 762         return -1;
 763
 764     ff_init_me(s);
 765
 766 #ifdef CONFIG_ENCODERS
 767 #ifdef CONFIG_RISKY
 768     if (s->out_format == FMT_H263)
 769         h263_encode_init(s);
 770     if(s->msmpeg4_version)
 771         ff_msmpeg4_encode_init(s);
 772 #endif
 773     if (s->out_format == FMT_MPEG1)
 774         ff_mpeg1_encode_init(s);
 775 #endif
 776
 777     /* init default q matrix */
 778     for(i=0;i<64;i++) {
 779         int j= s->dsp.idct_permutation[i];
 780 #ifdef CONFIG_RISKY
 781         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
 782             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
 783             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
 784         }else if(s->out_format == FMT_H263){
 785             s->intra_matrix[j] =
 786             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
 787         }else
 788 #endif
 789         { /* mpeg1 */
 790             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
 791             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
 792         }
 793     }
 794
 795     /* precompute matrix */
 796     /* for mjpeg, we do include qscale in the matrix */
 797     if (s->out_format != FMT_MJPEG) {
 798         convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias,
 799                        s->intra_matrix, s->intra_quant_bias, 1, 31);
 800         convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias,
 801                        s->inter_matrix, s->inter_quant_bias, 1, 31);
 802     }
 803
 804     if(ff_rate_control_init(s) < 0)
 805         return -1;
 806
 807     s->picture_number = 0;
 808     s->picture_in_gop_number = 0;
 809     s->fake_picture_number = 0;
 810     /* motion detector init */
 811     s->f_code = 1;
 812     s->b_code = 1;
 813
 814     return 0;
 815 }
 816
 817 int MPV_encode_end(AVCodecContext *avctx)
 818 {
 819     MpegEncContext *s = avctx->priv_data;
 820
 821 #ifdef STATS
 822     print_stats();
 823 #endif
 824
 825     ff_rate_control_uninit(s);
 826
 827     MPV_common_end(s);
 828     if (s->out_format == FMT_MJPEG)
 829         mjpeg_close(s);
 830
 831     return 0;
 832 }
 833
 834 #endif //CONFIG_ENCODERS
 835
 836 void init_rl(RLTable *rl)
 837 {
 838     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
 839     uint8_t index_run[MAX_RUN+1];
 840     int last, run, level, start, end, i;
 841
 842     /* compute max_level[], max_run[] and index_run[] */
 843     for(last=0;last<2;last++) {
 844         if (last == 0) {
 845             start = 0;
 846             end = rl->last;
 847         } else {
 848             start = rl->last;
 849             end = rl->n;
 850         }
 851
 852         memset(max_level, 0, MAX_RUN + 1);
 853         memset(max_run, 0, MAX_LEVEL + 1);
 854         memset(index_run, rl->n, MAX_RUN + 1);
 855         for(i=start;i<end;i++) {
 856             run = rl->table_run[i];
 857             level = rl->table_level[i];
 858             if (index_run[run] == rl->n)
 859                 index_run[run] = i;
 860             if (level > max_level[run])
 861                 max_level[run] = level;
 862             if (run > max_run[level])
 863                 max_run[level] = run;
 864         }
 865         rl->max_level[last] = av_malloc(MAX_RUN + 1);
 866         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
 867         rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
 868         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
 869         rl->index_run[last] = av_malloc(MAX_RUN + 1);
 870         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
 871     }
 872 }
 873
 874 /* draw the edges of width 'w' of an image of size width, height */
 875 //FIXME check that this is ok for mpeg4 interlaced
 876 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
 877 {
 878     uint8_t *ptr, *last_line;
 879     int i;
 880
 881     last_line = buf + (height - 1) * wrap;
 882     for(i=0;i<w;i++) {
 883         /* top and bottom */
 884         memcpy(buf - (i + 1) * wrap, buf, width);
 885         memcpy(last_line + (i + 1) * wrap, last_line, width);
 886     }
 887     /* left and right */
 888     ptr = buf;
 889     for(i=0;i<height;i++) {
 890         memset(ptr - w, ptr[0], w);
 891         memset(ptr + width, ptr[width-1], w);
 892         ptr += wrap;
 893     }
 894     /* corners */
 895     for(i=0;i<w;i++) {
 896         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
 897         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
 898         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
 899         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
 900     }
 901 }
 902
 903 static int find_unused_picture(MpegEncContext *s, int shared){
 904     int i;
 905
 906     if(shared){
 907         for(i=0; i<MAX_PICTURE_COUNT; i++){
 908             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
 909         }
 910     }else{
 911         for(i=0; i<MAX_PICTURE_COUNT; i++){
 912             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break; //FIXME
 913         }
 914         for(i=0; i<MAX_PICTURE_COUNT; i++){
 915             if(s->picture[i].data[0]==NULL) break;
 916         }
 917     }
 918
 919     assert(i<MAX_PICTURE_COUNT);
 920     return i;
 921 }
 922
 923 /* generic function for encode/decode called before a frame is coded/decoded */
 924 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
 925 {
 926     int i;
 927     AVFrame *pic;
 928
 929     s->mb_skiped = 0;
 930
 931     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
 932
 933     /* mark&release old frames */
 934     if (s->pict_type != B_TYPE && s->last_picture_ptr) {
 935         avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
 936
 937         /* release forgotten pictures */
 938         /* if(mpeg124/h263) */
 939         if(!s->encoding){
 940             for(i=0; i<MAX_PICTURE_COUNT; i++){
 941                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
 942                     fprintf(stderr, "releasing zombie picture\n");
 943                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
 944                 }
 945             }
 946         }
 947     }
 948 alloc:
 949     if(!s->encoding){
 950         /* release non refernce frames */
 951         for(i=0; i<MAX_PICTURE_COUNT; i++){
 952             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
 953                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
 954             }
 955         }
 956
 957         i= find_unused_picture(s, 0);
 958
 959         pic= (AVFrame*)&s->picture[i];
 960         pic->reference= s->pict_type != B_TYPE ? 3 : 0;
 961
 962         if(s->current_picture_ptr)
 963             pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
 964
 965         alloc_picture(s, (Picture*)pic, 0);
 966
 967         s->current_picture_ptr= &s->picture[i];
 968     }
 969
 970     s->current_picture_ptr->pict_type= s->pict_type;
 971     s->current_picture_ptr->quality= s->qscale;
 972     s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
 973
 974     s->current_picture= *s->current_picture_ptr;
 975
 976   if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
 977     if (s->pict_type != B_TYPE) {
 978         s->last_picture_ptr= s->next_picture_ptr;
 979         s->next_picture_ptr= s->current_picture_ptr;
 980     }
 981
 982     if(s->last_picture_ptr) s->last_picture= *s->last_picture_ptr;
 983     if(s->next_picture_ptr) s->next_picture= *s->next_picture_ptr;
 984     if(s->new_picture_ptr ) s->new_picture = *s->new_picture_ptr;
 985
 986     if(s->picture_structure!=PICT_FRAME){
 987         int i;
 988         for(i=0; i<4; i++){
 989             if(s->picture_structure == PICT_BOTTOM_FIELD){
 990                  s->current_picture.data[i] += s->current_picture.linesize[i];
 991             }
 992             s->current_picture.linesize[i] *= 2;
 993             s->last_picture.linesize[i] *=2;
 994             s->next_picture.linesize[i] *=2;
 995         }
 996     }
 997
 998     if(s->pict_type != I_TYPE && s->last_picture_ptr==NULL){
 999         fprintf(stderr, "warning: first frame is no keyframe\n");
1000         assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1001         goto alloc;
1002     }
1003   }
1004
1005     s->hurry_up= s->avctx->hurry_up;
1006     s->error_resilience= avctx->error_resilience;
1007
1008     /* set dequantizer, we cant do it during init as it might change for mpeg4
1009        and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1010     if(s->out_format == FMT_H263){
1011         if(s->mpeg_quant)
1012             s->dct_unquantize = s->dct_unquantize_mpeg2;
1013         else
1014             s->dct_unquantize = s->dct_unquantize_h263;
1015     }else
1016         s->dct_unquantize = s->dct_unquantize_mpeg1;
1017
1018     return 0;
1019 }
1020
1021 /* generic function for encode/decode called after a frame has been coded/decoded */
1022 void MPV_frame_end(MpegEncContext *s)
1023 {
1024     int i;
1025     /* draw edge for correct motion prediction if outside */
1026     if(s->codec_id!=CODEC_ID_SVQ1){
1027         if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1028             draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1029             draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1030             draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1031         }
1032     }
1033     emms_c();
1034
1035     s->last_pict_type    = s->pict_type;
1036     if(s->pict_type!=B_TYPE){
1037         s->last_non_b_pict_type= s->pict_type;
1038     }
1039 #if 0
1040         /* copy back current_picture variables */
1041     for(i=0; i<MAX_PICTURE_COUNT; i++){
1042         if(s->picture[i].data[0] == s->current_picture.data[0]){
1043             s->picture[i]= s->current_picture;
1044             break;
1045         }
1046     }
1047     assert(i<MAX_PICTURE_COUNT);
1048 #endif
1049
1050     if(s->encoding){
1051         /* release non refernce frames */
1052         for(i=0; i<MAX_PICTURE_COUNT; i++){
1053             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1054                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1055             }
1056         }
1057     }
1058     // clear copies, to avoid confusion
1059 #if 0
1060     memset(&s->last_picture, 0, sizeof(Picture));
1061     memset(&s->next_picture, 0, sizeof(Picture));
1062     memset(&s->current_picture, 0, sizeof(Picture));
1063 #endif
1064 }
1065
1066 /**
1067  * draws an line from (ex, ey) -> (sx, sy).
1068  * @param w width of the image
1069  * @param h height of the image
1070  * @param stride stride/linesize of the image
1071  * @param color color of the arrow
1072  */
1073 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1074     int t, x, y, f;
1075
1076     sx= clip(sx, 0, w-1);
1077     sy= clip(sy, 0, h-1);
1078     ex= clip(ex, 0, w-1);
1079     ey= clip(ey, 0, h-1);
1080
1081     buf[sy*stride + sx]+= color;
1082
1083     if(ABS(ex - sx) > ABS(ey - sy)){
1084         if(sx > ex){
1085             t=sx; sx=ex; ex=t;
1086             t=sy; sy=ey; ey=t;
1087         }
1088         buf+= sx + sy*stride;
1089         ex-= sx;
1090         f= ((ey-sy)<<16)/ex;
1091         for(x= 0; x <= ex; x++){
1092             y= ((x*f) + (1<<15))>>16;
1093             buf[y*stride + x]+= color;
1094         }
1095     }else{
1096         if(sy > ey){
1097             t=sx; sx=ex; ex=t;
1098             t=sy; sy=ey; ey=t;
1099         }
1100         buf+= sx + sy*stride;
1101         ey-= sy;
1102         if(ey) f= ((ex-sx)<<16)/ey;
1103         else   f= 0;
1104         for(y= 0; y <= ey; y++){
1105             x= ((y*f) + (1<<15))>>16;
1106             buf[y*stride + x]+= color;
1107         }
1108     }
1109 }
1110
1111 /**
1112  * draws an arrow from (ex, ey) -> (sx, sy).
1113  * @param w width of the image
1114  * @param h height of the image
1115  * @param stride stride/linesize of the image
1116  * @param color color of the arrow
1117  */
1118 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1119     int dx,dy;
1120
1121     sx= clip(sx, -100, w+100);
1122     sy= clip(sy, -100, h+100);
1123     ex= clip(ex, -100, w+100);
1124     ey= clip(ey, -100, h+100);
1125
1126     dx= ex - sx;
1127     dy= ey - sy;
1128
1129     if(dx*dx + dy*dy > 3*3){
1130         int rx=  dx + dy;
1131         int ry= -dx + dy;
1132         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1133
1134         //FIXME subpixel accuracy
1135         rx= ROUNDED_DIV(rx*3<<4, length);
1136         ry= ROUNDED_DIV(ry*3<<4, length);
1137
1138         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1139         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1140     }
1141     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1142 }
1143
1144 /**
1145  * prints debuging info for the given picture.
1146  */
1147 void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1148
1149     if(!pict || !pict->mb_type) return;
1150
1151     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1152         int x,y;
1153
1154         for(y=0; y<s->mb_height; y++){
1155             for(x=0; x<s->mb_width; x++){
1156                 if(s->avctx->debug&FF_DEBUG_SKIP){
1157                     int count= s->mbskip_table[x + y*s->mb_stride];
1158                     if(count>9) count=9;
1159                     printf("%1d", count);
1160                 }
1161                 if(s->avctx->debug&FF_DEBUG_QP){
1162                     printf("%2d", pict->qscale_table[x + y*s->mb_stride]);
1163                 }
1164                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1165                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1166
1167                     //Type & MV direction
1168                     if(IS_PCM(mb_type))
1169                         printf("P");
1170                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1171                         printf("A");
1172                     else if(IS_INTRA4x4(mb_type))
1173                         printf("i");
1174                     else if(IS_INTRA16x16(mb_type))
1175                         printf("I");
1176                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1177                         printf("d");
1178                     else if(IS_DIRECT(mb_type))
1179                         printf("D");
1180                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1181                         printf("g");
1182                     else if(IS_GMC(mb_type))
1183                         printf("G");
1184                     else if(IS_SKIP(mb_type))
1185                         printf("S");
1186                     else if(!USES_LIST(mb_type, 1))
1187                         printf(">");
1188                     else if(!USES_LIST(mb_type, 0))
1189                         printf("<");
1190                     else{
1191                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1192                         printf("X");
1193                     }
1194
1195                     //segmentation
1196                     if(IS_8X8(mb_type))
1197                         printf("+");
1198                     else if(IS_16X8(mb_type))
1199                         printf("-");
1200                     else if(IS_8X16(mb_type))
1201                         printf("¦");
1202                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1203                         printf(" ");
1204                     else
1205                         printf("?");
1206
1207
1208                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1209                         printf("=");
1210                     else
1211                         printf(" ");
1212                 }
1213 //                printf(" ");
1214             }
1215             printf("\n");
1216         }
1217     }
1218
1219     if((s->avctx->debug&FF_DEBUG_VIS_MV) && s->motion_val){
1220         const int shift= 1 + s->quarter_sample;
1221         int mb_y;
1222         uint8_t *ptr= pict->data[0];
1223         s->low_delay=0; //needed to see the vectors without trashing the buffers
1224
1225         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1226             int mb_x;
1227             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1228                 const int mb_index= mb_x + mb_y*s->mb_stride;
1229                 if(IS_8X8(s->current_picture.mb_type[mb_index])){
1230                     int i;
1231                     for(i=0; i<4; i++){
1232                         int sx= mb_x*16 + 4 + 8*(i&1);
1233                         int sy= mb_y*16 + 4 + 8*(i>>1);
1234                         int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1235                         int mx= (s->motion_val[xy][0]>>shift) + sx;
1236                         int my= (s->motion_val[xy][1]>>shift) + sy;
1237                         draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1238                     }
1239                 }else{
1240                     int sx= mb_x*16 + 8;
1241                     int sy= mb_y*16 + 8;
1242                     int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1243                     int mx= (s->motion_val[xy][0]>>shift) + sx;
1244                     int my= (s->motion_val[xy][1]>>shift) + sy;
1245                     draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1246                 }
1247                 s->mbskip_table[mb_index]=0;
1248             }
1249         }
1250     }
1251 }
1252
1253 #ifdef CONFIG_ENCODERS
1254
1255 static int get_sae(uint8_t *src, int ref, int stride){
1256     int x,y;
1257     int acc=0;
1258
1259     for(y=0; y<16; y++){
1260         for(x=0; x<16; x++){
1261             acc+= ABS(src[x+y*stride] - ref);
1262         }
1263     }
1264
1265     return acc;
1266 }
1267
1268 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1269     int x, y, w, h;
1270     int acc=0;
1271
1272     w= s->width &~15;
1273     h= s->height&~15;
1274
1275     for(y=0; y<h; y+=16){
1276         for(x=0; x<w; x+=16){
1277             int offset= x + y*stride;
1278             int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1279             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1280             int sae = get_sae(src + offset, mean, stride);
1281
1282             acc+= sae + 500 < sad;
1283         }
1284     }
1285     return acc;
1286 }
1287
1288
1289 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1290     AVFrame *pic;
1291     int i;
1292     const int encoding_delay= s->max_b_frames;
1293     int direct=1;
1294
1295     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1296     if(pic_arg->linesize[0] != s->linesize) direct=0;
1297     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1298     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1299
1300 //    printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1301
1302     if(direct){
1303         i= find_unused_picture(s, 1);
1304
1305         pic= (AVFrame*)&s->picture[i];
1306         pic->reference= 3;
1307
1308         for(i=0; i<4; i++){
1309             pic->data[i]= pic_arg->data[i];
1310             pic->linesize[i]= pic_arg->linesize[i];
1311         }
1312         alloc_picture(s, (Picture*)pic, 1);
1313     }else{
1314         i= find_unused_picture(s, 0);
1315
1316         pic= (AVFrame*)&s->picture[i];
1317         pic->reference= 3;
1318
1319         alloc_picture(s, (Picture*)pic, 0);
1320         for(i=0; i<4; i++){
1321             /* the input will be 16 pixels to the right relative to the actual buffer start
1322              * and the current_pic, so the buffer can be reused, yes its not beatifull
1323              */
1324             pic->data[i]+= 16;
1325         }
1326
1327         if(   pic->data[0] == pic_arg->data[0]
1328            && pic->data[1] == pic_arg->data[1]
1329            && pic->data[2] == pic_arg->data[2]){
1330        // empty
1331         }else{
1332             int h_chroma_shift, v_chroma_shift;
1333
1334             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1335
1336             for(i=0; i<3; i++){
1337                 int src_stride= pic_arg->linesize[i];
1338                 int dst_stride= i ? s->uvlinesize : s->linesize;
1339                 int h_shift= i ? h_chroma_shift : 0;
1340                 int v_shift= i ? v_chroma_shift : 0;
1341                 int w= s->width >>h_shift;
1342                 int h= s->height>>v_shift;
1343                 uint8_t *src= pic_arg->data[i];
1344                 uint8_t *dst= pic->data[i];
1345
1346                 if(src_stride==dst_stride)
1347                     memcpy(dst, src, src_stride*h);
1348                 else{
1349                     while(h--){
1350                         memcpy(dst, src, w);
1351                         dst += dst_stride;
1352                         src += src_stride;
1353                     }
1354                 }
1355             }
1356         }
1357     }
1358     pic->quality= pic_arg->quality;
1359     pic->pict_type= pic_arg->pict_type;
1360     pic->pts = pic_arg->pts;
1361
1362     if(s->input_picture[encoding_delay])
1363         pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1364
1365     /* shift buffer entries */
1366     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1367         s->input_picture[i-1]= s->input_picture[i];
1368
1369     s->input_picture[encoding_delay]= (Picture*)pic;
1370
1371     return 0;
1372 }
1373
1374 static void select_input_picture(MpegEncContext *s){
1375     int i;
1376     const int encoding_delay= s->max_b_frames;
1377     int coded_pic_num=0;
1378
1379     if(s->reordered_input_picture[0])
1380         coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1381
1382     for(i=1; i<MAX_PICTURE_COUNT; i++)
1383         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1384     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1385
1386     /* set next picture types & ordering */
1387     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1388         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1389             s->reordered_input_picture[0]= s->input_picture[0];
1390             s->reordered_input_picture[0]->pict_type= I_TYPE;
1391             s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1392         }else{
1393             int b_frames;
1394
1395             if(s->flags&CODEC_FLAG_PASS2){
1396                 for(i=0; i<s->max_b_frames+1; i++){
1397                     int pict_num= s->input_picture[0]->display_picture_number + i;
1398                     int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1399                     s->input_picture[i]->pict_type= pict_type;
1400
1401                     if(i + 1 >= s->rc_context.num_entries) break;
1402                 }
1403             }
1404
1405             if(s->input_picture[0]->pict_type){
1406                 /* user selected pict_type */
1407                 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1408                     if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1409                 }
1410
1411                 if(b_frames > s->max_b_frames){
1412                     fprintf(stderr, "warning, too many bframes in a row\n");
1413                     b_frames = s->max_b_frames;
1414                 }
1415             }else if(s->b_frame_strategy==0){
1416                 b_frames= s->max_b_frames;
1417             }else if(s->b_frame_strategy==1){
1418                 for(i=1; i<s->max_b_frames+1; i++){
1419                     if(s->input_picture[i]->b_frame_score==0){
1420                         s->input_picture[i]->b_frame_score=
1421                             get_intra_count(s, s->input_picture[i  ]->data[0],
1422                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
1423                     }
1424                 }
1425                 for(i=0; i<s->max_b_frames; i++){
1426                     if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1427                 }
1428
1429                 b_frames= FFMAX(0, i-1);
1430
1431                 /* reset scores */
1432                 for(i=0; i<b_frames+1; i++){
1433                     s->input_picture[i]->b_frame_score=0;
1434                 }
1435             }else{
1436                 fprintf(stderr, "illegal b frame strategy\n");
1437                 b_frames=0;
1438             }
1439
1440             emms_c();
1441 //static int b_count=0;
1442 //b_count+= b_frames;
1443 //printf("b_frames: %d\n", b_count);
1444
1445             s->reordered_input_picture[0]= s->input_picture[b_frames];
1446             if(   s->picture_in_gop_number + b_frames >= s->gop_size
1447                || s->reordered_input_picture[0]->pict_type== I_TYPE)
1448                 s->reordered_input_picture[0]->pict_type= I_TYPE;
1449             else
1450                 s->reordered_input_picture[0]->pict_type= P_TYPE;
1451             s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1452             for(i=0; i<b_frames; i++){
1453                 coded_pic_num++;
1454                 s->reordered_input_picture[i+1]= s->input_picture[i];
1455                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1456                 s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1457             }
1458         }
1459     }
1460
1461     if(s->reordered_input_picture[0]){
1462         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1463
1464         s->new_picture= *s->reordered_input_picture[0];
1465
1466         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1467             // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1468
1469             int i= find_unused_picture(s, 0);
1470             Picture *pic= &s->picture[i];
1471
1472             /* mark us unused / free shared pic */
1473             for(i=0; i<4; i++)
1474                 s->reordered_input_picture[0]->data[i]= NULL;
1475             s->reordered_input_picture[0]->type= 0;
1476
1477             //FIXME bad, copy * except
1478             pic->pict_type = s->reordered_input_picture[0]->pict_type;
1479             pic->quality   = s->reordered_input_picture[0]->quality;
1480             pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1481             pic->reference = s->reordered_input_picture[0]->reference;
1482
1483             alloc_picture(s, pic, 0);
1484
1485             s->current_picture_ptr= pic;
1486         }else{
1487             // input is not a shared pix -> reuse buffer for current_pix
1488
1489             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
1490                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1491
1492             s->current_picture_ptr= s->reordered_input_picture[0];
1493             for(i=0; i<4; i++){
1494                 //reverse the +16 we did before storing the input
1495                 s->current_picture_ptr->data[i]-=16;
1496             }
1497         }
1498         s->current_picture= *s->current_picture_ptr;
1499
1500         s->picture_number= s->new_picture.display_picture_number;
1501 //printf("dpn:%d\n", s->picture_number);
1502     }else{
1503        memset(&s->new_picture, 0, sizeof(Picture));
1504     }
1505 }
1506
1507 int MPV_encode_picture(AVCodecContext *avctx,
1508                        unsigned char *buf, int buf_size, void *data)
1509 {
1510     MpegEncContext *s = avctx->priv_data;
1511     AVFrame *pic_arg = data;
1512     int i;
1513
1514     init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1515
1516     s->picture_in_gop_number++;
1517
1518     load_input_picture(s, pic_arg);
1519
1520     select_input_picture(s);
1521
1522     /* output? */
1523     if(s->new_picture.data[0]){
1524
1525         s->pict_type= s->new_picture.pict_type;
1526         if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1527             s->qscale= (int)(s->new_picture.quality+0.5);
1528             assert(s->qscale);
1529         }
1530 //emms_c();
1531 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1532         MPV_frame_start(s, avctx);
1533
1534         encode_picture(s, s->picture_number);
1535
1536         avctx->real_pict_num  = s->picture_number;
1537         avctx->header_bits = s->header_bits;
1538         avctx->mv_bits     = s->mv_bits;
1539         avctx->misc_bits   = s->misc_bits;
1540         avctx->i_tex_bits  = s->i_tex_bits;
1541         avctx->p_tex_bits  = s->p_tex_bits;
1542         avctx->i_count     = s->i_count;
1543         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1544         avctx->skip_count  = s->skip_count;
1545
1546         MPV_frame_end(s);
1547
1548         if (s->out_format == FMT_MJPEG)
1549             mjpeg_picture_trailer(s);
1550
1551         if(s->flags&CODEC_FLAG_PASS1)
1552             ff_write_pass1_stats(s);
1553
1554         for(i=0; i<4; i++){
1555             avctx->error[i] += s->current_picture_ptr->error[i];
1556         }
1557     }
1558
1559     s->input_picture_number++;
1560
1561     flush_put_bits(&s->pb);
1562     s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1563
1564     s->total_bits += s->frame_bits;
1565     avctx->frame_bits  = s->frame_bits;
1566
1567     return pbBufPtr(&s->pb) - s->pb.buf;
1568 }
1569
1570 #endif //CONFIG_ENCODERS
1571
1572 static inline void gmc1_motion(MpegEncContext *s,
1573                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1574                                int dest_offset,
1575                                uint8_t **ref_picture, int src_offset)
1576 {
1577     uint8_t *ptr;
1578     int offset, src_x, src_y, linesize, uvlinesize;
1579     int motion_x, motion_y;
1580     int emu=0;
1581
1582     motion_x= s->sprite_offset[0][0];
1583     motion_y= s->sprite_offset[0][1];
1584     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1585     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1586     motion_x<<=(3-s->sprite_warping_accuracy);
1587     motion_y<<=(3-s->sprite_warping_accuracy);
1588     src_x = clip(src_x, -16, s->width);
1589     if (src_x == s->width)
1590         motion_x =0;
1591     src_y = clip(src_y, -16, s->height);
1592     if (src_y == s->height)
1593         motion_y =0;
1594
1595     linesize = s->linesize;
1596     uvlinesize = s->uvlinesize;
1597
1598     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1599
1600     dest_y+=dest_offset;
1601     if(s->flags&CODEC_FLAG_EMU_EDGE){
1602         if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1603                               || src_y + 17 >= s->v_edge_pos){
1604             ff_emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1605             ptr= s->edge_emu_buffer;
1606         }
1607     }
1608
1609     if((motion_x|motion_y)&7){
1610         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1611         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1612     }else{
1613         int dxy;
1614
1615         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1616         if (s->no_rounding){
1617             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1618         }else{
1619             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1620         }
1621     }
1622
1623     if(s->flags&CODEC_FLAG_GRAY) return;
1624
1625     motion_x= s->sprite_offset[1][0];
1626     motion_y= s->sprite_offset[1][1];
1627     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1628     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1629     motion_x<<=(3-s->sprite_warping_accuracy);
1630     motion_y<<=(3-s->sprite_warping_accuracy);
1631     src_x = clip(src_x, -8, s->width>>1);
1632     if (src_x == s->width>>1)
1633         motion_x =0;
1634     src_y = clip(src_y, -8, s->height>>1);
1635     if (src_y == s->height>>1)
1636         motion_y =0;
1637
1638     offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1639     ptr = ref_picture[1] + offset;
1640     if(s->flags&CODEC_FLAG_EMU_EDGE){
1641         if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1642                               || src_y + 9 >= s->v_edge_pos>>1){
1643             ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1644             ptr= s->edge_emu_buffer;
1645             emu=1;
1646         }
1647     }
1648     s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1649
1650     ptr = ref_picture[2] + offset;
1651     if(emu){
1652         ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1653         ptr= s->edge_emu_buffer;
1654     }
1655     s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1656
1657     return;
1658 }
1659
1660 static inline void gmc_motion(MpegEncContext *s,
1661                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1662                                int dest_offset,
1663                                uint8_t **ref_picture, int src_offset)
1664 {
1665     uint8_t *ptr;
1666     int linesize, uvlinesize;
1667     const int a= s->sprite_warping_accuracy;
1668     int ox, oy;
1669
1670     linesize = s->linesize;
1671     uvlinesize = s->uvlinesize;
1672
1673     ptr = ref_picture[0] + src_offset;
1674
1675     dest_y+=dest_offset;
1676
1677     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1678     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1679
1680     s->dsp.gmc(dest_y, ptr, linesize, 16,
1681            ox,
1682            oy,
1683            s->sprite_delta[0][0], s->sprite_delta[0][1],
1684            s->sprite_delta[1][0], s->sprite_delta[1][1],
1685            a+1, (1<<(2*a+1)) - s->no_rounding,
1686            s->h_edge_pos, s->v_edge_pos);
1687     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1688            ox + s->sprite_delta[0][0]*8,
1689            oy + s->sprite_delta[1][0]*8,
1690            s->sprite_delta[0][0], s->sprite_delta[0][1],
1691            s->sprite_delta[1][0], s->sprite_delta[1][1],
1692            a+1, (1<<(2*a+1)) - s->no_rounding,
1693            s->h_edge_pos, s->v_edge_pos);
1694
1695     if(s->flags&CODEC_FLAG_GRAY) return;
1696
1697
1698     dest_cb+=dest_offset>>1;
1699     dest_cr+=dest_offset>>1;
1700
1701     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1702     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1703
1704     ptr = ref_picture[1] + (src_offset>>1);
1705     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1706            ox,
1707            oy,
1708            s->sprite_delta[0][0], s->sprite_delta[0][1],
1709            s->sprite_delta[1][0], s->sprite_delta[1][1],
1710            a+1, (1<<(2*a+1)) - s->no_rounding,
1711            s->h_edge_pos>>1, s->v_edge_pos>>1);
1712
1713     ptr = ref_picture[2] + (src_offset>>1);
1714     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1715            ox,
1716            oy,
1717            s->sprite_delta[0][0], s->sprite_delta[0][1],
1718            s->sprite_delta[1][0], s->sprite_delta[1][1],
1719            a+1, (1<<(2*a+1)) - s->no_rounding,
1720            s->h_edge_pos>>1, s->v_edge_pos>>1);
1721 }
1722
1723
1724 void ff_emulated_edge_mc(MpegEncContext *s, uint8_t *src, int linesize, int block_w, int block_h,
1725                                     int src_x, int src_y, int w, int h){
1726     int x, y;
1727     int start_y, start_x, end_y, end_x;
1728     uint8_t *buf= s->edge_emu_buffer;
1729
1730     if(src_y>= h){
1731         src+= (h-1-src_y)*linesize;
1732         src_y=h-1;
1733     }else if(src_y<=-block_h){
1734         src+= (1-block_h-src_y)*linesize;
1735         src_y=1-block_h;
1736     }
1737     if(src_x>= w){
1738         src+= (w-1-src_x);
1739         src_x=w-1;
1740     }else if(src_x<=-block_w){
1741         src+= (1-block_w-src_x);
1742         src_x=1-block_w;
1743     }
1744
1745     start_y= FFMAX(0, -src_y);
1746     start_x= FFMAX(0, -src_x);
1747     end_y= FFMIN(block_h, h-src_y);
1748     end_x= FFMIN(block_w, w-src_x);
1749
1750     // copy existing part
1751     for(y=start_y; y<end_y; y++){
1752         for(x=start_x; x<end_x; x++){
1753             buf[x + y*linesize]= src[x + y*linesize];
1754         }
1755     }
1756
1757     //top
1758     for(y=0; y<start_y; y++){
1759         for(x=start_x; x<end_x; x++){
1760             buf[x + y*linesize]= buf[x + start_y*linesize];
1761         }
1762     }
1763
1764     //bottom
1765     for(y=end_y; y<block_h; y++){
1766         for(x=start_x; x<end_x; x++){
1767             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1768         }
1769     }
1770
1771     for(y=0; y<block_h; y++){
1772        //left
1773         for(x=0; x<start_x; x++){
1774             buf[x + y*linesize]= buf[start_x + y*linesize];
1775         }
1776
1777        //right
1778         for(x=end_x; x<block_w; x++){
1779             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1780         }
1781     }
1782 }
1783
1784
1785 /* apply one mpeg motion vector to the three components */
1786 static inline void mpeg_motion(MpegEncContext *s,
1787                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1788                                int dest_offset,
1789                                uint8_t **ref_picture, int src_offset,
1790                                int field_based, op_pixels_func (*pix_op)[4],
1791                                int motion_x, int motion_y, int h)
1792 {
1793     uint8_t *ptr;
1794     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1795     int emu=0;
1796 #if 0
1797 if(s->quarter_sample)
1798 {
1799     motion_x>>=1;
1800     motion_y>>=1;
1801 }
1802 #endif
1803     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1804     src_x = s->mb_x * 16 + (motion_x >> 1);
1805     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1806
1807     /* WARNING: do no forget half pels */
1808     height = s->height >> field_based;
1809     v_edge_pos = s->v_edge_pos >> field_based;
1810     src_x = clip(src_x, -16, s->width);
1811     if (src_x == s->width)
1812         dxy &= ~1;
1813     src_y = clip(src_y, -16, height);
1814     if (src_y == height)
1815         dxy &= ~2;
1816     linesize   = s->current_picture.linesize[0] << field_based;
1817     uvlinesize = s->current_picture.linesize[1] << field_based;
1818     ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1819     dest_y += dest_offset;
1820
1821     if(s->flags&CODEC_FLAG_EMU_EDGE){
1822         if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1823                               || src_y + (motion_y&1) + h  > v_edge_pos){
1824             ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,  //FIXME linesize? and uv below
1825                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1826             ptr= s->edge_emu_buffer + src_offset;
1827             emu=1;
1828         }
1829     }
1830     pix_op[0][dxy](dest_y, ptr, linesize, h);
1831
1832     if(s->flags&CODEC_FLAG_GRAY) return;
1833
1834     if (s->out_format == FMT_H263) {
1835         dxy = 0;
1836         if ((motion_x & 3) != 0)
1837             dxy |= 1;
1838         if ((motion_y & 3) != 0)
1839             dxy |= 2;
1840         mx = motion_x >> 2;
1841         my = motion_y >> 2;
1842     } else {
1843         mx = motion_x / 2;
1844         my = motion_y / 2;
1845         dxy = ((my & 1) << 1) | (mx & 1);
1846         mx >>= 1;
1847         my >>= 1;
1848     }
1849
1850     src_x = s->mb_x * 8 + mx;
1851     src_y = s->mb_y * (8 >> field_based) + my;
1852     src_x = clip(src_x, -8, s->width >> 1);
1853     if (src_x == (s->width >> 1))
1854         dxy &= ~1;
1855     src_y = clip(src_y, -8, height >> 1);
1856     if (src_y == (height >> 1))
1857         dxy &= ~2;
1858     offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1859     ptr = ref_picture[1] + offset;
1860     if(emu){
1861         ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
1862                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1863         ptr= s->edge_emu_buffer + (src_offset >> 1);
1864     }
1865     pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1866
1867     ptr = ref_picture[2] + offset;
1868     if(emu){
1869         ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
1870                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1871         ptr= s->edge_emu_buffer + (src_offset >> 1);
1872     }
1873     pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1874 }
1875
1876 static inline void qpel_motion(MpegEncContext *s,
1877                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1878                                int dest_offset,
1879                                uint8_t **ref_picture, int src_offset,
1880                                int field_based, op_pixels_func (*pix_op)[4],
1881                                qpel_mc_func (*qpix_op)[16],
1882                                int motion_x, int motion_y, int h)
1883 {
1884     uint8_t *ptr;
1885     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1886     int emu=0;
1887
1888     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1889     src_x = s->mb_x * 16 + (motion_x >> 2);
1890     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1891
1892     height = s->height >> field_based;
1893     v_edge_pos = s->v_edge_pos >> field_based;
1894     src_x = clip(src_x, -16, s->width);
1895     if (src_x == s->width)
1896         dxy &= ~3;
1897     src_y = clip(src_y, -16, height);
1898     if (src_y == height)
1899         dxy &= ~12;
1900     linesize = s->linesize << field_based;
1901     uvlinesize = s->uvlinesize << field_based;
1902     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1903     dest_y += dest_offset;
1904 //printf("%d %d %d\n", src_x, src_y, dxy);
1905
1906     if(s->flags&CODEC_FLAG_EMU_EDGE){
1907         if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1908                               || src_y + (motion_y&3) + h  > v_edge_pos){
1909             ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,
1910                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1911             ptr= s->edge_emu_buffer + src_offset;
1912             emu=1;
1913         }
1914     }
1915     if(!field_based)
1916         qpix_op[0][dxy](dest_y, ptr, linesize);
1917     else{
1918         //damn interlaced mode
1919         //FIXME boundary mirroring is not exactly correct here
1920         qpix_op[1][dxy](dest_y  , ptr  , linesize);
1921         qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1922     }
1923
1924     if(s->flags&CODEC_FLAG_GRAY) return;
1925
1926     if(field_based){
1927         mx= motion_x/2;
1928         my= motion_y>>1;
1929     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
1930         static const int rtab[8]= {0,0,1,1,0,0,0,1};
1931         mx= (motion_x>>1) + rtab[motion_x&7];
1932         my= (motion_y>>1) + rtab[motion_y&7];
1933     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1934         mx= (motion_x>>1)|(motion_x&1);
1935         my= (motion_y>>1)|(motion_y&1);
1936     }else{
1937         mx= motion_x/2;
1938         my= motion_y/2;
1939     }
1940     mx= (mx>>1)|(mx&1);
1941     my= (my>>1)|(my&1);
1942
1943     dxy= (mx&1) | ((my&1)<<1);
1944     mx>>=1;
1945     my>>=1;
1946
1947     src_x = s->mb_x * 8 + mx;
1948     src_y = s->mb_y * (8 >> field_based) + my;
1949     src_x = clip(src_x, -8, s->width >> 1);
1950     if (src_x == (s->width >> 1))
1951         dxy &= ~1;
1952     src_y = clip(src_y, -8, height >> 1);
1953     if (src_y == (height >> 1))
1954         dxy &= ~2;
1955
1956     offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1957     ptr = ref_picture[1] + offset;
1958     if(emu){
1959         ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
1960                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1961         ptr= s->edge_emu_buffer + (src_offset >> 1);
1962     }
1963     pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1964
1965     ptr = ref_picture[2] + offset;
1966     if(emu){
1967         ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
1968                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1969         ptr= s->edge_emu_buffer + (src_offset >> 1);
1970     }
1971     pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1972 }
1973
1974 inline int ff_h263_round_chroma(int x){
1975     if (x >= 0)
1976         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1977     else {
1978         x = -x;
1979         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1980     }
1981 }
1982
1983 /**
1984  * motion compesation of a single macroblock
1985  * @param s context
1986  * @param dest_y luma destination pointer
1987  * @param dest_cb chroma cb/u destination pointer
1988  * @param dest_cr chroma cr/v destination pointer
1989  * @param dir direction (0->forward, 1->backward)
1990  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1991  * @param pic_op halfpel motion compensation function (average or put normally)
1992  * @param pic_op qpel motion compensation function (average or put normally)
1993  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1994  */
1995 static inline void MPV_motion(MpegEncContext *s,
1996                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1997                               int dir, uint8_t **ref_picture,
1998                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1999 {
2000     int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
2001     int mb_x, mb_y, i;
2002     uint8_t *ptr, *dest;
2003     int emu=0;
2004
2005     mb_x = s->mb_x;
2006     mb_y = s->mb_y;
2007
2008     switch(s->mv_type) {
2009     case MV_TYPE_16X16:
2010 #ifdef CONFIG_RISKY
2011         if(s->mcsel){
2012             if(s->real_sprite_warping_points==1){
2013                 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2014                             ref_picture, 0);
2015             }else{
2016                 gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2017                             ref_picture, 0);
2018             }
2019         }else if(s->quarter_sample){
2020             qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2021                         ref_picture, 0,
2022                         0, pix_op, qpix_op,
2023                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2024         }else if(s->mspel){
2025             ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2026                         ref_picture, pix_op,
2027                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2028         }else
2029 #endif
2030         {
2031             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2032                         ref_picture, 0,
2033                         0, pix_op,
2034                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2035         }
2036         break;
2037     case MV_TYPE_8X8:
2038         mx = 0;
2039         my = 0;
2040         if(s->quarter_sample){
2041             for(i=0;i<4;i++) {
2042                 motion_x = s->mv[dir][i][0];
2043                 motion_y = s->mv[dir][i][1];
2044
2045                 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2046                 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2047                 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2048
2049                 /* WARNING: do no forget half pels */
2050                 src_x = clip(src_x, -16, s->width);
2051                 if (src_x == s->width)
2052                     dxy &= ~3;
2053                 src_y = clip(src_y, -16, s->height);
2054                 if (src_y == s->height)
2055                     dxy &= ~12;
2056
2057                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2058                 if(s->flags&CODEC_FLAG_EMU_EDGE){
2059                     if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
2060                                           || src_y + (motion_y&3) + 8 > s->v_edge_pos){
2061                         ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2062                         ptr= s->edge_emu_buffer;
2063                     }
2064                 }
2065                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2066                 qpix_op[1][dxy](dest, ptr, s->linesize);
2067
2068                 mx += s->mv[dir][i][0]/2;
2069                 my += s->mv[dir][i][1]/2;
2070             }
2071         }else{
2072             for(i=0;i<4;i++) {
2073                 motion_x = s->mv[dir][i][0];
2074                 motion_y = s->mv[dir][i][1];
2075
2076                 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2077                 src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
2078                 src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
2079
2080                 /* WARNING: do no forget half pels */
2081                 src_x = clip(src_x, -16, s->width);
2082                 if (src_x == s->width)
2083                     dxy &= ~1;
2084                 src_y = clip(src_y, -16, s->height);
2085                 if (src_y == s->height)
2086                     dxy &= ~2;
2087
2088                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2089                 if(s->flags&CODEC_FLAG_EMU_EDGE){
2090                     if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
2091                                           || src_y + (motion_y&1) + 8 > s->v_edge_pos){
2092                         ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2093                         ptr= s->edge_emu_buffer;
2094                     }
2095                 }
2096                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2097                 pix_op[1][dxy](dest, ptr, s->linesize, 8);
2098
2099                 mx += s->mv[dir][i][0];
2100                 my += s->mv[dir][i][1];
2101             }
2102         }
2103
2104         if(s->flags&CODEC_FLAG_GRAY) break;
2105         /* In case of 8X8, we construct a single chroma motion vector
2106            with a special rounding */
2107         mx= ff_h263_round_chroma(mx);
2108         my= ff_h263_round_chroma(my);
2109         dxy = ((my & 1) << 1) | (mx & 1);
2110         mx >>= 1;
2111         my >>= 1;
2112
2113         src_x = mb_x * 8 + mx;
2114         src_y = mb_y * 8 + my;
2115         src_x = clip(src_x, -8, s->width/2);
2116         if (src_x == s->width/2)
2117             dxy &= ~1;
2118         src_y = clip(src_y, -8, s->height/2);
2119         if (src_y == s->height/2)
2120             dxy &= ~2;
2121
2122         offset = (src_y * (s->uvlinesize)) + src_x;
2123         ptr = ref_picture[1] + offset;
2124         if(s->flags&CODEC_FLAG_EMU_EDGE){
2125                 if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
2126                                       || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
2127                     ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2128                     ptr= s->edge_emu_buffer;
2129                     emu=1;
2130                 }
2131             }
2132         pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
2133
2134         ptr = ref_picture[2] + offset;
2135         if(emu){
2136             ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2137             ptr= s->edge_emu_buffer;
2138         }
2139         pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
2140         break;
2141     case MV_TYPE_FIELD:
2142         if (s->picture_structure == PICT_FRAME) {
2143             if(s->quarter_sample){
2144                 /* top field */
2145                 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2146                             ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2147                             1, pix_op, qpix_op,
2148                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
2149                 /* bottom field */
2150                 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2151                             ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2152                             1, pix_op, qpix_op,
2153                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
2154             }else{
2155                 /* top field */
2156                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2157                             ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2158                             1, pix_op,
2159                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
2160                 /* bottom field */
2161                 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2162                             ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2163                             1, pix_op,
2164                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
2165             }
2166         } else {
2167             int offset;
2168             if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2169                 offset= s->field_select[dir][0] ? s->linesize : 0;
2170             }else{
2171                 ref_picture= s->current_picture.data;
2172                 offset= s->field_select[dir][0] ? s->linesize : -s->linesize;
2173             }
2174
2175             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2176                         ref_picture, offset,
2177                         0, pix_op,
2178                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2179         }
2180         break;
2181     }
2182 }
2183
2184
2185 /* put block[] to dest[] */
2186 static inline void put_dct(MpegEncContext *s,
2187                            DCTELEM *block, int i, uint8_t *dest, int line_size)
2188 {
2189     s->dct_unquantize(s, block, i, s->qscale);
2190     s->dsp.idct_put (dest, line_size, block);
2191 }
2192
2193 /* add block[] to dest[] */
2194 static inline void add_dct(MpegEncContext *s,
2195                            DCTELEM *block, int i, uint8_t *dest, int line_size)
2196 {
2197     if (s->block_last_index[i] >= 0) {
2198         s->dsp.idct_add (dest, line_size, block);
2199     }
2200 }
2201
2202 static inline void add_dequant_dct(MpegEncContext *s,
2203                            DCTELEM *block, int i, uint8_t *dest, int line_size)
2204 {
2205     if (s->block_last_index[i] >= 0) {
2206         s->dct_unquantize(s, block, i, s->qscale);
2207
2208         s->dsp.idct_add (dest, line_size, block);
2209     }
2210 }
2211
2212 /**
2213  * cleans dc, ac, coded_block for the current non intra MB
2214  */
2215 void ff_clean_intra_table_entries(MpegEncContext *s)
2216 {
2217     int wrap = s->block_wrap[0];
2218     int xy = s->block_index[0];
2219
2220     s->dc_val[0][xy           ] =
2221     s->dc_val[0][xy + 1       ] =
2222     s->dc_val[0][xy     + wrap] =
2223     s->dc_val[0][xy + 1 + wrap] = 1024;
2224     /* ac pred */
2225     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2226     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2227     if (s->msmpeg4_version>=3) {
2228         s->coded_block[xy           ] =
2229         s->coded_block[xy + 1       ] =
2230         s->coded_block[xy     + wrap] =
2231         s->coded_block[xy + 1 + wrap] = 0;
2232     }
2233     /* chroma */
2234     wrap = s->block_wrap[4];
2235     xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2236     s->dc_val[1][xy] =
2237     s->dc_val[2][xy] = 1024;
2238     /* ac pred */
2239     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2240     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2241
2242     s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2243 }
2244
2245 /* generic function called after a macroblock has been parsed by the
2246    decoder or after it has been encoded by the encoder.
2247
2248    Important variables used:
2249    s->mb_intra : true if intra macroblock
2250    s->mv_dir   : motion vector direction
2251    s->mv_type  : motion vector type
2252    s->mv       : motion vector
2253    s->interlaced_dct : true if interlaced dct used (mpeg2)
2254  */
2255 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2256 {
2257     int mb_x, mb_y;
2258     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2259
2260     mb_x = s->mb_x;
2261     mb_y = s->mb_y;
2262
2263     s->current_picture.qscale_table[mb_xy]= s->qscale;
2264
2265     /* update DC predictors for P macroblocks */
2266     if (!s->mb_intra) {
2267         if (s->h263_pred || s->h263_aic) {
2268             if(s->mbintra_table[mb_xy])
2269                 ff_clean_intra_table_entries(s);
2270         } else {
2271             s->last_dc[0] =
2272             s->last_dc[1] =
2273             s->last_dc[2] = 128 << s->intra_dc_precision;
2274         }
2275     }
2276     else if (s->h263_pred || s->h263_aic)
2277         s->mbintra_table[mb_xy]=1;
2278
2279     /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
2280     if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
2281         //FIXME a lot of thet is only needed for !low_delay
2282         const int wrap = s->block_wrap[0];
2283         const int xy = s->block_index[0];
2284         if(s->mv_type != MV_TYPE_8X8){
2285             int motion_x, motion_y;
2286             if (s->mb_intra) {
2287                 motion_x = 0;
2288                 motion_y = 0;
2289             } else if (s->mv_type == MV_TYPE_16X16) {
2290                 motion_x = s->mv[0][0][0];
2291                 motion_y = s->mv[0][0][1];
2292             } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2293                 int i;
2294                 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2295                 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2296                 motion_x = (motion_x>>1) | (motion_x&1);
2297                 for(i=0; i<2; i++){
2298                     s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
2299                     s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
2300                     s->field_select_table[mb_xy][i]= s->field_select[0][i];
2301                 }
2302             }
2303
2304             /* no update if 8X8 because it has been done during parsing */
2305             s->motion_val[xy][0] = motion_x;
2306             s->motion_val[xy][1] = motion_y;
2307             s->motion_val[xy + 1][0] = motion_x;
2308             s->motion_val[xy + 1][1] = motion_y;
2309             s->motion_val[xy + wrap][0] = motion_x;
2310             s->motion_val[xy + wrap][1] = motion_y;
2311             s->motion_val[xy + 1 + wrap][0] = motion_x;
2312             s->motion_val[xy + 1 + wrap][1] = motion_y;
2313         }
2314
2315         if(s->encoding){ //FIXME encoding MUST be cleaned up
2316             if (s->mv_type == MV_TYPE_8X8)
2317                 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
2318             else
2319                 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
2320         }
2321     }
2322
2323     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2324         uint8_t *dest_y, *dest_cb, *dest_cr;
2325         int dct_linesize, dct_offset;
2326         op_pixels_func (*op_pix)[4];
2327         qpel_mc_func (*op_qpix)[16];
2328         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2329         const int uvlinesize= s->current_picture.linesize[1];
2330
2331         /* avoid copy if macroblock skipped in last frame too */
2332         if (s->pict_type != B_TYPE) {
2333             s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2334         }
2335
2336         /* skip only during decoding as we might trash the buffers during encoding a bit */
2337         if(!s->encoding){
2338             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2339             const int age= s->current_picture.age;
2340
2341             assert(age);
2342
2343             if (s->mb_skiped) {
2344                 s->mb_skiped= 0;
2345                 assert(s->pict_type!=I_TYPE);
2346
2347                 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2348                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2349
2350                 /* if previous was skipped too, then nothing to do !  */
2351                 if (*mbskip_ptr >= age && s->current_picture.reference){
2352                     return;
2353                 }
2354             } else if(!s->current_picture.reference){
2355                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2356                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2357             } else{
2358                 *mbskip_ptr = 0; /* not skipped */
2359             }
2360         }else
2361             s->mb_skiped= 0;
2362
2363         if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){ //FIXME precalc
2364             dest_y  = s->current_picture.data[0] + mb_x * 16;
2365             dest_cb = s->current_picture.data[1] + mb_x * 8;
2366             dest_cr = s->current_picture.data[2] + mb_x * 8;
2367         }else{
2368             dest_y  = s->current_picture.data[0] + (mb_y * 16* linesize  ) + mb_x * 16;
2369             dest_cb = s->current_picture.data[1] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2370             dest_cr = s->current_picture.data[2] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2371         }
2372
2373         if (s->interlaced_dct) {
2374             dct_linesize = linesize * 2;
2375             dct_offset = linesize;
2376         } else {
2377             dct_linesize = linesize;
2378             dct_offset = linesize * 8;
2379         }
2380
2381         if (!s->mb_intra) {
2382             /* motion handling */
2383             /* decoding or more than one mb_type (MC was allready done otherwise) */
2384             if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
2385                 if ((!s->no_rounding) || s->pict_type==B_TYPE){
2386                     op_pix = s->dsp.put_pixels_tab;
2387                     op_qpix= s->dsp.put_qpel_pixels_tab;
2388                 }else{
2389                     op_pix = s->dsp.put_no_rnd_pixels_tab;
2390                     op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2391                 }
2392
2393                 if (s->mv_dir & MV_DIR_FORWARD) {
2394                     MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2395                     op_pix = s->dsp.avg_pixels_tab;
2396                     op_qpix= s->dsp.avg_qpel_pixels_tab;
2397                 }
2398                 if (s->mv_dir & MV_DIR_BACKWARD) {
2399                     MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2400                 }
2401             }
2402
2403             /* skip dequant / idct if we are really late ;) */
2404             if(s->hurry_up>1) return;
2405
2406             /* add dct residue */
2407             if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO
2408                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2409                 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2410                 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2411                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2412                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2413
2414                 if(!(s->flags&CODEC_FLAG_GRAY)){
2415                     add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2416                     add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2417                 }
2418             } else if(s->codec_id != CODEC_ID_WMV2){
2419                 add_dct(s, block[0], 0, dest_y, dct_linesize);
2420                 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2421                 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2422                 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2423
2424                 if(!(s->flags&CODEC_FLAG_GRAY)){
2425                     add_dct(s, block[4], 4, dest_cb, uvlinesize);
2426                     add_dct(s, block[5], 5, dest_cr, uvlinesize);
2427                 }
2428             }
2429 #ifdef CONFIG_RISKY
2430             else{
2431                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2432             }
2433 #endif
2434         } else {
2435             /* dct only in intra block */
2436             if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2437                 put_dct(s, block[0], 0, dest_y, dct_linesize);
2438                 put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2439                 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2440                 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2441
2442                 if(!(s->flags&CODEC_FLAG_GRAY)){
2443                     put_dct(s, block[4], 4, dest_cb, uvlinesize);
2444                     put_dct(s, block[5], 5, dest_cr, uvlinesize);
2445                 }
2446             }else{
2447                 s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
2448                 s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
2449                 s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2450                 s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2451
2452                 if(!(s->flags&CODEC_FLAG_GRAY)){
2453                     s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2454                     s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2455                 }
2456             }
2457         }
2458     }
2459 }
2460
2461 #ifdef CONFIG_ENCODERS
2462
2463 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2464 {
2465     static const char tab[64]=
2466         {3,2,2,1,1,1,1,1,
2467          1,1,1,1,1,1,1,1,
2468          1,1,1,1,1,1,1,1,
2469          0,0,0,0,0,0,0,0,
2470          0,0,0,0,0,0,0,0,
2471          0,0,0,0,0,0,0,0,
2472          0,0,0,0,0,0,0,0,
2473          0,0,0,0,0,0,0,0};
2474     int score=0;
2475     int run=0;
2476     int i;
2477     DCTELEM *block= s->block[n];
2478     const int last_index= s->block_last_index[n];
2479     int skip_dc;
2480
2481     if(threshold<0){
2482         skip_dc=0;
2483         threshold= -threshold;
2484     }else
2485         skip_dc=1;
2486
2487     /* are all which we could set to zero are allready zero? */
2488     if(last_index<=skip_dc - 1) return;
2489
2490     for(i=0; i<=last_index; i++){
2491         const int j = s->intra_scantable.permutated[i];
2492         const int level = ABS(block[j]);
2493         if(level==1){
2494             if(skip_dc && i==0) continue;
2495             score+= tab[run];
2496             run=0;
2497         }else if(level>1){
2498             return;
2499         }else{
2500             run++;
2501         }
2502     }
2503     if(score >= threshold) return;
2504     for(i=skip_dc; i<=last_index; i++){
2505         const int j = s->intra_scantable.permutated[i];
2506         block[j]=0;
2507     }
2508     if(block[0]) s->block_last_index[n]= 0;
2509     else         s->block_last_index[n]= -1;
2510 }
2511
2512 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2513 {
2514     int i;
2515     const int maxlevel= s->max_qcoeff;
2516     const int minlevel= s->min_qcoeff;
2517
2518     if(s->mb_intra){
2519         i=1; //skip clipping of intra dc
2520     }else
2521         i=0;
2522
2523     for(;i<=last_index; i++){
2524         const int j= s->intra_scantable.permutated[i];
2525         int level = block[j];
2526
2527         if     (level>maxlevel) level=maxlevel;
2528         else if(level<minlevel) level=minlevel;
2529
2530         block[j]= level;
2531     }
2532 }
2533
2534 #if 0
2535 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2536     int score=0;
2537     int x,y;
2538
2539     for(y=0; y<7; y++){
2540         for(x=0; x<16; x+=4){
2541             score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride])
2542                    +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2543         }
2544         s+= stride;
2545     }
2546
2547     return score;
2548 }
2549
2550 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2551     int score=0;
2552     int x,y;
2553
2554     for(y=0; y<7; y++){
2555         for(x=0; x<16; x++){
2556             score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2557         }
2558         s1+= stride;
2559         s2+= stride;
2560     }
2561
2562     return score;
2563 }
2564 #else
2565 #define SQ(a) ((a)*(a))
2566
2567 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2568     int score=0;
2569     int x,y;
2570
2571     for(y=0; y<7; y++){
2572         for(x=0; x<16; x+=4){
2573             score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride])
2574                    +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2575         }
2576         s+= stride;
2577     }
2578
2579     return score;
2580 }
2581
2582 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2583     int score=0;
2584     int x,y;
2585
2586     for(y=0; y<7; y++){
2587         for(x=0; x<16; x++){
2588             score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2589         }
2590         s1+= stride;
2591         s2+= stride;
2592     }
2593
2594     return score;
2595 }
2596
2597 #endif
2598
2599 #endif //CONFIG_ENCODERS
2600
2601 /**
2602  *
2603  * @param h is the normal height, this will be reduced automatically if needed for the last row
2604  */
2605 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2606     if (    s->avctx->draw_horiz_band
2607         && (s->last_picture_ptr || s->low_delay) ) {
2608         uint8_t *src_ptr[3];
2609         int offset;
2610         h= FFMIN(h, s->height - y);
2611
2612         if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME)
2613             offset = 0;
2614         else
2615             offset = y * s->linesize;
2616
2617         if(s->pict_type==B_TYPE || s->low_delay){
2618             src_ptr[0] = s->current_picture.data[0] + offset;
2619             src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2620             src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2621         } else {
2622             src_ptr[0] = s->last_picture.data[0] + offset;
2623             src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2624             src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2625         }
2626         emms_c();
2627
2628         s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2629                                y, s->width, h);
2630     }
2631 }
2632
2633 #ifdef CONFIG_ENCODERS
2634
2635 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2636 {
2637     const int mb_x= s->mb_x;
2638     const int mb_y= s->mb_y;
2639     int i;
2640     int skip_dct[6];
2641     int dct_offset   = s->linesize*8; //default for progressive frames
2642
2643     for(i=0; i<6; i++) skip_dct[i]=0;
2644
2645     if(s->adaptive_quant){
2646         s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_stride] - s->qscale;
2647
2648         if(s->out_format==FMT_H263){
2649             if     (s->dquant> 2) s->dquant= 2;
2650             else if(s->dquant<-2) s->dquant=-2;
2651         }
2652
2653         if(s->codec_id==CODEC_ID_MPEG4){
2654             if(!s->mb_intra){
2655                 if(s->mv_dir&MV_DIRECT)
2656                     s->dquant=0;
2657
2658                 assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2659             }
2660         }
2661         s->qscale+= s->dquant;
2662         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2663         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2664     }
2665
2666     if (s->mb_intra) {
2667         uint8_t *ptr;
2668         int wrap_y;
2669         int emu=0;
2670
2671         wrap_y = s->linesize;
2672         ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2673
2674         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2675             ff_emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2676             ptr= s->edge_emu_buffer;
2677             emu=1;
2678         }
2679
2680         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2681             int progressive_score, interlaced_score;
2682
2683             progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2684             interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2685
2686             if(progressive_score > interlaced_score + 100){
2687                 s->interlaced_dct=1;
2688
2689                 dct_offset= wrap_y;
2690                 wrap_y<<=1;
2691             }else
2692                 s->interlaced_dct=0;
2693         }
2694
2695         s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2696         s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2697         s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2698         s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2699
2700         if(s->flags&CODEC_FLAG_GRAY){
2701             skip_dct[4]= 1;
2702             skip_dct[5]= 1;
2703         }else{
2704             int wrap_c = s->uvlinesize;
2705             ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2706             if(emu){
2707                 ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2708                 ptr= s->edge_emu_buffer;
2709             }
2710             s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2711
2712             ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2713             if(emu){
2714                 ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2715                 ptr= s->edge_emu_buffer;
2716             }
2717             s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2718         }
2719     }else{
2720         op_pixels_func (*op_pix)[4];
2721         qpel_mc_func (*op_qpix)[16];
2722         uint8_t *dest_y, *dest_cb, *dest_cr;
2723         uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2724         int wrap_y, wrap_c;
2725         int emu=0;
2726
2727         dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2728         dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2729         dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2730         wrap_y = s->linesize;
2731         wrap_c = s->uvlinesize;
2732         ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2733         ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2734         ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2735
2736         if ((!s->no_rounding) || s->pict_type==B_TYPE){
2737             op_pix = s->dsp.put_pixels_tab;
2738             op_qpix= s->dsp.put_qpel_pixels_tab;
2739         }else{
2740             op_pix = s->dsp.put_no_rnd_pixels_tab;
2741             op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2742         }
2743
2744         if (s->mv_dir & MV_DIR_FORWARD) {
2745             MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2746             op_pix = s->dsp.avg_pixels_tab;
2747             op_qpix= s->dsp.avg_qpel_pixels_tab;
2748         }
2749         if (s->mv_dir & MV_DIR_BACKWARD) {
2750             MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2751         }
2752
2753         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2754             ff_emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2755             ptr_y= s->edge_emu_buffer;
2756             emu=1;
2757         }
2758
2759         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2760             int progressive_score, interlaced_score;
2761
2762             progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  )
2763                              + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2764             interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2765                              + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2766
2767             if(progressive_score > interlaced_score + 600){
2768                 s->interlaced_dct=1;
2769
2770                 dct_offset= wrap_y;
2771                 wrap_y<<=1;
2772             }else
2773                 s->interlaced_dct=0;
2774         }
2775
2776         s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2777         s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2778         s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2779         s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2780
2781         if(s->flags&CODEC_FLAG_GRAY){
2782             skip_dct[4]= 1;
2783             skip_dct[5]= 1;
2784         }else{
2785             if(emu){
2786                 ff_emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2787                 ptr_cb= s->edge_emu_buffer;
2788             }
2789             s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2790             if(emu){
2791                 ff_emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2792                 ptr_cr= s->edge_emu_buffer;
2793             }
2794             s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2795         }
2796         /* pre quantization */
2797         if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
2798             //FIXME optimize
2799             if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2800             if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2801             if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2802             if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2803             if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2804             if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2805 #if 0
2806 {
2807  static int stat[7];
2808  int num=0;
2809  for(i=0; i<6; i++)
2810   if(skip_dct[i]) num++;
2811  stat[num]++;
2812
2813  if(s->mb_x==0 && s->mb_y==0){
2814   for(i=0; i<7; i++){
2815    printf("%6d %1d\n", stat[i], i);
2816   }
2817  }
2818 }
2819 #endif
2820         }
2821
2822     }
2823
2824 #if 0
2825             {
2826                 float adap_parm;
2827
2828                 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_stride*mb_y+mb_x] + 1.0) /
2829                             ((s->mb_var[s->mb_stride*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2830
2831                 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d",
2832                         (s->mb_type[s->mb_stride*mb_y+mb_x] > 0) ? 'I' : 'P',
2833                         s->qscale, adap_parm, s->qscale*adap_parm,
2834                         s->mb_var[s->mb_stride*mb_y+mb_x], s->avg_mb_var);
2835             }
2836 #endif
2837     /* DCT & quantize */
2838     if(s->out_format==FMT_MJPEG){
2839         for(i=0;i<6;i++) {
2840             int overflow;
2841             s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2842             if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2843         }
2844     }else{
2845         for(i=0;i<6;i++) {
2846             if(!skip_dct[i]){
2847                 int overflow;
2848                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2849             // FIXME we could decide to change to quantizer instead of clipping
2850             // JS: I don't think that would be a good idea it could lower quality instead
2851             //     of improve it. Just INTRADC clipping deserves changes in quantizer
2852                 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2853             }else
2854                 s->block_last_index[i]= -1;
2855         }
2856         if(s->luma_elim_threshold && !s->mb_intra)
2857             for(i=0; i<4; i++)
2858                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2859         if(s->chroma_elim_threshold && !s->mb_intra)
2860             for(i=4; i<6; i++)
2861                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2862     }
2863
2864     if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2865         s->block_last_index[4]=
2866         s->block_last_index[5]= 0;
2867         s->block[4][0]=
2868         s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
2869     }
2870
2871     /* huffman encode */
2872     switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2873     case CODEC_ID_MPEG1VIDEO:
2874         mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2875 #ifdef CONFIG_RISKY
2876     case CODEC_ID_MPEG4:
2877         mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2878     case CODEC_ID_MSMPEG4V2:
2879     case CODEC_ID_MSMPEG4V3:
2880     case CODEC_ID_WMV1:
2881         msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2882     case CODEC_ID_WMV2:
2883          ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
2884     case CODEC_ID_H263:
2885     case CODEC_ID_H263P:
2886     case CODEC_ID_RV10:
2887         h263_encode_mb(s, s->block, motion_x, motion_y); break;
2888 #endif
2889     case CODEC_ID_MJPEG:
2890         mjpeg_encode_mb(s, s->block); break;
2891     default:
2892         assert(0);
2893     }
2894 }
2895
2896 #endif //CONFIG_ENCODERS
2897
2898 /**
2899  * combines the (truncated) bitstream to a complete frame
2900  * @returns -1 if no complete frame could be created
2901  */
2902 int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
2903     ParseContext *pc= &s->parse_context;
2904
2905 #if 0
2906     if(pc->overread){
2907         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
2908         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
2909     }
2910 #endif
2911
2912     /* copy overreaded byes from last frame into buffer */
2913     for(; pc->overread>0; pc->overread--){
2914         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
2915     }
2916
2917     pc->last_index= pc->index;
2918
2919     /* copy into buffer end return */
2920     if(next == END_NOT_FOUND){
2921         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2922
2923         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
2924         pc->index += *buf_size;
2925         return -1;
2926     }
2927
2928     *buf_size=
2929     pc->overread_index= pc->index + next;
2930
2931     /* append to buffer */
2932     if(pc->index){
2933         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
2934
2935         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
2936         pc->index = 0;
2937         *buf= pc->buffer;
2938     }
2939
2940     /* store overread bytes */
2941     for(;next < 0; next++){
2942         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
2943         pc->overread++;
2944     }
2945
2946 #if 0
2947     if(pc->overread){
2948         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
2949         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
2950     }
2951 #endif
2952
2953     return 0;
2954 }
2955
2956 #ifdef CONFIG_ENCODERS
2957 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
2958 {
2959     int bytes= length>>4;
2960     int bits= length&15;
2961     int i;
2962
2963     if(length==0) return;
2964
2965     for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2966     put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2967 }
2968
2969 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2970     int i;
2971
2972     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2973
2974     /* mpeg1 */
2975     d->mb_skip_run= s->mb_skip_run;
2976     for(i=0; i<3; i++)
2977         d->last_dc[i]= s->last_dc[i];
2978
2979     /* statistics */
2980     d->mv_bits= s->mv_bits;
2981     d->i_tex_bits= s->i_tex_bits;
2982     d->p_tex_bits= s->p_tex_bits;
2983     d->i_count= s->i_count;
2984     d->f_count= s->f_count;
2985     d->b_count= s->b_count;
2986     d->skip_count= s->skip_count;
2987     d->misc_bits= s->misc_bits;
2988     d->last_bits= 0;
2989
2990     d->mb_skiped= s->mb_skiped;
2991     d->qscale= s->qscale;
2992 }
2993
2994 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2995     int i;
2996
2997     memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2998     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2999
3000     /* mpeg1 */
3001     d->mb_skip_run= s->mb_skip_run;
3002     for(i=0; i<3; i++)
3003         d->last_dc[i]= s->last_dc[i];
3004
3005     /* statistics */
3006     d->mv_bits= s->mv_bits;
3007     d->i_tex_bits= s->i_tex_bits;
3008     d->p_tex_bits= s->p_tex_bits;
3009     d->i_count= s->i_count;
3010     d->f_count= s->f_count;
3011     d->b_count= s->b_count;
3012     d->skip_count= s->skip_count;
3013     d->misc_bits= s->misc_bits;
3014
3015     d->mb_intra= s->mb_intra;
3016     d->mb_skiped= s->mb_skiped;
3017     d->mv_type= s->mv_type;
3018     d->mv_dir= s->mv_dir;
3019     d->pb= s->pb;
3020     if(s->data_partitioning){
3021         d->pb2= s->pb2;
3022         d->tex_pb= s->tex_pb;
3023     }
3024     d->block= s->block;
3025     for(i=0; i<6; i++)
3026         d->block_last_index[i]= s->block_last_index[i];
3027     d->interlaced_dct= s->interlaced_dct;
3028     d->qscale= s->qscale;
3029 }
3030
3031 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
3032                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3033                            int *dmin, int *next_block, int motion_x, int motion_y)
3034 {
3035     int bits_count;
3036
3037     copy_context_before_encode(s, backup, type);
3038
3039     s->block= s->blocks[*next_block];
3040     s->pb= pb[*next_block];
3041     if(s->data_partitioning){
3042         s->pb2   = pb2   [*next_block];
3043         s->tex_pb= tex_pb[*next_block];
3044     }
3045
3046     encode_mb(s, motion_x, motion_y);
3047
3048     bits_count= get_bit_count(&s->pb);
3049     if(s->data_partitioning){
3050         bits_count+= get_bit_count(&s->pb2);
3051         bits_count+= get_bit_count(&s->tex_pb);
3052     }
3053
3054     if(bits_count<*dmin){
3055         *dmin= bits_count;
3056         *next_block^=1;
3057
3058         copy_context_after_encode(best, s, type);
3059     }
3060 }
3061
3062 static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3063     uint32_t *sq = squareTbl + 256;
3064     int acc=0;
3065     int x,y;
3066
3067     if(w==16 && h==16)
3068         return s->dsp.sse[0](NULL, src1, src2, stride);
3069     else if(w==8 && h==8)
3070         return s->dsp.sse[1](NULL, src1, src2, stride);
3071
3072     for(y=0; y<h; y++){
3073         for(x=0; x<w; x++){
3074             acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3075         }
3076     }
3077
3078     assert(acc>=0);
3079
3080     return acc;
3081 }
3082
3083 static void encode_picture(MpegEncContext *s, int picture_number)
3084 {
3085     int mb_x, mb_y, pdif = 0;
3086     int i;
3087     int bits;
3088     MpegEncContext best_s, backup_s;
3089     uint8_t bit_buf[2][3000];
3090     uint8_t bit_buf2[2][3000];
3091     uint8_t bit_buf_tex[2][3000];
3092     PutBitContext pb[2], pb2[2], tex_pb[2];
3093
3094     for(i=0; i<2; i++){
3095         init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
3096         init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
3097         init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
3098     }
3099
3100     s->picture_number = picture_number;
3101
3102     /* Reset the average MB variance */
3103     s->current_picture.mb_var_sum = 0;
3104     s->current_picture.mc_mb_var_sum = 0;
3105
3106 #ifdef CONFIG_RISKY
3107     /* we need to initialize some time vars before we can encode b-frames */
3108     // RAL: Condition added for MPEG1VIDEO
3109     if (s->codec_id == CODEC_ID_MPEG1VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3110         ff_set_mpeg4_time(s, s->picture_number);
3111 #endif
3112
3113     s->scene_change_score=0;
3114
3115     s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
3116
3117     if(s->pict_type==I_TYPE){
3118         if(s->msmpeg4_version >= 3) s->no_rounding=1;
3119         else                        s->no_rounding=0;
3120     }else if(s->pict_type!=B_TYPE){
3121         if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3122             s->no_rounding ^= 1;
3123     }
3124
3125     /* Estimate motion for every MB */
3126     s->mb_intra=0; //for the rate distoration & bit compare functions
3127     if(s->pict_type != I_TYPE){
3128         if(s->pict_type != B_TYPE){
3129             if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3130                 s->me.pre_pass=1;
3131                 s->me.dia_size= s->avctx->pre_dia_size;
3132
3133                 for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3134                     for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3135                         s->mb_x = mb_x;
3136                         s->mb_y = mb_y;
3137                         ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3138                     }
3139                 }
3140                 s->me.pre_pass=0;
3141             }
3142         }
3143
3144         s->me.dia_size= s->avctx->dia_size;
3145         for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3146             s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3147             s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3148             s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3149             s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3150             for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3151                 s->mb_x = mb_x;
3152                 s->mb_y = mb_y;
3153                 s->block_index[0]+=2;
3154                 s->block_index[1]+=2;
3155                 s->block_index[2]+=2;
3156                 s->block_index[3]+=2;
3157
3158                 /* compute motion vector & mb_type and store in context */
3159                 if(s->pict_type==B_TYPE)
3160                     ff_estimate_b_frame_motion(s, mb_x, mb_y);
3161                 else
3162                     ff_estimate_p_frame_motion(s, mb_x, mb_y);
3163             }
3164         }
3165     }else /* if(s->pict_type == I_TYPE) */{
3166         /* I-Frame */
3167         //FIXME do we need to zero them?
3168         memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3169         memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3170         memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3171
3172         if(!s->fixed_qscale){
3173             /* finding spatial complexity for I-frame rate control */
3174             for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3175                 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3176                     int xx = mb_x * 16;
3177                     int yy = mb_y * 16;
3178                     uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3179                     int varc;
3180                     int sum = s->dsp.pix_sum(pix, s->linesize);
3181
3182                     varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3183
3184                     s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3185                     s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3186                     s->current_picture.mb_var_sum    += varc;
3187                 }
3188             }
3189         }
3190     }
3191     emms_c();
3192
3193     if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
3194         s->pict_type= I_TYPE;
3195         memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3196 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3197     }
3198
3199     if(!s->umvplus){
3200         if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3201             s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3202
3203             ff_fix_long_p_mvs(s);
3204         }
3205
3206         if(s->pict_type==B_TYPE){
3207             int a, b;
3208
3209             a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3210             b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3211             s->f_code = FFMAX(a, b);
3212
3213             a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3214             b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3215             s->b_code = FFMAX(a, b);
3216
3217             ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3218             ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3219             ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3220             ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3221         }
3222     }
3223
3224     if (s->fixed_qscale)
3225         s->frame_qscale = s->current_picture.quality;
3226     else
3227         s->frame_qscale = ff_rate_estimate_qscale(s);
3228
3229     if(s->adaptive_quant){
3230 #ifdef CONFIG_RISKY
3231         switch(s->codec_id){
3232         case CODEC_ID_MPEG4:
3233             ff_clean_mpeg4_qscales(s);
3234             break;
3235         case CODEC_ID_H263:
3236         case CODEC_ID_H263P:
3237             ff_clean_h263_qscales(s);
3238             break;
3239         }
3240 #endif
3241
3242         s->qscale= s->current_picture.qscale_table[0];
3243     }else
3244         s->qscale= (int)(s->frame_qscale + 0.5);
3245
3246     if (s->out_format == FMT_MJPEG) {
3247         /* for mjpeg, we do include qscale in the matrix */
3248         s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3249         for(i=1;i<64;i++){
3250             int j= s->dsp.idct_permutation[i];
3251
3252             s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3253         }
3254         convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3255                        s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3256     }
3257
3258     //FIXME var duplication
3259     s->current_picture.key_frame= s->pict_type == I_TYPE;
3260     s->current_picture.pict_type= s->pict_type;
3261
3262     if(s->current_picture.key_frame)
3263         s->picture_in_gop_number=0;
3264
3265     s->last_bits= get_bit_count(&s->pb);
3266     switch(s->out_format) {
3267     case FMT_MJPEG:
3268         mjpeg_picture_header(s);
3269         break;
3270 #ifdef CONFIG_RISKY
3271     case FMT_H263:
3272         if (s->codec_id == CODEC_ID_WMV2)
3273             ff_wmv2_encode_picture_header(s, picture_number);
3274         else if (s->h263_msmpeg4)
3275             msmpeg4_encode_picture_header(s, picture_number);
3276         else if (s->h263_pred)
3277             mpeg4_encode_picture_header(s, picture_number);
3278         else if (s->h263_rv10)
3279             rv10_encode_picture_header(s, picture_number);
3280         else
3281             h263_encode_picture_header(s, picture_number);
3282         break;
3283 #endif
3284     case FMT_MPEG1:
3285         mpeg1_encode_picture_header(s, picture_number);
3286         break;
3287     }
3288     bits= get_bit_count(&s->pb);
3289     s->header_bits= bits - s->last_bits;
3290     s->last_bits= bits;
3291     s->mv_bits=0;
3292     s->misc_bits=0;
3293     s->i_tex_bits=0;
3294     s->p_tex_bits=0;
3295     s->i_count=0;
3296     s->f_count=0;
3297     s->b_count=0;
3298     s->skip_count=0;
3299
3300     for(i=0; i<3; i++){
3301         /* init last dc values */
3302         /* note: quant matrix value (8) is implied here */
3303         s->last_dc[i] = 128;
3304
3305         s->current_picture_ptr->error[i] = 0;
3306     }
3307     s->mb_skip_run = 0;
3308     s->last_mv[0][0][0] = 0;
3309     s->last_mv[0][0][1] = 0;
3310     s->last_mv[1][0][0] = 0;
3311     s->last_mv[1][0][1] = 0;
3312
3313     s->last_mv_dir = 0;
3314
3315 #ifdef CONFIG_RISKY
3316     if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
3317         s->gob_index = ff_h263_get_gob_height(s);
3318
3319     if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3320         ff_mpeg4_init_partitions(s);
3321 #endif
3322
3323     s->resync_mb_x=0;
3324     s->resync_mb_y=0;
3325     s->first_slice_line = 1;
3326     s->ptr_lastgob = s->pb.buf;
3327     for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3328         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3329         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3330
3331         s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3332         s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3333         s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3334         s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3335         s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
3336         s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
3337         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3338             const int xy= mb_y*s->mb_stride + mb_x;
3339             int mb_type= s->mb_type[xy];
3340 //            int d;
3341             int dmin=10000000;
3342
3343             s->mb_x = mb_x;
3344             s->mb_y = mb_y;
3345             s->block_index[0]+=2;
3346             s->block_index[1]+=2;
3347             s->block_index[2]+=2;
3348             s->block_index[3]+=2;
3349             s->block_index[4]++;
3350             s->block_index[5]++;
3351
3352             /* write gob / video packet header  */
3353 #ifdef CONFIG_RISKY
3354             if(s->rtp_mode){
3355                 int current_packet_size, is_gob_start;
3356
3357                 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3358                 is_gob_start=0;
3359
3360                 if(s->codec_id==CODEC_ID_MPEG4){
3361                     if(current_packet_size >= s->rtp_payload_size
3362                        && s->mb_y + s->mb_x>0){
3363
3364                         if(s->partitioned_frame){
3365                             ff_mpeg4_merge_partitions(s);
3366                             ff_mpeg4_init_partitions(s);
3367                         }
3368                         ff_mpeg4_encode_video_packet_header(s);
3369
3370                         if(s->flags&CODEC_FLAG_PASS1){
3371                             int bits= get_bit_count(&s->pb);
3372                             s->misc_bits+= bits - s->last_bits;
3373                             s->last_bits= bits;
3374                         }
3375                         ff_mpeg4_clean_buffers(s);
3376                         is_gob_start=1;
3377                     }
3378                 }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3379                     if(   current_packet_size >= s->rtp_payload_size
3380                        && s->mb_y + s->mb_x>0 && s->mb_skip_run==0){
3381                         ff_mpeg1_encode_slice_header(s);
3382                         ff_mpeg1_clean_buffers(s);
3383                         is_gob_start=1;
3384                     }
3385                 }else{
3386                     if(current_packet_size >= s->rtp_payload_size
3387                        && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3388
3389                         h263_encode_gob_header(s, mb_y);
3390                         is_gob_start=1;
3391                     }
3392                 }
3393
3394                 if(is_gob_start){
3395                     s->ptr_lastgob = pbBufPtr(&s->pb);
3396                     s->first_slice_line=1;
3397                     s->resync_mb_x=mb_x;
3398                     s->resync_mb_y=mb_y;
3399                 }
3400             }
3401 #endif
3402
3403             if(  (s->resync_mb_x   == s->mb_x)
3404                && s->resync_mb_y+1 == s->mb_y){
3405                 s->first_slice_line=0;
3406             }
3407
3408             if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3409                 int next_block=0;
3410                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3411
3412                 copy_context_before_encode(&backup_s, s, -1);
3413                 backup_s.pb= s->pb;
3414                 best_s.data_partitioning= s->data_partitioning;
3415                 best_s.partitioned_frame= s->partitioned_frame;
3416                 if(s->data_partitioning){
3417                     backup_s.pb2= s->pb2;
3418                     backup_s.tex_pb= s->tex_pb;
3419                 }
3420
3421                 if(mb_type&MB_TYPE_INTER){
3422                     s->mv_dir = MV_DIR_FORWARD;
3423                     s->mv_type = MV_TYPE_16X16;
3424                     s->mb_intra= 0;
3425                     s->mv[0][0][0] = s->p_mv_table[xy][0];
3426                     s->mv[0][0][1] = s->p_mv_table[xy][1];
3427                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,
3428                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3429                 }
3430                 if(mb_type&MB_TYPE_INTER4V){
3431                     s->mv_dir = MV_DIR_FORWARD;
3432                     s->mv_type = MV_TYPE_8X8;
3433                     s->mb_intra= 0;
3434                     for(i=0; i<4; i++){
3435                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3436                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3437                     }
3438                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,
3439                                  &dmin, &next_block, 0, 0);
3440                 }
3441                 if(mb_type&MB_TYPE_FORWARD){
3442                     s->mv_dir = MV_DIR_FORWARD;
3443                     s->mv_type = MV_TYPE_16X16;
3444                     s->mb_intra= 0;
3445                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3446                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3447                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,
3448                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3449                 }
3450                 if(mb_type&MB_TYPE_BACKWARD){
3451                     s->mv_dir = MV_DIR_BACKWARD;
3452                     s->mv_type = MV_TYPE_16X16;
3453                     s->mb_intra= 0;
3454                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3455                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3456                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3457                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3458                 }
3459                 if(mb_type&MB_TYPE_BIDIR){
3460                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3461                     s->mv_type = MV_TYPE_16X16;
3462                     s->mb_intra= 0;
3463                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3464                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3465                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3466                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3467                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,
3468                                  &dmin, &next_block, 0, 0);
3469                 }
3470                 if(mb_type&MB_TYPE_DIRECT){
3471                     int mx= s->b_direct_mv_table[xy][0];
3472                     int my= s->b_direct_mv_table[xy][1];
3473
3474                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3475                     s->mb_intra= 0;
3476 #ifdef CONFIG_RISKY
3477                     ff_mpeg4_set_direct_mv(s, mx, my);
3478 #endif
3479                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
3480                                  &dmin, &next_block, mx, my);
3481                 }
3482                 if(mb_type&MB_TYPE_INTRA){
3483                     s->mv_dir = 0;
3484                     s->mv_type = MV_TYPE_16X16;
3485                     s->mb_intra= 1;
3486                     s->mv[0][0][0] = 0;
3487                     s->mv[0][0][1] = 0;
3488                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
3489                                  &dmin, &next_block, 0, 0);
3490                     /* force cleaning of ac/dc pred stuff if needed ... */
3491                     if(s->h263_pred || s->h263_aic)
3492                         s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3493                 }
3494                 copy_context_after_encode(s, &best_s, -1);
3495
3496                 pb_bits_count= get_bit_count(&s->pb);
3497                 flush_put_bits(&s->pb);
3498                 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3499                 s->pb= backup_s.pb;
3500
3501                 if(s->data_partitioning){
3502                     pb2_bits_count= get_bit_count(&s->pb2);
3503                     flush_put_bits(&s->pb2);
3504                     ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3505                     s->pb2= backup_s.pb2;
3506
3507                     tex_pb_bits_count= get_bit_count(&s->tex_pb);
3508                     flush_put_bits(&s->tex_pb);
3509                     ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3510                     s->tex_pb= backup_s.tex_pb;
3511                 }
3512                 s->last_bits= get_bit_count(&s->pb);
3513             } else {
3514                 int motion_x, motion_y;
3515                 int intra_score;
3516                 int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3517
3518               if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
3519                 /* get luma score */
3520                 if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3521                     intra_score= (s->current_picture.mb_var[mb_x + mb_y*s->mb_stride]<<8) - 500; //FIXME dont scale it down so we dont have to fix it
3522                 }else{
3523                     uint8_t *dest_y;
3524
3525                     int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3526                     mean*= 0x01010101;
3527
3528                     dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3529
3530                     for(i=0; i<16; i++){
3531                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3532                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3533                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3534                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3535                     }
3536
3537                     s->mb_intra=1;
3538                     intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3539
3540 /*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8,
3541                         s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3542                         s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3543                 }
3544
3545                 /* get chroma score */
3546                 if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3547                     int i;
3548
3549                     s->mb_intra=1;
3550                     for(i=1; i<3; i++){
3551                         uint8_t *dest_c;
3552                         int mean;
3553
3554                         if(s->out_format == FMT_H263){
3555                             mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3556                         }else{
3557                             mean= (s->last_dc[i] + 4)>>3;
3558                         }
3559                         dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3560
3561                         mean*= 0x01010101;
3562                         for(i=0; i<8; i++){
3563                             *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3564                             *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3565                         }
3566
3567                         intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3568                     }
3569                 }
3570
3571                 /* bias */
3572                 switch(s->avctx->mb_cmp&0xFF){
3573                 default:
3574                 case FF_CMP_SAD:
3575                     intra_score+= 32*s->qscale;
3576                     break;
3577                 case FF_CMP_SSE:
3578                     intra_score+= 24*s->qscale*s->qscale;
3579                     break;
3580                 case FF_CMP_SATD:
3581                     intra_score+= 96*s->qscale;
3582                     break;
3583                 case FF_CMP_DCT:
3584                     intra_score+= 48*s->qscale;
3585                     break;
3586                 case FF_CMP_BIT:
3587                     intra_score+= 16;
3588                     break;
3589                 case FF_CMP_PSNR:
3590                 case FF_CMP_RD:
3591                     intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3592                     break;
3593                 }
3594
3595                 if(intra_score < inter_score)
3596                     mb_type= MB_TYPE_INTRA;
3597               }
3598
3599                 s->mv_type=MV_TYPE_16X16;
3600                 // only one MB-Type possible
3601
3602                 switch(mb_type){
3603                 case MB_TYPE_INTRA:
3604                     s->mv_dir = 0;
3605                     s->mb_intra= 1;
3606                     motion_x= s->mv[0][0][0] = 0;
3607                     motion_y= s->mv[0][0][1] = 0;
3608                     break;
3609                 case MB_TYPE_INTER:
3610                     s->mv_dir = MV_DIR_FORWARD;
3611                     s->mb_intra= 0;
3612                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3613                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3614                     break;
3615                 case MB_TYPE_INTER4V:
3616                     s->mv_dir = MV_DIR_FORWARD;
3617                     s->mv_type = MV_TYPE_8X8;
3618                     s->mb_intra= 0;
3619                     for(i=0; i<4; i++){
3620                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3621                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3622                     }
3623                     motion_x= motion_y= 0;
3624                     break;
3625                 case MB_TYPE_DIRECT:
3626                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3627                     s->mb_intra= 0;
3628                     motion_x=s->b_direct_mv_table[xy][0];
3629                     motion_y=s->b_direct_mv_table[xy][1];
3630 #ifdef CONFIG_RISKY
3631                     ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3632 #endif
3633                     break;
3634                 case MB_TYPE_BIDIR:
3635                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3636                     s->mb_intra= 0;
3637                     motion_x=0;
3638                     motion_y=0;
3639                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3640                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3641                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3642                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3643                     break;
3644                 case MB_TYPE_BACKWARD:
3645                     s->mv_dir = MV_DIR_BACKWARD;
3646                     s->mb_intra= 0;
3647                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3648                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3649                     break;
3650                 case MB_TYPE_FORWARD:
3651                     s->mv_dir = MV_DIR_FORWARD;
3652                     s->mb_intra= 0;
3653                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3654                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3655 //                    printf(" %d %d ", motion_x, motion_y);
3656                     break;
3657                 default:
3658                     motion_x=motion_y=0; //gcc warning fix
3659                     printf("illegal MB type\n");
3660                 }
3661
3662                 encode_mb(s, motion_x, motion_y);
3663
3664                 // RAL: Update last macrobloc type
3665                 s->last_mv_dir = s->mv_dir;
3666             }
3667
3668             /* clean the MV table in IPS frames for direct mode in B frames */
3669             if(s->mb_intra /* && I,P,S_TYPE */){
3670                 s->p_mv_table[xy][0]=0;
3671                 s->p_mv_table[xy][1]=0;
3672             }
3673
3674             MPV_decode_mb(s, s->block);
3675
3676             if(s->flags&CODEC_FLAG_PSNR){
3677                 int w= 16;
3678                 int h= 16;
3679
3680                 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3681                 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3682
3683                 s->current_picture_ptr->error[0] += sse(
3684                     s,
3685                     s->new_picture    .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3686                     s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3687                     w, h, s->linesize);
3688                 s->current_picture_ptr->error[1] += sse(
3689                     s,
3690                     s->new_picture    .data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3691                     s->current_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3692                     w>>1, h>>1, s->uvlinesize);
3693                 s->current_picture_ptr->error[2] += sse(
3694                     s,
3695                     s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3696                     s->current_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3697                     w>>1, h>>1, s->uvlinesize);
3698             }
3699 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3700         }
3701     }
3702     emms_c();
3703
3704 #ifdef CONFIG_RISKY
3705     if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3706         ff_mpeg4_merge_partitions(s);
3707
3708     if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3709         msmpeg4_encode_ext_header(s);
3710
3711     if(s->codec_id==CODEC_ID_MPEG4)
3712         ff_mpeg4_stuffing(&s->pb);
3713 #endif
3714
3715     //if (s->gob_number)
3716     //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3717
3718     /* Send the last GOB if RTP */
3719     if (s->rtp_mode) {
3720         flush_put_bits(&s->pb);
3721         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3722         /* Call the RTP callback to send the last GOB */
3723         if (s->rtp_callback)
3724             s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3725         s->ptr_lastgob = pbBufPtr(&s->pb);
3726         //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3727     }
3728 }
3729
3730 static int dct_quantize_trellis_c(MpegEncContext *s,
3731                         DCTELEM *block, int n,
3732                         int qscale, int *overflow){
3733     const int *qmat;
3734     const uint8_t *scantable= s->intra_scantable.scantable;
3735     int max=0;
3736     unsigned int threshold1, threshold2;
3737     int bias=0;
3738     int run_tab[65];
3739     int level_tab[65];
3740     int score_tab[65];
3741     int last_run=0;
3742     int last_level=0;
3743     int last_score= 0;
3744     int last_i= 0;
3745     int coeff[3][64];
3746     int coeff_count[64];
3747     int lambda, qmul, qadd, start_i, last_non_zero, i;
3748     const int esc_length= s->ac_esc_length;
3749     uint8_t * length;
3750     uint8_t * last_length;
3751     int score_limit=0;
3752     int left_limit= 0;
3753
3754     s->dsp.fdct (block);
3755
3756     qmul= qscale*16;
3757     qadd= ((qscale-1)|1)*8;
3758
3759     if (s->mb_intra) {
3760         int q;
3761         if (!s->h263_aic) {
3762             if (n < 4)
3763                 q = s->y_dc_scale;
3764             else
3765                 q = s->c_dc_scale;
3766             q = q << 3;
3767         } else{
3768             /* For AIC we skip quant/dequant of INTRADC */
3769             q = 1 << 3;
3770             qadd=0;
3771         }
3772
3773         /* note: block[0] is assumed to be positive */
3774         block[0] = (block[0] + (q >> 1)) / q;
3775         start_i = 1;
3776         last_non_zero = 0;
3777         qmat = s->q_intra_matrix[qscale];
3778         if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3779             bias= 1<<(QMAT_SHIFT-1);
3780         length     = s->intra_ac_vlc_length;
3781         last_length= s->intra_ac_vlc_last_length;
3782     } else {
3783         start_i = 0;
3784         last_non_zero = -1;
3785         qmat = s->q_inter_matrix[qscale];
3786         length     = s->inter_ac_vlc_length;
3787         last_length= s->inter_ac_vlc_last_length;
3788     }
3789
3790     threshold1= (1<<QMAT_SHIFT) - bias - 1;
3791     threshold2= (threshold1<<1);
3792
3793     for(i=start_i; i<64; i++) {
3794         const int j = scantable[i];
3795         const int k= i-start_i;
3796         int level = block[j];
3797         level = level * qmat[j];
3798
3799 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3800 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3801         if(((unsigned)(level+threshold1))>threshold2){
3802             if(level>0){
3803                 level= (bias + level)>>QMAT_SHIFT;
3804                 coeff[0][k]= level;
3805                 coeff[1][k]= level-1;
3806 //                coeff[2][k]= level-2;
3807             }else{
3808                 level= (bias - level)>>QMAT_SHIFT;
3809                 coeff[0][k]= -level;
3810                 coeff[1][k]= -level+1;
3811 //                coeff[2][k]= -level+2;
3812             }
3813             coeff_count[k]= FFMIN(level, 2);
3814             max |=level;
3815             last_non_zero = i;
3816         }else{
3817             coeff[0][k]= (level>>31)|1;
3818             coeff_count[k]= 1;
3819         }
3820     }
3821
3822     *overflow= s->max_qcoeff < max; //overflow might have happend
3823
3824     if(last_non_zero < start_i){
3825         memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3826         return last_non_zero;
3827     }
3828
3829     lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
3830
3831     score_tab[0]= 0;
3832     for(i=0; i<=last_non_zero - start_i; i++){
3833         int level_index, run, j;
3834         const int dct_coeff= block[ scantable[i + start_i] ];
3835         const int zero_distoration= dct_coeff*dct_coeff;
3836         int best_score=256*256*256*120;
3837
3838         last_score += zero_distoration;
3839         for(level_index=0; level_index < coeff_count[i]; level_index++){
3840             int distoration;
3841             int level= coeff[level_index][i];
3842             int unquant_coeff;
3843
3844             assert(level);
3845
3846             if(s->out_format == FMT_H263){
3847                 if(level>0){
3848                     unquant_coeff= level*qmul + qadd;
3849                 }else{
3850                     unquant_coeff= level*qmul - qadd;
3851                 }
3852             }else{ //MPEG1
3853                 j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
3854                 if(s->mb_intra){
3855                     if (level < 0) {
3856                         unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
3857                         unquant_coeff = -((unquant_coeff - 1) | 1);
3858                     } else {
3859                         unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
3860                         unquant_coeff =   (unquant_coeff - 1) | 1;
3861                     }
3862                 }else{
3863                     if (level < 0) {
3864                         unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3865                         unquant_coeff = -((unquant_coeff - 1) | 1);
3866                     } else {
3867                         unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3868                         unquant_coeff =   (unquant_coeff - 1) | 1;
3869                     }
3870                 }
3871                 unquant_coeff<<= 3;
3872             }
3873
3874             distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
3875             level+=64;
3876             if((level&(~127)) == 0){
3877                 for(run=0; run<=i - left_limit; run++){
3878                     int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3879                     score += score_tab[i-run];
3880
3881                     if(score < best_score){
3882                         best_score=
3883                         score_tab[i+1]= score;
3884                         run_tab[i+1]= run;
3885                         level_tab[i+1]= level-64;
3886                     }
3887                 }
3888
3889                 if(s->out_format == FMT_H263){
3890                     for(run=0; run<=i - left_limit; run++){
3891                         int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3892                         score += score_tab[i-run];
3893                         if(score < last_score){
3894                             last_score= score;
3895                             last_run= run;
3896                             last_level= level-64;
3897                             last_i= i+1;
3898                         }
3899                     }
3900                 }
3901             }else{
3902                 distoration += esc_length*lambda;
3903                 for(run=0; run<=i - left_limit; run++){
3904                     int score= distoration + score_tab[i-run];
3905
3906                     if(score < best_score){
3907                         best_score=
3908                         score_tab[i+1]= score;
3909                         run_tab[i+1]= run;
3910                         level_tab[i+1]= level-64;
3911                     }
3912                 }
3913
3914                 if(s->out_format == FMT_H263){
3915                     for(run=0; run<=i - left_limit; run++){
3916                         int score= distoration + score_tab[i-run];
3917                         if(score < last_score){
3918                             last_score= score;
3919                             last_run= run;
3920                             last_level= level-64;
3921                             last_i= i+1;
3922                         }
3923                     }
3924                 }
3925             }
3926         }
3927
3928         for(j=left_limit; j<=i; j++){
3929             score_tab[j] += zero_distoration;
3930         }
3931         score_limit+= zero_distoration;
3932         if(score_tab[i+1] < score_limit)
3933             score_limit= score_tab[i+1];
3934
3935         //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3936         while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
3937     }
3938
3939         //FIXME add some cbp penalty
3940
3941     if(s->out_format != FMT_H263){
3942         last_score= 256*256*256*120;
3943         for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
3944             int score= score_tab[i];
3945             if(i) score += lambda*2; //FIXME exacter?
3946
3947             if(score < last_score){
3948                 last_score= score;
3949                 last_i= i;
3950                 last_level= level_tab[i];
3951                 last_run= run_tab[i];
3952             }
3953         }
3954     }
3955
3956     last_non_zero= last_i - 1 + start_i;
3957     memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3958
3959     if(last_non_zero < start_i)
3960         return last_non_zero;
3961
3962     i= last_i;
3963     assert(last_level);
3964 //FIXME use permutated scantable
3965     block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
3966     i -= last_run + 1;
3967
3968     for(;i>0 ; i -= run_tab[i] + 1){
3969         const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
3970
3971         block[j]= level_tab[i];
3972         assert(block[j]);
3973     }
3974
3975     return last_non_zero;
3976 }
3977
3978 static int dct_quantize_c(MpegEncContext *s,
3979                         DCTELEM *block, int n,
3980                         int qscale, int *overflow)
3981 {
3982     int i, j, level, last_non_zero, q;
3983     const int *qmat;
3984     const uint8_t *scantable= s->intra_scantable.scantable;
3985     int bias;
3986     int max=0;
3987     unsigned int threshold1, threshold2;
3988
3989     s->dsp.fdct (block);
3990
3991     if (s->mb_intra) {
3992         if (!s->h263_aic) {
3993             if (n < 4)
3994                 q = s->y_dc_scale;
3995             else
3996                 q = s->c_dc_scale;
3997             q = q << 3;
3998         } else
3999             /* For AIC we skip quant/dequant of INTRADC */
4000             q = 1 << 3;
4001
4002         /* note: block[0] is assumed to be positive */
4003         block[0] = (block[0] + (q >> 1)) / q;
4004         i = 1;
4005         last_non_zero = 0;
4006         qmat = s->q_intra_matrix[qscale];
4007         bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4008     } else {
4009         i = 0;
4010         last_non_zero = -1;
4011         qmat = s->q_inter_matrix[qscale];
4012         bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4013     }
4014     threshold1= (1<<QMAT_SHIFT) - bias - 1;
4015     threshold2= (threshold1<<1);
4016
4017     for(;i<64;i++) {
4018         j = scantable[i];
4019         level = block[j];
4020         level = level * qmat[j];
4021
4022 //        if(   bias+level >= (1<<QMAT_SHIFT)
4023 //           || bias-level >= (1<<QMAT_SHIFT)){
4024         if(((unsigned)(level+threshold1))>threshold2){
4025             if(level>0){
4026                 level= (bias + level)>>QMAT_SHIFT;
4027                 block[j]= level;
4028             }else{
4029                 level= (bias - level)>>QMAT_SHIFT;
4030                 block[j]= -level;
4031             }
4032             max |=level;
4033             last_non_zero = i;
4034         }else{
4035             block[j]=0;
4036         }
4037     }
4038     *overflow= s->max_qcoeff < max; //overflow might have happend
4039
4040     /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4041     if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4042         ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4043
4044     return last_non_zero;
4045 }
4046
4047 #endif //CONFIG_ENCODERS
4048
4049 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
4050                                    DCTELEM *block, int n, int qscale)
4051 {
4052     int i, level, nCoeffs;
4053     const uint16_t *quant_matrix;
4054
4055     nCoeffs= s->block_last_index[n];
4056
4057     if (s->mb_intra) {
4058         if (n < 4)
4059             block[0] = block[0] * s->y_dc_scale;
4060         else
4061             block[0] = block[0] * s->c_dc_scale;
4062         /* XXX: only mpeg1 */
4063         quant_matrix = s->intra_matrix;
4064         for(i=1;i<=nCoeffs;i++) {
4065             int j= s->intra_scantable.permutated[i];
4066             level = block[j];
4067             if (level) {
4068                 if (level < 0) {
4069                     level = -level;
4070                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
4071                     level = (level - 1) | 1;
4072                     level = -level;
4073                 } else {
4074                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
4075                     level = (level - 1) | 1;
4076                 }
4077 #ifdef PARANOID
4078                 if (level < -2048 || level > 2047)
4079                     fprintf(stderr, "unquant error %d %d\n", i, level);
4080 #endif
4081                 block[j] = level;
4082             }
4083         }
4084     } else {
4085         i = 0;
4086         quant_matrix = s->inter_matrix;
4087         for(;i<=nCoeffs;i++) {
4088             int j= s->intra_scantable.permutated[i];
4089             level = block[j];
4090             if (level) {
4091                 if (level < 0) {
4092                     level = -level;
4093                     level = (((level << 1) + 1) * qscale *
4094                              ((int) (quant_matrix[j]))) >> 4;
4095                     level = (level - 1) | 1;
4096                     level = -level;
4097                 } else {
4098                     level = (((level << 1) + 1) * qscale *
4099                              ((int) (quant_matrix[j]))) >> 4;
4100                     level = (level - 1) | 1;
4101                 }
4102 #ifdef PARANOID
4103                 if (level < -2048 || level > 2047)
4104                     fprintf(stderr, "unquant error %d %d\n", i, level);
4105 #endif
4106                 block[j] = level;
4107             }
4108         }
4109     }
4110 }
4111
4112 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
4113                                    DCTELEM *block, int n, int qscale)
4114 {
4115     int i, level, nCoeffs;
4116     const uint16_t *quant_matrix;
4117
4118     if(s->alternate_scan) nCoeffs= 63;
4119     else nCoeffs= s->block_last_index[n];
4120
4121     if (s->mb_intra) {
4122         if (n < 4)
4123             block[0] = block[0] * s->y_dc_scale;
4124         else
4125             block[0] = block[0] * s->c_dc_scale;
4126         quant_matrix = s->intra_matrix;
4127         for(i=1;i<=nCoeffs;i++) {
4128             int j= s->intra_scantable.permutated[i];
4129             level = block[j];
4130             if (level) {
4131                 if (level < 0) {
4132                     level = -level;
4133                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
4134                     level = -level;
4135                 } else {
4136                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
4137                 }
4138 #ifdef PARANOID
4139                 if (level < -2048 || level > 2047)
4140                     fprintf(stderr, "unquant error %d %d\n", i, level);
4141 #endif
4142                 block[j] = level;
4143             }
4144         }
4145     } else {
4146         int sum=-1;
4147         i = 0;
4148         quant_matrix = s->inter_matrix;
4149         for(;i<=nCoeffs;i++) {
4150             int j= s->intra_scantable.permutated[i];
4151             level = block[j];
4152             if (level) {
4153                 if (level < 0) {
4154                     level = -level;
4155                     level = (((level << 1) + 1) * qscale *
4156                              ((int) (quant_matrix[j]))) >> 4;
4157                     level = -level;
4158                 } else {
4159                     level = (((level << 1) + 1) * qscale *
4160                              ((int) (quant_matrix[j]))) >> 4;
4161                 }
4162 #ifdef PARANOID
4163                 if (level < -2048 || level > 2047)
4164                     fprintf(stderr, "unquant error %d %d\n", i, level);
4165 #endif
4166                 block[j] = level;
4167                 sum+=level;
4168             }
4169         }
4170         block[63]^=sum&1;
4171     }
4172 }
4173
4174
4175 static void dct_unquantize_h263_c(MpegEncContext *s,
4176                                   DCTELEM *block, int n, int qscale)
4177 {
4178     int i, level, qmul, qadd;
4179     int nCoeffs;
4180
4181     assert(s->block_last_index[n]>=0);
4182
4183     qadd = (qscale - 1) | 1;
4184     qmul = qscale << 1;
4185
4186     if (s->mb_intra) {
4187         if (!s->h263_aic) {
4188             if (n < 4)
4189                 block[0] = block[0] * s->y_dc_scale;
4190             else
4191                 block[0] = block[0] * s->c_dc_scale;
4192         }else
4193             qadd = 0;
4194         i = 1;
4195         nCoeffs= 63; //does not allways use zigzag table
4196     } else {
4197         i = 0;
4198         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
4199     }
4200
4201     for(;i<=nCoeffs;i++) {
4202         level = block[i];
4203         if (level) {
4204             if (level < 0) {
4205                 level = level * qmul - qadd;
4206             } else {
4207                 level = level * qmul + qadd;
4208             }
4209 #ifdef PARANOID
4210                 if (level < -2048 || level > 2047)
4211                     fprintf(stderr, "unquant error %d %d\n", i, level);
4212 #endif
4213             block[i] = level;
4214         }
4215     }
4216 }
4217
4218
4219 static const AVOption mpeg4_options[] =
4220 {
4221     AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4222     AVOPTION_CODEC_FLAG("vhq", "very high quality", flags, CODEC_FLAG_HQ, 0),
4223     AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4224                        "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4225                        bit_rate_tolerance, 4, 240000000, 8000),
4226     AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4227     AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
4228     AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
4229                           rc_eq, "tex^qComp,option1,options2", 0),
4230     AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
4231                        rc_min_rate, 4, 24000000, 0),
4232     AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
4233                        rc_max_rate, 4, 24000000, 0),
4234     AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
4235                           rc_buffer_aggressivity, 4, 24000000, 0),
4236     AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
4237                           rc_initial_cplx, 0., 9999999., 0),
4238     AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
4239                           i_quant_factor, 0., 0., 0),
4240     AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
4241                           i_quant_factor, -999999., 999999., 0),
4242     AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
4243                        dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
4244     AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
4245                           lumi_masking, 0., 999999., 0),
4246     AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4247                           temporal_cplx_masking, 0., 999999., 0),
4248     AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4249                           spatial_cplx_masking, 0., 999999., 0),
4250     AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4251                           p_masking, 0., 999999., 0),
4252     AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4253                           dark_masking, 0., 999999., 0),
4254     AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4255                        idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4256
4257     AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4258                        mb_qmin, 0, 8, 0),
4259     AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4260                        mb_qmin, 0, 8, 0),
4261
4262     AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4263                        me_cmp, 0, 24000000, 0),
4264     AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4265                        me_sub_cmp, 0, 24000000, 0),
4266
4267
4268     AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4269                        dia_size, 0, 24000000, 0),
4270     AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4271                        last_predictor_count, 0, 24000000, 0),
4272
4273     AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4274                        pre_me, 0, 24000000, 0),
4275     AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4276                        me_pre_cmp, 0, 24000000, 0),
4277
4278     AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4279                        me_range, 0, 24000000, 0),
4280     AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4281                        pre_dia_size, 0, 24000000, 0),
4282     AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4283                        me_subpel_quality, 0, 24000000, 0),
4284     AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4285                        me_range, 0, 24000000, 0),
4286     AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4287                         flags, CODEC_FLAG_PSNR, 0),
4288     AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4289                               rc_override),
4290     AVOPTION_SUB(avoptions_common),
4291     AVOPTION_END()
4292 };
4293
4294 #ifdef CONFIG_ENCODERS
4295
4296 AVCodec mpeg1video_encoder = {
4297     "mpeg1video",
4298     CODEC_TYPE_VIDEO,
4299     CODEC_ID_MPEG1VIDEO,
4300     sizeof(MpegEncContext),
4301     MPV_encode_init,
4302     MPV_encode_picture,
4303     MPV_encode_end,
4304 };
4305
4306 #ifdef CONFIG_RISKY
4307
4308 AVCodec h263_encoder = {
4309     "h263",
4310     CODEC_TYPE_VIDEO,
4311     CODEC_ID_H263,
4312     sizeof(MpegEncContext),
4313     MPV_encode_init,
4314     MPV_encode_picture,
4315     MPV_encode_end,
4316 };
4317
4318 AVCodec h263p_encoder = {
4319     "h263p",
4320     CODEC_TYPE_VIDEO,
4321     CODEC_ID_H263P,
4322     sizeof(MpegEncContext),
4323     MPV_encode_init,
4324     MPV_encode_picture,
4325     MPV_encode_end,
4326 };
4327
4328 AVCodec rv10_encoder = {
4329     "rv10",
4330     CODEC_TYPE_VIDEO,
4331     CODEC_ID_RV10,
4332     sizeof(MpegEncContext),
4333     MPV_encode_init,
4334     MPV_encode_picture,
4335     MPV_encode_end,
4336 };
4337
4338 AVCodec mpeg4_encoder = {
4339     "mpeg4",
4340     CODEC_TYPE_VIDEO,
4341     CODEC_ID_MPEG4,
4342     sizeof(MpegEncContext),
4343     MPV_encode_init,
4344     MPV_encode_picture,
4345     MPV_encode_end,
4346     .options = mpeg4_options,
4347 };
4348
4349 AVCodec msmpeg4v1_encoder = {
4350     "msmpeg4v1",
4351     CODEC_TYPE_VIDEO,
4352     CODEC_ID_MSMPEG4V1,
4353     sizeof(MpegEncContext),
4354     MPV_encode_init,
4355     MPV_encode_picture,
4356     MPV_encode_end,
4357     .options = mpeg4_options,
4358 };
4359
4360 AVCodec msmpeg4v2_encoder = {
4361     "msmpeg4v2",
4362     CODEC_TYPE_VIDEO,
4363     CODEC_ID_MSMPEG4V2,
4364     sizeof(MpegEncContext),
4365     MPV_encode_init,
4366     MPV_encode_picture,
4367     MPV_encode_end,
4368     .options = mpeg4_options,
4369 };
4370
4371 AVCodec msmpeg4v3_encoder = {
4372     "msmpeg4",
4373     CODEC_TYPE_VIDEO,
4374     CODEC_ID_MSMPEG4V3,
4375     sizeof(MpegEncContext),
4376     MPV_encode_init,
4377     MPV_encode_picture,
4378     MPV_encode_end,
4379     .options = mpeg4_options,
4380 };
4381
4382 AVCodec wmv1_encoder = {
4383     "wmv1",
4384     CODEC_TYPE_VIDEO,
4385     CODEC_ID_WMV1,
4386     sizeof(MpegEncContext),
4387     MPV_encode_init,
4388     MPV_encode_picture,
4389     MPV_encode_end,
4390     .options = mpeg4_options,
4391 };
4392
4393 #endif
4394
4395 AVCodec mjpeg_encoder = {
4396     "mjpeg",
4397     CODEC_TYPE_VIDEO,
4398     CODEC_ID_MJPEG,
4399     sizeof(MpegEncContext),
4400     MPV_encode_init,
4401     MPV_encode_picture,
4402     MPV_encode_end,
4403 };
4404
4405 #endif //CONFIG_ENCODERS
4406