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