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