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