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