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