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