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