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         s->low_delay=0; //needed to see the vectors without trashing the buffers
1724
1725         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1726         for(i=0; i<3; i++){
1727             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1728             pict->data[i]= s->visualization_buffer[i];
1729         }
1730         pict->type= FF_BUFFER_TYPE_COPY;
1731         ptr= pict->data[0];
1732
1733         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1734             int mb_x;
1735             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1736                 const int mb_index= mb_x + mb_y*s->mb_stride;
1737                 if((s->avctx->debug_mv) && pict->motion_val){
1738                   int type;
1739                   for(type=0; type<3; type++){
1740                     int direction = 0;
1741                     switch (type) {
1742                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1743                                 continue;
1744                               direction = 0;
1745                               break;
1746                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1747                                 continue;
1748                               direction = 0;
1749                               break;
1750                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1751                                 continue;
1752                               direction = 1;
1753                               break;
1754                     }
1755                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1756                         continue;
1757
1758                     //FIXME for h264
1759                     if(IS_8X8(pict->mb_type[mb_index])){
1760                       int i;
1761                       for(i=0; i<4; i++){
1762                         int sx= mb_x*16 + 4 + 8*(i&1);
1763                         int sy= mb_y*16 + 4 + 8*(i>>1);
1764                         int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1765                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1766                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1767                         draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1768                       }
1769                     }else if(IS_16X8(pict->mb_type[mb_index])){
1770                       int i;
1771                       for(i=0; i<2; i++){
1772                         int sx=mb_x*16 + 8;
1773                         int sy=mb_y*16 + 4 + 8*i;
1774                         int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1775                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1776                         int my=(pict->motion_val[direction][xy][1]>>shift);
1777
1778                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1779                             my*=2;
1780
1781                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, s->width, s->height, s->linesize, 100);
1782                       }
1783                     }else{
1784                       int sx= mb_x*16 + 8;
1785                       int sy= mb_y*16 + 8;
1786                       int xy= mb_x*2 + mb_y*2*s->b8_stride;
1787                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1788                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1789                       draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1790                     }
1791                   }
1792                 }
1793                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1794                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1795                     int y;
1796                     for(y=0; y<8; y++){
1797                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1798                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1799                     }
1800                 }
1801                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1802                     int mb_type= pict->mb_type[mb_index];
1803                     uint64_t u,v;
1804                     int y;
1805 #define COLOR(theta, r)\
1806 u= (int)(128 + r*cos(theta*3.141592/180));\
1807 v= (int)(128 + r*sin(theta*3.141592/180));
1808
1809
1810                     u=v=128;
1811                     if(IS_PCM(mb_type)){
1812                         COLOR(120,48)
1813                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1814                         COLOR(30,48)
1815                     }else if(IS_INTRA4x4(mb_type)){
1816                         COLOR(90,48)
1817                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1818 //                        COLOR(120,48)
1819                     }else if(IS_DIRECT(mb_type)){
1820                         COLOR(150,48)
1821                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1822                         COLOR(170,48)
1823                     }else if(IS_GMC(mb_type)){
1824                         COLOR(190,48)
1825                     }else if(IS_SKIP(mb_type)){
1826 //                        COLOR(180,48)
1827                     }else if(!USES_LIST(mb_type, 1)){
1828                         COLOR(240,48)
1829                     }else if(!USES_LIST(mb_type, 0)){
1830                         COLOR(0,48)
1831                     }else{
1832                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1833                         COLOR(300,48)
1834                     }
1835
1836                     u*= 0x0101010101010101ULL;
1837                     v*= 0x0101010101010101ULL;
1838                     for(y=0; y<8; y++){
1839                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1840                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1841                     }
1842
1843                     //segmentation
1844                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1845                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1846                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1847                     }
1848                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1849                         for(y=0; y<16; y++)
1850                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1851                     }
1852
1853                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1854                         // hmm
1855                     }
1856                 }
1857                 s->mbskip_table[mb_index]=0;
1858             }
1859         }
1860     }
1861 }
1862
1863 #ifdef CONFIG_ENCODERS
1864
1865 static int get_sae(uint8_t *src, int ref, int stride){
1866     int x,y;
1867     int acc=0;
1868
1869     for(y=0; y<16; y++){
1870         for(x=0; x<16; x++){
1871             acc+= ABS(src[x+y*stride] - ref);
1872         }
1873     }
1874
1875     return acc;
1876 }
1877
1878 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1879     int x, y, w, h;
1880     int acc=0;
1881
1882     w= s->width &~15;
1883     h= s->height&~15;
1884
1885     for(y=0; y<h; y+=16){
1886         for(x=0; x<w; x+=16){
1887             int offset= x + y*stride;
1888             int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1889             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1890             int sae = get_sae(src + offset, mean, stride);
1891
1892             acc+= sae + 500 < sad;
1893         }
1894     }
1895     return acc;
1896 }
1897
1898
1899 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1900     AVFrame *pic=NULL;
1901     int i;
1902     const int encoding_delay= s->max_b_frames;
1903     int direct=1;
1904
1905   if(pic_arg){
1906     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1907     if(pic_arg->linesize[0] != s->linesize) direct=0;
1908     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1909     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1910
1911 //    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1912
1913     if(direct){
1914         i= ff_find_unused_picture(s, 1);
1915
1916         pic= (AVFrame*)&s->picture[i];
1917         pic->reference= 3;
1918
1919         for(i=0; i<4; i++){
1920             pic->data[i]= pic_arg->data[i];
1921             pic->linesize[i]= pic_arg->linesize[i];
1922         }
1923         alloc_picture(s, (Picture*)pic, 1);
1924     }else{
1925         int offset= 16;
1926         i= ff_find_unused_picture(s, 0);
1927
1928         pic= (AVFrame*)&s->picture[i];
1929         pic->reference= 3;
1930
1931         alloc_picture(s, (Picture*)pic, 0);
1932
1933         if(   pic->data[0] + offset == pic_arg->data[0]
1934            && pic->data[1] + offset == pic_arg->data[1]
1935            && pic->data[2] + offset == pic_arg->data[2]){
1936        // empty
1937         }else{
1938             int h_chroma_shift, v_chroma_shift;
1939             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1940
1941             for(i=0; i<3; i++){
1942                 int src_stride= pic_arg->linesize[i];
1943                 int dst_stride= i ? s->uvlinesize : s->linesize;
1944                 int h_shift= i ? h_chroma_shift : 0;
1945                 int v_shift= i ? v_chroma_shift : 0;
1946                 int w= s->width >>h_shift;
1947                 int h= s->height>>v_shift;
1948                 uint8_t *src= pic_arg->data[i];
1949                 uint8_t *dst= pic->data[i] + offset;
1950
1951                 if(src_stride==dst_stride)
1952                     memcpy(dst, src, src_stride*h);
1953                 else{
1954                     while(h--){
1955                         memcpy(dst, src, w);
1956                         dst += dst_stride;
1957                         src += src_stride;
1958                     }
1959                 }
1960             }
1961         }
1962     }
1963     copy_picture_attributes(s, pic, pic_arg);
1964
1965     pic->display_picture_number= s->input_picture_number++;
1966
1967     if(pic->pts != AV_NOPTS_VALUE){
1968         if(s->user_specified_pts != AV_NOPTS_VALUE){
1969             int64_t time= av_rescale(pic->pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1970             int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1971
1972             if(time <= last){
1973                 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pic->pts, s->user_specified_pts);
1974                 return -1;
1975             }
1976         }
1977         s->user_specified_pts= pic->pts;
1978     }else{
1979         if(s->user_specified_pts != AV_NOPTS_VALUE){
1980             s->user_specified_pts=
1981             pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
1982             av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
1983         }else{
1984             pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
1985         }
1986     }
1987   }
1988
1989     /* shift buffer entries */
1990     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1991         s->input_picture[i-1]= s->input_picture[i];
1992
1993     s->input_picture[encoding_delay]= (Picture*)pic;
1994
1995     return 0;
1996 }
1997
1998 static void select_input_picture(MpegEncContext *s){
1999     int i;
2000
2001     for(i=1; i<MAX_PICTURE_COUNT; i++)
2002         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2003     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2004
2005     /* set next picture types & ordering */
2006     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2007         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2008             s->reordered_input_picture[0]= s->input_picture[0];
2009             s->reordered_input_picture[0]->pict_type= I_TYPE;
2010             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2011         }else{
2012             int b_frames;
2013
2014             if(s->flags&CODEC_FLAG_PASS2){
2015                 for(i=0; i<s->max_b_frames+1; i++){
2016                     int pict_num= s->input_picture[0]->display_picture_number + i;
2017                     int pict_type= s->rc_context.entry[pict_num].new_pict_type;
2018                     s->input_picture[i]->pict_type= pict_type;
2019
2020                     if(i + 1 >= s->rc_context.num_entries) break;
2021                 }
2022             }
2023
2024             if(s->input_picture[0]->pict_type){
2025                 /* user selected pict_type */
2026                 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
2027                     if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
2028                 }
2029
2030                 if(b_frames > s->max_b_frames){
2031                     av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2032                     b_frames = s->max_b_frames;
2033                 }
2034             }else if(s->avctx->b_frame_strategy==0){
2035                 b_frames= s->max_b_frames;
2036                 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2037             }else if(s->avctx->b_frame_strategy==1){
2038                 for(i=1; i<s->max_b_frames+1; i++){
2039                     if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2040                         s->input_picture[i]->b_frame_score=
2041                             get_intra_count(s, s->input_picture[i  ]->data[0],
2042                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
2043                     }
2044                 }
2045                 for(i=0; i<s->max_b_frames; i++){
2046                     if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2047                 }
2048
2049                 b_frames= FFMAX(0, i-1);
2050
2051                 /* reset scores */
2052                 for(i=0; i<b_frames+1; i++){
2053                     s->input_picture[i]->b_frame_score=0;
2054                 }
2055             }else{
2056                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2057                 b_frames=0;
2058             }
2059
2060             emms_c();
2061 //static int b_count=0;
2062 //b_count+= b_frames;
2063 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2064             if(s->picture_in_gop_number + b_frames >= s->gop_size){
2065                 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2066                     b_frames=0;
2067                 s->input_picture[b_frames]->pict_type= I_TYPE;
2068             }
2069
2070             if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2071                && b_frames
2072                && s->input_picture[b_frames]->pict_type== I_TYPE)
2073                 b_frames--;
2074
2075             s->reordered_input_picture[0]= s->input_picture[b_frames];
2076             if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2077                 s->reordered_input_picture[0]->pict_type= P_TYPE;
2078             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2079             for(i=0; i<b_frames; i++){
2080                 s->reordered_input_picture[i+1]= s->input_picture[i];
2081                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2082                 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2083             }
2084         }
2085     }
2086
2087     if(s->reordered_input_picture[0]){
2088         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2089
2090         copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2091
2092         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2093             // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2094
2095             int i= ff_find_unused_picture(s, 0);
2096             Picture *pic= &s->picture[i];
2097
2098             /* mark us unused / free shared pic */
2099             for(i=0; i<4; i++)
2100                 s->reordered_input_picture[0]->data[i]= NULL;
2101             s->reordered_input_picture[0]->type= 0;
2102
2103             pic->reference              = s->reordered_input_picture[0]->reference;
2104
2105             alloc_picture(s, pic, 0);
2106
2107             copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2108
2109             s->current_picture_ptr= pic;
2110         }else{
2111             // input is not a shared pix -> reuse buffer for current_pix
2112
2113             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2114                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2115
2116             s->current_picture_ptr= s->reordered_input_picture[0];
2117             for(i=0; i<4; i++){
2118                 s->new_picture.data[i]+=16;
2119             }
2120         }
2121         copy_picture(&s->current_picture, s->current_picture_ptr);
2122
2123         s->picture_number= s->new_picture.display_picture_number;
2124 //printf("dpn:%d\n", s->picture_number);
2125     }else{
2126        memset(&s->new_picture, 0, sizeof(Picture));
2127     }
2128 }
2129
2130 int MPV_encode_picture(AVCodecContext *avctx,
2131                        unsigned char *buf, int buf_size, void *data)
2132 {
2133     MpegEncContext *s = avctx->priv_data;
2134     AVFrame *pic_arg = data;
2135     int i, stuffing_count;
2136
2137     if(avctx->pix_fmt != PIX_FMT_YUV420P){
2138         av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2139         return -1;
2140     }
2141
2142     for(i=0; i<avctx->thread_count; i++){
2143         int start_y= s->thread_context[i]->start_mb_y;
2144         int   end_y= s->thread_context[i]->  end_mb_y;
2145         int h= s->mb_height;
2146         uint8_t *start= buf + buf_size*start_y/h;
2147         uint8_t *end  = buf + buf_size*  end_y/h;
2148
2149         init_put_bits(&s->thread_context[i]->pb, start, end - start);
2150     }
2151
2152     s->picture_in_gop_number++;
2153
2154     if(load_input_picture(s, pic_arg) < 0)
2155         return -1;
2156
2157     select_input_picture(s);
2158
2159     /* output? */
2160     if(s->new_picture.data[0]){
2161         s->pict_type= s->new_picture.pict_type;
2162 //emms_c();
2163 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2164         MPV_frame_start(s, avctx);
2165
2166         encode_picture(s, s->picture_number);
2167
2168         avctx->real_pict_num  = s->picture_number;
2169         avctx->header_bits = s->header_bits;
2170         avctx->mv_bits     = s->mv_bits;
2171         avctx->misc_bits   = s->misc_bits;
2172         avctx->i_tex_bits  = s->i_tex_bits;
2173         avctx->p_tex_bits  = s->p_tex_bits;
2174         avctx->i_count     = s->i_count;
2175         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2176         avctx->skip_count  = s->skip_count;
2177
2178         MPV_frame_end(s);
2179
2180         if (s->out_format == FMT_MJPEG)
2181             mjpeg_picture_trailer(s);
2182
2183         if(s->flags&CODEC_FLAG_PASS1)
2184             ff_write_pass1_stats(s);
2185
2186         for(i=0; i<4; i++){
2187             avctx->error[i] += s->current_picture_ptr->error[i];
2188         }
2189
2190         flush_put_bits(&s->pb);
2191         s->frame_bits  = put_bits_count(&s->pb);
2192
2193         stuffing_count= ff_vbv_update(s, s->frame_bits);
2194         if(stuffing_count){
2195             switch(s->codec_id){
2196             case CODEC_ID_MPEG1VIDEO:
2197             case CODEC_ID_MPEG2VIDEO:
2198                 while(stuffing_count--){
2199                     put_bits(&s->pb, 8, 0);
2200                 }
2201             break;
2202             case CODEC_ID_MPEG4:
2203                 put_bits(&s->pb, 16, 0);
2204                 put_bits(&s->pb, 16, 0x1C3);
2205                 stuffing_count -= 4;
2206                 while(stuffing_count--){
2207                     put_bits(&s->pb, 8, 0xFF);
2208                 }
2209             break;
2210             default:
2211                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2212             }
2213             flush_put_bits(&s->pb);
2214             s->frame_bits  = put_bits_count(&s->pb);
2215         }
2216
2217         /* update mpeg1/2 vbv_delay for CBR */
2218         if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2219            && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2220             int vbv_delay;
2221
2222             assert(s->repeat_first_field==0);
2223
2224             vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2225             assert(vbv_delay < 0xFFFF);
2226
2227             s->vbv_delay_ptr[0] &= 0xF8;
2228             s->vbv_delay_ptr[0] |= vbv_delay>>13;
2229             s->vbv_delay_ptr[1]  = vbv_delay>>5;
2230             s->vbv_delay_ptr[2] &= 0x07;
2231             s->vbv_delay_ptr[2] |= vbv_delay<<3;
2232         }
2233         s->total_bits += s->frame_bits;
2234         avctx->frame_bits  = s->frame_bits;
2235     }else{
2236         assert((pbBufPtr(&s->pb) == s->pb.buf));
2237         s->frame_bits=0;
2238     }
2239     assert((s->frame_bits&7)==0);
2240
2241     return s->frame_bits/8;
2242 }
2243
2244 #endif //CONFIG_ENCODERS
2245
2246 static inline void gmc1_motion(MpegEncContext *s,
2247                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2248                                uint8_t **ref_picture)
2249 {
2250     uint8_t *ptr;
2251     int offset, src_x, src_y, linesize, uvlinesize;
2252     int motion_x, motion_y;
2253     int emu=0;
2254
2255     motion_x= s->sprite_offset[0][0];
2256     motion_y= s->sprite_offset[0][1];
2257     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2258     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2259     motion_x<<=(3-s->sprite_warping_accuracy);
2260     motion_y<<=(3-s->sprite_warping_accuracy);
2261     src_x = clip(src_x, -16, s->width);
2262     if (src_x == s->width)
2263         motion_x =0;
2264     src_y = clip(src_y, -16, s->height);
2265     if (src_y == s->height)
2266         motion_y =0;
2267
2268     linesize = s->linesize;
2269     uvlinesize = s->uvlinesize;
2270
2271     ptr = ref_picture[0] + (src_y * linesize) + src_x;
2272
2273     if(s->flags&CODEC_FLAG_EMU_EDGE){
2274         if(   (unsigned)src_x >= s->h_edge_pos - 17
2275            || (unsigned)src_y >= s->v_edge_pos - 17){
2276             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2277             ptr= s->edge_emu_buffer;
2278         }
2279     }
2280
2281     if((motion_x|motion_y)&7){
2282         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2283         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2284     }else{
2285         int dxy;
2286
2287         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2288         if (s->no_rounding){
2289             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2290         }else{
2291             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2292         }
2293     }
2294
2295     if(s->flags&CODEC_FLAG_GRAY) return;
2296
2297     motion_x= s->sprite_offset[1][0];
2298     motion_y= s->sprite_offset[1][1];
2299     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2300     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2301     motion_x<<=(3-s->sprite_warping_accuracy);
2302     motion_y<<=(3-s->sprite_warping_accuracy);
2303     src_x = clip(src_x, -8, s->width>>1);
2304     if (src_x == s->width>>1)
2305         motion_x =0;
2306     src_y = clip(src_y, -8, s->height>>1);
2307     if (src_y == s->height>>1)
2308         motion_y =0;
2309
2310     offset = (src_y * uvlinesize) + src_x;
2311     ptr = ref_picture[1] + offset;
2312     if(s->flags&CODEC_FLAG_EMU_EDGE){
2313         if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2314            || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2315             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);
2316             ptr= s->edge_emu_buffer;
2317             emu=1;
2318         }
2319     }
2320     s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2321
2322     ptr = ref_picture[2] + offset;
2323     if(emu){
2324         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);
2325         ptr= s->edge_emu_buffer;
2326     }
2327     s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2328
2329     return;
2330 }
2331
2332 static inline void gmc_motion(MpegEncContext *s,
2333                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2334                                uint8_t **ref_picture)
2335 {
2336     uint8_t *ptr;
2337     int linesize, uvlinesize;
2338     const int a= s->sprite_warping_accuracy;
2339     int ox, oy;
2340
2341     linesize = s->linesize;
2342     uvlinesize = s->uvlinesize;
2343
2344     ptr = ref_picture[0];
2345
2346     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2347     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2348
2349     s->dsp.gmc(dest_y, ptr, linesize, 16,
2350            ox,
2351            oy,
2352            s->sprite_delta[0][0], s->sprite_delta[0][1],
2353            s->sprite_delta[1][0], s->sprite_delta[1][1],
2354            a+1, (1<<(2*a+1)) - s->no_rounding,
2355            s->h_edge_pos, s->v_edge_pos);
2356     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2357            ox + s->sprite_delta[0][0]*8,
2358            oy + s->sprite_delta[1][0]*8,
2359            s->sprite_delta[0][0], s->sprite_delta[0][1],
2360            s->sprite_delta[1][0], s->sprite_delta[1][1],
2361            a+1, (1<<(2*a+1)) - s->no_rounding,
2362            s->h_edge_pos, s->v_edge_pos);
2363
2364     if(s->flags&CODEC_FLAG_GRAY) return;
2365
2366     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2367     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2368
2369     ptr = ref_picture[1];
2370     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2371            ox,
2372            oy,
2373            s->sprite_delta[0][0], s->sprite_delta[0][1],
2374            s->sprite_delta[1][0], s->sprite_delta[1][1],
2375            a+1, (1<<(2*a+1)) - s->no_rounding,
2376            s->h_edge_pos>>1, s->v_edge_pos>>1);
2377
2378     ptr = ref_picture[2];
2379     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2380            ox,
2381            oy,
2382            s->sprite_delta[0][0], s->sprite_delta[0][1],
2383            s->sprite_delta[1][0], s->sprite_delta[1][1],
2384            a+1, (1<<(2*a+1)) - s->no_rounding,
2385            s->h_edge_pos>>1, s->v_edge_pos>>1);
2386 }
2387
2388 /**
2389  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2390  * @param buf destination buffer
2391  * @param src source buffer
2392  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2393  * @param block_w width of block
2394  * @param block_h height of block
2395  * @param src_x x coordinate of the top left sample of the block in the source buffer
2396  * @param src_y y coordinate of the top left sample of the block in the source buffer
2397  * @param w width of the source buffer
2398  * @param h height of the source buffer
2399  */
2400 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2401                                     int src_x, int src_y, int w, int h){
2402     int x, y;
2403     int start_y, start_x, end_y, end_x;
2404
2405     if(src_y>= h){
2406         src+= (h-1-src_y)*linesize;
2407         src_y=h-1;
2408     }else if(src_y<=-block_h){
2409         src+= (1-block_h-src_y)*linesize;
2410         src_y=1-block_h;
2411     }
2412     if(src_x>= w){
2413         src+= (w-1-src_x);
2414         src_x=w-1;
2415     }else if(src_x<=-block_w){
2416         src+= (1-block_w-src_x);
2417         src_x=1-block_w;
2418     }
2419
2420     start_y= FFMAX(0, -src_y);
2421     start_x= FFMAX(0, -src_x);
2422     end_y= FFMIN(block_h, h-src_y);
2423     end_x= FFMIN(block_w, w-src_x);
2424
2425     // copy existing part
2426     for(y=start_y; y<end_y; y++){
2427         for(x=start_x; x<end_x; x++){
2428             buf[x + y*linesize]= src[x + y*linesize];
2429         }
2430     }
2431
2432     //top
2433     for(y=0; y<start_y; y++){
2434         for(x=start_x; x<end_x; x++){
2435             buf[x + y*linesize]= buf[x + start_y*linesize];
2436         }
2437     }
2438
2439     //bottom
2440     for(y=end_y; y<block_h; y++){
2441         for(x=start_x; x<end_x; x++){
2442             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2443         }
2444     }
2445
2446     for(y=0; y<block_h; y++){
2447        //left
2448         for(x=0; x<start_x; x++){
2449             buf[x + y*linesize]= buf[start_x + y*linesize];
2450         }
2451
2452        //right
2453         for(x=end_x; x<block_w; x++){
2454             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2455         }
2456     }
2457 }
2458
2459 static inline int hpel_motion(MpegEncContext *s,
2460                                   uint8_t *dest, uint8_t *src,
2461                                   int field_based, int field_select,
2462                                   int src_x, int src_y,
2463                                   int width, int height, int stride,
2464                                   int h_edge_pos, int v_edge_pos,
2465                                   int w, int h, op_pixels_func *pix_op,
2466                                   int motion_x, int motion_y)
2467 {
2468     int dxy;
2469     int emu=0;
2470
2471     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2472     src_x += motion_x >> 1;
2473     src_y += motion_y >> 1;
2474
2475     /* WARNING: do no forget half pels */
2476     src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2477     if (src_x == width)
2478         dxy &= ~1;
2479     src_y = clip(src_y, -16, height);
2480     if (src_y == height)
2481         dxy &= ~2;
2482     src += src_y * stride + src_x;
2483
2484     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2485         if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2486            || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2487             ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2488                              src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2489             src= s->edge_emu_buffer;
2490             emu=1;
2491         }
2492     }
2493     if(field_select)
2494         src += s->linesize;
2495     pix_op[dxy](dest, src, stride, h);
2496     return emu;
2497 }
2498
2499 /* apply one mpeg motion vector to the three components */
2500 static always_inline void mpeg_motion(MpegEncContext *s,
2501                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2502                                int field_based, int bottom_field, int field_select,
2503                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2504                                int motion_x, int motion_y, int h)
2505 {
2506     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2507     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2508
2509 #if 0
2510 if(s->quarter_sample)
2511 {
2512     motion_x>>=1;
2513     motion_y>>=1;
2514 }
2515 #endif
2516
2517     v_edge_pos = s->v_edge_pos >> field_based;
2518     linesize   = s->current_picture.linesize[0] << field_based;
2519     uvlinesize = s->current_picture.linesize[1] << field_based;
2520
2521     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2522     src_x = s->mb_x* 16               + (motion_x >> 1);
2523     src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2524
2525     if (s->out_format == FMT_H263) {
2526         if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2527             mx = (motion_x>>1)|(motion_x&1);
2528             my = motion_y >>1;
2529             uvdxy = ((my & 1) << 1) | (mx & 1);
2530             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2531             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2532         }else{
2533             uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2534             uvsrc_x = src_x>>1;
2535             uvsrc_y = src_y>>1;
2536         }
2537     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2538         mx = motion_x / 4;
2539         my = motion_y / 4;
2540         uvdxy = 0;
2541         uvsrc_x = s->mb_x*8 + mx;
2542         uvsrc_y = s->mb_y*8 + my;
2543     } else {
2544         if(s->chroma_y_shift){
2545             mx = motion_x / 2;
2546             my = motion_y / 2;
2547             uvdxy = ((my & 1) << 1) | (mx & 1);
2548             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2549             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2550         } else {
2551             if(s->chroma_x_shift){
2552             //Chroma422
2553                 mx = motion_x / 2;
2554                 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2555                 uvsrc_x = s->mb_x* 8           + (mx >> 1);
2556                 uvsrc_y = src_y;
2557             } else {
2558             //Chroma444
2559                 uvdxy = dxy;
2560                 uvsrc_x = src_x;
2561                 uvsrc_y = src_y;
2562             }
2563         }
2564     }
2565
2566     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2567     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2568     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2569
2570     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2571        || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2572             if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2573                s->codec_id == CODEC_ID_MPEG1VIDEO){
2574                 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2575                 return ;
2576             }
2577             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2578                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2579             ptr_y = s->edge_emu_buffer;
2580             if(!(s->flags&CODEC_FLAG_GRAY)){
2581                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2582                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
2583                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2584                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2585                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2586                 ptr_cb= uvbuf;
2587                 ptr_cr= uvbuf+16;
2588             }
2589     }
2590
2591     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2592         dest_y += s->linesize;
2593         dest_cb+= s->uvlinesize;
2594         dest_cr+= s->uvlinesize;
2595     }
2596
2597     if(field_select){
2598         ptr_y += s->linesize;
2599         ptr_cb+= s->uvlinesize;
2600         ptr_cr+= s->uvlinesize;
2601     }
2602
2603     pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2604
2605     if(!(s->flags&CODEC_FLAG_GRAY)){
2606         pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2607         pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2608     }
2609 }
2610
2611 /* apply one mpeg motion vector to the three components */
2612 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2613                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2614                                int field_based, int bottom_field, int field_select,
2615                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2616                                int motion_x, int motion_y, int h)
2617 {
2618     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2619     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2620     const int lowres= s->avctx->lowres;
2621     const int block_s= 8>>lowres;
2622     const int s_mask= (2<<lowres)-1;
2623     const int h_edge_pos = s->h_edge_pos >> lowres;
2624     const int v_edge_pos = s->v_edge_pos >> lowres;
2625     linesize   = s->current_picture.linesize[0] << field_based;
2626     uvlinesize = s->current_picture.linesize[1] << field_based;
2627
2628     if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2629         motion_x/=2;
2630         motion_y/=2;
2631     }
2632
2633     if(field_based){
2634         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2635     }
2636
2637     sx= motion_x & s_mask;
2638     sy= motion_y & s_mask;
2639     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2640     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2641
2642     if (s->out_format == FMT_H263) {
2643         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2644         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2645         uvsrc_x = src_x>>1;
2646         uvsrc_y = src_y>>1;
2647     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2648         mx = motion_x / 4;
2649         my = motion_y / 4;
2650         uvsx = (2*mx) & s_mask;
2651         uvsy = (2*my) & s_mask;
2652         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2653         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2654     } else {
2655         mx = motion_x / 2;
2656         my = motion_y / 2;
2657         uvsx = mx & s_mask;
2658         uvsy = my & s_mask;
2659         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2660         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2661     }
2662
2663     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2664     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2665     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2666
2667     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2668        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2669             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2670                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2671             ptr_y = s->edge_emu_buffer;
2672             if(!(s->flags&CODEC_FLAG_GRAY)){
2673                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2674                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
2675                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2676                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2677                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2678                 ptr_cb= uvbuf;
2679                 ptr_cr= uvbuf+16;
2680             }
2681     }
2682
2683     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2684         dest_y += s->linesize;
2685         dest_cb+= s->uvlinesize;
2686         dest_cr+= s->uvlinesize;
2687     }
2688
2689     if(field_select){
2690         ptr_y += s->linesize;
2691         ptr_cb+= s->uvlinesize;
2692         ptr_cr+= s->uvlinesize;
2693     }
2694
2695     sx <<= 2 - lowres;
2696     sy <<= 2 - lowres;
2697     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2698
2699     if(!(s->flags&CODEC_FLAG_GRAY)){
2700         uvsx <<= 2 - lowres;
2701         uvsy <<= 2 - lowres;
2702         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2703         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2704     }
2705 }
2706
2707 //FIXME move to dsputil, avg variant, 16x16 version
2708 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2709     int x;
2710     uint8_t * const top   = src[1];
2711     uint8_t * const left  = src[2];
2712     uint8_t * const mid   = src[0];
2713     uint8_t * const right = src[3];
2714     uint8_t * const bottom= src[4];
2715 #define OBMC_FILTER(x, t, l, m, r, b)\
2716     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2717 #define OBMC_FILTER4(x, t, l, m, r, b)\
2718     OBMC_FILTER(x         , t, l, m, r, b);\
2719     OBMC_FILTER(x+1       , t, l, m, r, b);\
2720     OBMC_FILTER(x  +stride, t, l, m, r, b);\
2721     OBMC_FILTER(x+1+stride, t, l, m, r, b);
2722
2723     x=0;
2724     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2725     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2726     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2727     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2728     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2729     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2730     x+= stride;
2731     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2732     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2733     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2734     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2735     x+= stride;
2736     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2737     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2738     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2739     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2740     x+= 2*stride;
2741     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2742     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2743     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2744     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2745     x+= 2*stride;
2746     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2747     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2748     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2749     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2750     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2751     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2752     x+= stride;
2753     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2754     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2755     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2756     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2757 }
2758
2759 /* obmc for 1 8x8 luma block */
2760 static inline void obmc_motion(MpegEncContext *s,
2761                                uint8_t *dest, uint8_t *src,
2762                                int src_x, int src_y,
2763                                op_pixels_func *pix_op,
2764                                int16_t mv[5][2]/* mid top left right bottom*/)
2765 #define MID    0
2766 {
2767     int i;
2768     uint8_t *ptr[5];
2769
2770     assert(s->quarter_sample==0);
2771
2772     for(i=0; i<5; i++){
2773         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2774             ptr[i]= ptr[MID];
2775         }else{
2776             ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2777             hpel_motion(s, ptr[i], src, 0, 0,
2778                         src_x, src_y,
2779                         s->width, s->height, s->linesize,
2780                         s->h_edge_pos, s->v_edge_pos,
2781                         8, 8, pix_op,
2782                         mv[i][0], mv[i][1]);
2783         }
2784     }
2785
2786     put_obmc(dest, ptr, s->linesize);
2787 }
2788
2789 static inline void qpel_motion(MpegEncContext *s,
2790                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2791                                int field_based, int bottom_field, int field_select,
2792                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2793                                qpel_mc_func (*qpix_op)[16],
2794                                int motion_x, int motion_y, int h)
2795 {
2796     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2797     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2798
2799     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2800     src_x = s->mb_x *  16                 + (motion_x >> 2);
2801     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2802
2803     v_edge_pos = s->v_edge_pos >> field_based;
2804     linesize = s->linesize << field_based;
2805     uvlinesize = s->uvlinesize << field_based;
2806
2807     if(field_based){
2808         mx= motion_x/2;
2809         my= motion_y>>1;
2810     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2811         static const int rtab[8]= {0,0,1,1,0,0,0,1};
2812         mx= (motion_x>>1) + rtab[motion_x&7];
2813         my= (motion_y>>1) + rtab[motion_y&7];
2814     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2815         mx= (motion_x>>1)|(motion_x&1);
2816         my= (motion_y>>1)|(motion_y&1);
2817     }else{
2818         mx= motion_x/2;
2819         my= motion_y/2;
2820     }
2821     mx= (mx>>1)|(mx&1);
2822     my= (my>>1)|(my&1);
2823
2824     uvdxy= (mx&1) | ((my&1)<<1);
2825     mx>>=1;
2826     my>>=1;
2827
2828     uvsrc_x = s->mb_x *  8                 + mx;
2829     uvsrc_y = s->mb_y * (8 >> field_based) + my;
2830
2831     ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2832     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2833     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2834
2835     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
2836        || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2837         ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2838                          src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2839         ptr_y= s->edge_emu_buffer;
2840         if(!(s->flags&CODEC_FLAG_GRAY)){
2841             uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2842             ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
2843                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2844             ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
2845                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2846             ptr_cb= uvbuf;
2847             ptr_cr= uvbuf + 16;
2848         }
2849     }
2850
2851     if(!field_based)
2852         qpix_op[0][dxy](dest_y, ptr_y, linesize);
2853     else{
2854         if(bottom_field){
2855             dest_y += s->linesize;
2856             dest_cb+= s->uvlinesize;
2857             dest_cr+= s->uvlinesize;
2858         }
2859
2860         if(field_select){
2861             ptr_y  += s->linesize;
2862             ptr_cb += s->uvlinesize;
2863             ptr_cr += s->uvlinesize;
2864         }
2865         //damn interlaced mode
2866         //FIXME boundary mirroring is not exactly correct here
2867         qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2868         qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2869     }
2870     if(!(s->flags&CODEC_FLAG_GRAY)){
2871         pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2872         pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2873     }
2874 }
2875
2876 inline int ff_h263_round_chroma(int x){
2877     if (x >= 0)
2878         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2879     else {
2880         x = -x;
2881         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2882     }
2883 }
2884
2885 /**
2886  * h263 chorma 4mv motion compensation.
2887  */
2888 static inline void chroma_4mv_motion(MpegEncContext *s,
2889                                      uint8_t *dest_cb, uint8_t *dest_cr,
2890                                      uint8_t **ref_picture,
2891                                      op_pixels_func *pix_op,
2892                                      int mx, int my){
2893     int dxy, emu=0, src_x, src_y, offset;
2894     uint8_t *ptr;
2895
2896     /* In case of 8X8, we construct a single chroma motion vector
2897        with a special rounding */
2898     mx= ff_h263_round_chroma(mx);
2899     my= ff_h263_round_chroma(my);
2900
2901     dxy = ((my & 1) << 1) | (mx & 1);
2902     mx >>= 1;
2903     my >>= 1;
2904
2905     src_x = s->mb_x * 8 + mx;
2906     src_y = s->mb_y * 8 + my;
2907     src_x = clip(src_x, -8, s->width/2);
2908     if (src_x == s->width/2)
2909         dxy &= ~1;
2910     src_y = clip(src_y, -8, s->height/2);
2911     if (src_y == s->height/2)
2912         dxy &= ~2;
2913
2914     offset = (src_y * (s->uvlinesize)) + src_x;
2915     ptr = ref_picture[1] + offset;
2916     if(s->flags&CODEC_FLAG_EMU_EDGE){
2917         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2918            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2919             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);
2920             ptr= s->edge_emu_buffer;
2921             emu=1;
2922         }
2923     }
2924     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2925
2926     ptr = ref_picture[2] + offset;
2927     if(emu){
2928         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);
2929         ptr= s->edge_emu_buffer;
2930     }
2931     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2932 }
2933
2934 /**
2935  * motion compesation of a single macroblock
2936  * @param s context
2937  * @param dest_y luma destination pointer
2938  * @param dest_cb chroma cb/u destination pointer
2939  * @param dest_cr chroma cr/v destination pointer
2940  * @param dir direction (0->forward, 1->backward)
2941  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2942  * @param pic_op halfpel motion compensation function (average or put normally)
2943  * @param pic_op qpel motion compensation function (average or put normally)
2944  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2945  */
2946 static inline void MPV_motion(MpegEncContext *s,
2947                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2948                               int dir, uint8_t **ref_picture,
2949                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2950 {
2951     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2952     int mb_x, mb_y, i;
2953     uint8_t *ptr, *dest;
2954
2955     mb_x = s->mb_x;
2956     mb_y = s->mb_y;
2957
2958     if(s->obmc && s->pict_type != B_TYPE){
2959         int16_t mv_cache[4][4][2];
2960         const int xy= s->mb_x + s->mb_y*s->mb_stride;
2961         const int mot_stride= s->b8_stride;
2962         const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2963
2964         assert(!s->mb_skiped);
2965
2966         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2967         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2968         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2969
2970         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2971             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2972         }else{
2973             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2974         }
2975
2976         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2977             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2978             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2979         }else{
2980             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2981             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2982         }
2983
2984         if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2985             *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2986             *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2987         }else{
2988             *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2989             *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2990         }
2991
2992         mx = 0;
2993         my = 0;
2994         for(i=0;i<4;i++) {
2995             const int x= (i&1)+1;
2996             const int y= (i>>1)+1;
2997             int16_t mv[5][2]= {
2998                 {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2999                 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3000                 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3001                 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3002                 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3003             //FIXME cleanup
3004             obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3005                         ref_picture[0],
3006                         mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3007                         pix_op[1],
3008                         mv);
3009
3010             mx += mv[0][0];
3011             my += mv[0][1];
3012         }
3013         if(!(s->flags&CODEC_FLAG_GRAY))
3014             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3015
3016         return;
3017     }
3018
3019     switch(s->mv_type) {
3020     case MV_TYPE_16X16:
3021 #ifdef CONFIG_RISKY
3022         if(s->mcsel){
3023             if(s->real_sprite_warping_points==1){
3024                 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3025                             ref_picture);
3026             }else{
3027                 gmc_motion(s, dest_y, dest_cb, dest_cr,
3028                             ref_picture);
3029             }
3030         }else if(s->quarter_sample){
3031             qpel_motion(s, dest_y, dest_cb, dest_cr,
3032                         0, 0, 0,
3033                         ref_picture, pix_op, qpix_op,
3034                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3035         }else if(s->mspel){
3036             ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3037                         ref_picture, pix_op,
3038                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3039         }else
3040 #endif
3041         {
3042             mpeg_motion(s, dest_y, dest_cb, dest_cr,
3043                         0, 0, 0,
3044                         ref_picture, pix_op,
3045                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3046         }
3047         break;
3048     case MV_TYPE_8X8:
3049         mx = 0;
3050         my = 0;
3051         if(s->quarter_sample){
3052             for(i=0;i<4;i++) {
3053                 motion_x = s->mv[dir][i][0];
3054                 motion_y = s->mv[dir][i][1];
3055
3056                 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3057                 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3058                 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3059
3060                 /* WARNING: do no forget half pels */
3061                 src_x = clip(src_x, -16, s->width);
3062                 if (src_x == s->width)
3063                     dxy &= ~3;
3064                 src_y = clip(src_y, -16, s->height);
3065                 if (src_y == s->height)
3066                     dxy &= ~12;
3067
3068                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3069                 if(s->flags&CODEC_FLAG_EMU_EDGE){
3070                     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3071                        || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3072                         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);
3073                         ptr= s->edge_emu_buffer;
3074                     }
3075                 }
3076                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3077                 qpix_op[1][dxy](dest, ptr, s->linesize);
3078
3079                 mx += s->mv[dir][i][0]/2;
3080                 my += s->mv[dir][i][1]/2;
3081             }
3082         }else{
3083             for(i=0;i<4;i++) {
3084                 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3085                             ref_picture[0], 0, 0,
3086                             mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3087                             s->width, s->height, s->linesize,
3088                             s->h_edge_pos, s->v_edge_pos,
3089                             8, 8, pix_op[1],
3090                             s->mv[dir][i][0], s->mv[dir][i][1]);
3091
3092                 mx += s->mv[dir][i][0];
3093                 my += s->mv[dir][i][1];
3094             }
3095         }
3096
3097         if(!(s->flags&CODEC_FLAG_GRAY))
3098             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3099         break;
3100     case MV_TYPE_FIELD:
3101         if (s->picture_structure == PICT_FRAME) {
3102             if(s->quarter_sample){
3103                 for(i=0; i<2; i++){
3104                     qpel_motion(s, dest_y, dest_cb, dest_cr,
3105                                 1, i, s->field_select[dir][i],
3106                                 ref_picture, pix_op, qpix_op,
3107                                 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3108                 }
3109             }else{
3110                 /* top field */
3111                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3112                             1, 0, s->field_select[dir][0],
3113                             ref_picture, pix_op,
3114                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
3115                 /* bottom field */
3116                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3117                             1, 1, s->field_select[dir][1],
3118                             ref_picture, pix_op,
3119                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
3120             }
3121         } else {
3122             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3123                 ref_picture= s->current_picture_ptr->data;
3124             }
3125
3126             mpeg_motion(s, dest_y, dest_cb, dest_cr,
3127                         0, 0, s->field_select[dir][0],
3128                         ref_picture, pix_op,
3129                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3130         }
3131         break;
3132     case MV_TYPE_16X8:
3133         for(i=0; i<2; i++){
3134             uint8_t ** ref2picture;
3135
3136             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3137                 ref2picture= ref_picture;
3138             }else{
3139                 ref2picture= s->current_picture_ptr->data;
3140             }
3141
3142             mpeg_motion(s, dest_y, dest_cb, dest_cr,
3143                         0, 0, s->field_select[dir][i],
3144                         ref2picture, pix_op,
3145                         s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3146
3147             dest_y += 16*s->linesize;
3148             dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3149             dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3150         }
3151         break;
3152     case MV_TYPE_DMV:
3153         if(s->picture_structure == PICT_FRAME){
3154             for(i=0; i<2; i++){
3155                 int j;
3156                 for(j=0; j<2; j++){
3157                     mpeg_motion(s, dest_y, dest_cb, dest_cr,
3158                                 1, j, j^i,
3159                                 ref_picture, pix_op,
3160                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3161                 }
3162                 pix_op = s->dsp.avg_pixels_tab;
3163             }
3164         }else{
3165             for(i=0; i<2; i++){
3166                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3167                             0, 0, s->picture_structure != i+1,
3168                             ref_picture, pix_op,
3169                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3170
3171                 // after put we make avg of the same block
3172                 pix_op=s->dsp.avg_pixels_tab;
3173
3174                 //opposite parity is always in the same frame if this is second field
3175                 if(!s->first_field){
3176                     ref_picture = s->current_picture_ptr->data;
3177                 }
3178             }
3179         }
3180     break;
3181     default: assert(0);
3182     }
3183 }
3184
3185 /**
3186  * motion compesation of a single macroblock
3187  * @param s context
3188  * @param dest_y luma destination pointer
3189  * @param dest_cb chroma cb/u destination pointer
3190  * @param dest_cr chroma cr/v destination pointer
3191  * @param dir direction (0->forward, 1->backward)
3192  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3193  * @param pic_op halfpel motion compensation function (average or put normally)
3194  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3195  */
3196 static inline void MPV_motion_lowres(MpegEncContext *s,
3197                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3198                               int dir, uint8_t **ref_picture,
3199                               h264_chroma_mc_func *pix_op)
3200 {
3201     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3202     int mb_x, mb_y, i;
3203     uint8_t *ptr, *dest;
3204     const int lowres= s->avctx->lowres;
3205     const int block_s= 8>>lowres;
3206
3207     mb_x = s->mb_x;
3208     mb_y = s->mb_y;
3209
3210     switch(s->mv_type) {
3211     case MV_TYPE_16X16:
3212         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3213                     0, 0, 0,
3214                     ref_picture, pix_op,
3215                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3216         break;
3217 /*    case MV_TYPE_8X8:
3218         mx = 0;
3219         my = 0;
3220             for(i=0;i<4;i++) {
3221                 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3222                             ref_picture[0], 0, 0,
3223                             mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3224                             s->width, s->height, s->linesize,
3225                             s->h_edge_pos, s->v_edge_pos,
3226                             8, 8, pix_op[1],
3227                             s->mv[dir][i][0], s->mv[dir][i][1]);
3228
3229                 mx += s->mv[dir][i][0];
3230                 my += s->mv[dir][i][1];
3231             }
3232
3233         if(!(s->flags&CODEC_FLAG_GRAY))
3234             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3235         break;*/
3236     case MV_TYPE_FIELD:
3237         if (s->picture_structure == PICT_FRAME) {
3238             /* top field */
3239             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3240                         1, 0, s->field_select[dir][0],
3241                         ref_picture, pix_op,
3242                         s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3243             /* bottom field */
3244             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3245                         1, 1, s->field_select[dir][1],
3246                         ref_picture, pix_op,
3247                         s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3248         } else {
3249             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3250                 ref_picture= s->current_picture_ptr->data;
3251             }
3252
3253             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3254                         0, 0, s->field_select[dir][0],
3255                         ref_picture, pix_op,
3256                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3257         }
3258         break;
3259     case MV_TYPE_16X8:
3260         for(i=0; i<2; i++){
3261             uint8_t ** ref2picture;
3262
3263             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3264                 ref2picture= ref_picture;
3265             }else{
3266                 ref2picture= s->current_picture_ptr->data;
3267             }
3268
3269             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3270                         0, 0, s->field_select[dir][i],
3271                         ref2picture, pix_op,
3272                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3273
3274             dest_y += 2*block_s*s->linesize;
3275             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3276             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3277         }
3278         break;
3279     case MV_TYPE_DMV:
3280         if(s->picture_structure == PICT_FRAME){
3281             for(i=0; i<2; i++){
3282                 int j;
3283                 for(j=0; j<2; j++){
3284                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3285                                 1, j, j^i,
3286                                 ref_picture, pix_op,
3287                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3288                 }
3289                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3290             }
3291         }else{
3292             for(i=0; i<2; i++){
3293                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3294                             0, 0, s->picture_structure != i+1,
3295                             ref_picture, pix_op,
3296                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3297
3298                 // after put we make avg of the same block
3299                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3300
3301                 //opposite parity is always in the same frame if this is second field
3302                 if(!s->first_field){
3303                     ref_picture = s->current_picture_ptr->data;
3304                 }
3305             }
3306         }
3307     break;
3308     default: assert(0);
3309     }
3310 }
3311
3312 /* put block[] to dest[] */
3313 static inline void put_dct(MpegEncContext *s,
3314                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3315 {
3316     s->dct_unquantize_intra(s, block, i, qscale);
3317     s->dsp.idct_put (dest, line_size, block);
3318 }
3319
3320 /* add block[] to dest[] */
3321 static inline void add_dct(MpegEncContext *s,
3322                            DCTELEM *block, int i, uint8_t *dest, int line_size)
3323 {
3324     if (s->block_last_index[i] >= 0) {
3325         s->dsp.idct_add (dest, line_size, block);
3326     }
3327 }
3328
3329 static inline void add_dequant_dct(MpegEncContext *s,
3330                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3331 {
3332     if (s->block_last_index[i] >= 0) {
3333         s->dct_unquantize_inter(s, block, i, qscale);
3334
3335         s->dsp.idct_add (dest, line_size, block);
3336     }
3337 }
3338
3339 /**
3340  * cleans dc, ac, coded_block for the current non intra MB
3341  */
3342 void ff_clean_intra_table_entries(MpegEncContext *s)
3343 {
3344     int wrap = s->b8_stride;
3345     int xy = s->block_index[0];
3346
3347     s->dc_val[0][xy           ] =
3348     s->dc_val[0][xy + 1       ] =
3349     s->dc_val[0][xy     + wrap] =
3350     s->dc_val[0][xy + 1 + wrap] = 1024;
3351     /* ac pred */
3352     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3353     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3354     if (s->msmpeg4_version>=3) {
3355         s->coded_block[xy           ] =
3356         s->coded_block[xy + 1       ] =
3357         s->coded_block[xy     + wrap] =
3358         s->coded_block[xy + 1 + wrap] = 0;
3359     }
3360     /* chroma */
3361     wrap = s->mb_stride;
3362     xy = s->mb_x + s->mb_y * wrap;
3363     s->dc_val[1][xy] =
3364     s->dc_val[2][xy] = 1024;
3365     /* ac pred */
3366     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3367     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3368
3369     s->mbintra_table[xy]= 0;
3370 }
3371
3372 /* generic function called after a macroblock has been parsed by the
3373    decoder or after it has been encoded by the encoder.
3374
3375    Important variables used:
3376    s->mb_intra : true if intra macroblock
3377    s->mv_dir   : motion vector direction
3378    s->mv_type  : motion vector type
3379    s->mv       : motion vector
3380    s->interlaced_dct : true if interlaced dct used (mpeg2)
3381  */
3382 static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3383 {
3384     int mb_x, mb_y;
3385     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3386 #ifdef HAVE_XVMC
3387     if(s->avctx->xvmc_acceleration){
3388         XVMC_decode_mb(s);//xvmc uses pblocks
3389         return;
3390     }
3391 #endif
3392
3393     mb_x = s->mb_x;
3394     mb_y = s->mb_y;
3395
3396     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3397        /* save DCT coefficients */
3398        int i,j;
3399        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3400        for(i=0; i<6; i++)
3401            for(j=0; j<64; j++)
3402                *dct++ = block[i][s->dsp.idct_permutation[j]];
3403     }
3404
3405     s->current_picture.qscale_table[mb_xy]= s->qscale;
3406
3407     /* update DC predictors for P macroblocks */
3408     if (!s->mb_intra) {
3409         if (s->h263_pred || s->h263_aic) {
3410             if(s->mbintra_table[mb_xy])
3411                 ff_clean_intra_table_entries(s);
3412         } else {
3413             s->last_dc[0] =
3414             s->last_dc[1] =
3415             s->last_dc[2] = 128 << s->intra_dc_precision;
3416         }
3417     }
3418     else if (s->h263_pred || s->h263_aic)
3419         s->mbintra_table[mb_xy]=1;
3420
3421     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3422         uint8_t *dest_y, *dest_cb, *dest_cr;
3423         int dct_linesize, dct_offset;
3424         op_pixels_func (*op_pix)[4];
3425         qpel_mc_func (*op_qpix)[16];
3426         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3427         const int uvlinesize= s->current_picture.linesize[1];
3428         const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3429         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3430
3431         /* avoid copy if macroblock skipped in last frame too */
3432         /* skip only during decoding as we might trash the buffers during encoding a bit */
3433         if(!s->encoding){
3434             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3435             const int age= s->current_picture.age;
3436
3437             assert(age);
3438
3439             if (s->mb_skiped) {
3440                 s->mb_skiped= 0;
3441                 assert(s->pict_type!=I_TYPE);
3442
3443                 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3444                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3445
3446                 /* if previous was skipped too, then nothing to do !  */
3447                 if (*mbskip_ptr >= age && s->current_picture.reference){
3448                     return;
3449                 }
3450             } else if(!s->current_picture.reference){
3451                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3452                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3453             } else{
3454                 *mbskip_ptr = 0; /* not skipped */
3455             }
3456         }
3457
3458         dct_linesize = linesize << s->interlaced_dct;
3459         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3460
3461         if(readable){
3462             dest_y=  s->dest[0];
3463             dest_cb= s->dest[1];
3464             dest_cr= s->dest[2];
3465         }else{
3466             dest_y = s->b_scratchpad;
3467             dest_cb= s->b_scratchpad+16*linesize;
3468             dest_cr= s->b_scratchpad+32*linesize;
3469         }
3470
3471         if (!s->mb_intra) {
3472             /* motion handling */
3473             /* decoding or more than one mb_type (MC was allready done otherwise) */
3474             if(!s->encoding){
3475                 if(lowres_flag){
3476                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3477
3478                     if (s->mv_dir & MV_DIR_FORWARD) {
3479                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3480                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3481                     }
3482                     if (s->mv_dir & MV_DIR_BACKWARD) {
3483                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3484                     }
3485                 }else{
3486                     if ((!s->no_rounding) || s->pict_type==B_TYPE){
3487                         op_pix = s->dsp.put_pixels_tab;
3488                         op_qpix= s->dsp.put_qpel_pixels_tab;
3489                     }else{
3490                         op_pix = s->dsp.put_no_rnd_pixels_tab;
3491                         op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3492                     }
3493                     if (s->mv_dir & MV_DIR_FORWARD) {
3494                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3495                         op_pix = s->dsp.avg_pixels_tab;
3496                         op_qpix= s->dsp.avg_qpel_pixels_tab;
3497                     }
3498                     if (s->mv_dir & MV_DIR_BACKWARD) {
3499                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3500                     }
3501                 }
3502             }
3503
3504             /* skip dequant / idct if we are really late ;) */
3505             if(s->hurry_up>1) return;
3506
3507             /* add dct residue */
3508             if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3509                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3510                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3511                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3512                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3513                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3514
3515                 if(!(s->flags&CODEC_FLAG_GRAY)){
3516                     add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3517                     add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3518                 }
3519             } else if(s->codec_id != CODEC_ID_WMV2){
3520                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3521                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3522                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3523                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3524
3525                 if(!(s->flags&CODEC_FLAG_GRAY)){
3526                     if(s->chroma_y_shift){//Chroma420
3527                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
3528                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
3529                     }else{
3530                         //chroma422
3531                         dct_linesize = uvlinesize << s->interlaced_dct;
3532                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3533
3534                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
3535                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
3536                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3537                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3538                         if(!s->chroma_x_shift){//Chroma444
3539                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3540                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3541                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3542                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3543                         }
3544                     }
3545                 }//fi gray
3546             }
3547 #ifdef CONFIG_RISKY
3548             else{
3549                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3550             }
3551 #endif
3552         } else {
3553             /* dct only in intra block */
3554             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3555                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3556                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3557                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3558                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3559
3560                 if(!(s->flags&CODEC_FLAG_GRAY)){
3561                     put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3562                     put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3563                 }
3564             }else{
3565                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3566                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3567                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3568                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3569
3570                 if(!(s->flags&CODEC_FLAG_GRAY)){
3571                     if(s->chroma_y_shift){
3572                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3573                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3574                     }else{
3575
3576                         dct_linesize = uvlinesize << s->interlaced_dct;
3577                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3578
3579                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3580                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3581                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3582                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3583                         if(!s->chroma_x_shift){//Chroma444
3584                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3585                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3586                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3587                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3588                         }
3589                     }
3590                 }//gray
3591             }
3592         }
3593         if(!readable){
3594             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3595             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3596             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3597         }
3598     }
3599 }
3600
3601 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3602     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3603     else                  MPV_decode_mb_internal(s, block, 0);
3604 }
3605
3606 #ifdef CONFIG_ENCODERS
3607
3608 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3609 {
3610     static const char tab[64]=
3611         {3,2,2,1,1,1,1,1,
3612          1,1,1,1,1,1,1,1,
3613          1,1,1,1,1,1,1,1,
3614          0,0,0,0,0,0,0,0,
3615          0,0,0,0,0,0,0,0,
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     int score=0;
3620     int run=0;
3621     int i;
3622     DCTELEM *block= s->block[n];
3623     const int last_index= s->block_last_index[n];
3624     int skip_dc;
3625
3626     if(threshold<0){
3627         skip_dc=0;
3628         threshold= -threshold;
3629     }else
3630         skip_dc=1;
3631
3632     /* are all which we could set to zero are allready zero? */
3633     if(last_index<=skip_dc - 1) return;
3634
3635     for(i=0; i<=last_index; i++){
3636         const int j = s->intra_scantable.permutated[i];
3637         const int level = ABS(block[j]);
3638         if(level==1){
3639             if(skip_dc && i==0) continue;
3640             score+= tab[run];
3641             run=0;
3642         }else if(level>1){
3643             return;
3644         }else{
3645             run++;
3646         }
3647     }
3648     if(score >= threshold) return;
3649     for(i=skip_dc; i<=last_index; i++){
3650         const int j = s->intra_scantable.permutated[i];
3651         block[j]=0;
3652     }
3653     if(block[0]) s->block_last_index[n]= 0;
3654     else         s->block_last_index[n]= -1;
3655 }
3656
3657 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3658 {
3659     int i;
3660     const int maxlevel= s->max_qcoeff;
3661     const int minlevel= s->min_qcoeff;
3662     int overflow=0;
3663
3664     if(s->mb_intra){
3665         i=1; //skip clipping of intra dc
3666     }else
3667         i=0;
3668
3669     for(;i<=last_index; i++){
3670         const int j= s->intra_scantable.permutated[i];
3671         int level = block[j];
3672
3673         if     (level>maxlevel){
3674             level=maxlevel;
3675             overflow++;
3676         }else if(level<minlevel){
3677             level=minlevel;
3678             overflow++;
3679         }
3680
3681         block[j]= level;
3682     }
3683
3684     if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3685         av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3686 }
3687
3688 #endif //CONFIG_ENCODERS
3689
3690 /**
3691  *
3692  * @param h is the normal height, this will be reduced automatically if needed for the last row
3693  */
3694 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3695     if (s->avctx->draw_horiz_band) {
3696         AVFrame *src;
3697         int offset[4];
3698
3699         if(s->picture_structure != PICT_FRAME){
3700             h <<= 1;
3701             y <<= 1;
3702             if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3703         }
3704
3705         h= FFMIN(h, (s->height>>s->avctx->lowres) - y);
3706
3707         if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
3708             src= (AVFrame*)s->current_picture_ptr;
3709         else if(s->last_picture_ptr)
3710             src= (AVFrame*)s->last_picture_ptr;
3711         else
3712             return;
3713
3714         if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3715             offset[0]=
3716             offset[1]=
3717             offset[2]=
3718             offset[3]= 0;
3719         }else{
3720             offset[0]= y * s->linesize;;
3721             offset[1]=
3722             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3723             offset[3]= 0;
3724         }
3725
3726         emms_c();
3727
3728         s->avctx->draw_horiz_band(s->avctx, src, offset,
3729                                   y, s->picture_structure, h);
3730     }
3731 }
3732
3733 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3734     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3735     const int uvlinesize= s->current_picture.linesize[1];
3736     const int mb_size= 4 - s->avctx->lowres;
3737
3738     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3739     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3740     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3741     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3742     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3743     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;
3744     //block_index is not used by mpeg2, so it is not affected by chroma_format
3745
3746     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
3747     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3748     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3749
3750     if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3751     {
3752         s->dest[0] += s->mb_y *   linesize << mb_size;
3753         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3754         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3755     }
3756 }
3757
3758 #ifdef CONFIG_ENCODERS
3759
3760 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3761     int x, y;
3762 //FIXME optimize
3763     for(y=0; y<8; y++){
3764         for(x=0; x<8; x++){
3765             int x2, y2;
3766             int sum=0;
3767             int sqr=0;
3768             int count=0;
3769
3770             for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3771                 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3772                     int v= ptr[x2 + y2*stride];
3773                     sum += v;
3774                     sqr += v*v;
3775                     count++;
3776                 }
3777             }
3778             weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3779         }
3780     }
3781 }
3782
3783 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3784 {
3785     int16_t weight[6][64];
3786     DCTELEM orig[6][64];
3787     const int mb_x= s->mb_x;
3788     const int mb_y= s->mb_y;
3789     int i;
3790     int skip_dct[6];
3791     int dct_offset   = s->linesize*8; //default for progressive frames
3792     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3793     int wrap_y, wrap_c;
3794
3795     for(i=0; i<6; i++) skip_dct[i]=0;
3796
3797     if(s->adaptive_quant){
3798         const int last_qp= s->qscale;
3799         const int mb_xy= mb_x + mb_y*s->mb_stride;
3800
3801         s->lambda= s->lambda_table[mb_xy];
3802         update_qscale(s);
3803
3804         if(!(s->flags&CODEC_FLAG_QP_RD)){
3805             s->dquant= s->qscale - last_qp;
3806
3807             if(s->out_format==FMT_H263){
3808                 s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3809
3810                 if(s->codec_id==CODEC_ID_MPEG4){
3811                     if(!s->mb_intra){
3812                         if(s->pict_type == B_TYPE){
3813                             if(s->dquant&1)
3814                                 s->dquant= (s->dquant/2)*2;
3815                             if(s->mv_dir&MV_DIRECT)
3816                                 s->dquant= 0;
3817                         }
3818                         if(s->mv_type==MV_TYPE_8X8)
3819                             s->dquant=0;
3820                     }
3821                 }
3822             }
3823         }
3824         ff_set_qscale(s, last_qp + s->dquant);
3825     }else if(s->flags&CODEC_FLAG_QP_RD)
3826         ff_set_qscale(s, s->qscale + s->dquant);
3827
3828     wrap_y = s->linesize;
3829     wrap_c = s->uvlinesize;
3830     ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3831     ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3832     ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3833
3834     if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3835         uint8_t *ebuf= s->edge_emu_buffer + 32;
3836         ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3837         ptr_y= ebuf;
3838         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);
3839         ptr_cb= ebuf+18*wrap_y;
3840         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);
3841         ptr_cr= ebuf+18*wrap_y+8;
3842     }
3843
3844     if (s->mb_intra) {
3845         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3846             int progressive_score, interlaced_score;
3847
3848             s->interlaced_dct=0;
3849             progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8)
3850                               +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3851
3852             if(progressive_score > 0){
3853                 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8)
3854                                   +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3855                 if(progressive_score > interlaced_score){
3856                     s->interlaced_dct=1;
3857
3858                     dct_offset= wrap_y;
3859                     wrap_y<<=1;
3860                 }
3861             }
3862         }
3863
3864         s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3865         s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3866         s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3867         s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3868
3869         if(s->flags&CODEC_FLAG_GRAY){
3870             skip_dct[4]= 1;
3871             skip_dct[5]= 1;
3872         }else{
3873             s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3874             s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3875         }
3876     }else{
3877         op_pixels_func (*op_pix)[4];
3878         qpel_mc_func (*op_qpix)[16];
3879         uint8_t *dest_y, *dest_cb, *dest_cr;
3880
3881         dest_y  = s->dest[0];
3882         dest_cb = s->dest[1];
3883         dest_cr = s->dest[2];
3884
3885         if ((!s->no_rounding) || s->pict_type==B_TYPE){
3886             op_pix = s->dsp.put_pixels_tab;
3887             op_qpix= s->dsp.put_qpel_pixels_tab;
3888         }else{
3889             op_pix = s->dsp.put_no_rnd_pixels_tab;
3890             op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3891         }
3892
3893         if (s->mv_dir & MV_DIR_FORWARD) {
3894             MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3895             op_pix = s->dsp.avg_pixels_tab;
3896             op_qpix= s->dsp.avg_qpel_pixels_tab;
3897         }
3898         if (s->mv_dir & MV_DIR_BACKWARD) {
3899             MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3900         }
3901
3902         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3903             int progressive_score, interlaced_score;
3904
3905             s->interlaced_dct=0;
3906             progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8)
3907                               +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3908
3909             if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3910
3911             if(progressive_score>0){
3912                 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8)
3913                                   +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
3914
3915                 if(progressive_score > interlaced_score){
3916                     s->interlaced_dct=1;
3917
3918                     dct_offset= wrap_y;
3919                     wrap_y<<=1;
3920                 }
3921             }
3922         }
3923
3924         s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3925         s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3926         s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3927         s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3928
3929         if(s->flags&CODEC_FLAG_GRAY){
3930             skip_dct[4]= 1;
3931             skip_dct[5]= 1;
3932         }else{
3933             s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3934             s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3935         }
3936         /* pre quantization */
3937         if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3938             //FIXME optimize
3939             if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3940             if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3941             if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3942             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;
3943             if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3944             if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3945         }
3946     }
3947
3948     if(s->avctx->quantizer_noise_shaping){
3949         if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
3950         if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
3951         if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
3952         if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
3953         if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
3954         if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
3955         memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
3956     }
3957
3958     /* DCT & quantize */
3959     assert(s->out_format!=FMT_MJPEG || s->qscale==8);
3960     {
3961         for(i=0;i<6;i++) {
3962             if(!skip_dct[i]){
3963                 int overflow;
3964                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3965             // FIXME we could decide to change to quantizer instead of clipping
3966             // JS: I don't think that would be a good idea it could lower quality instead
3967             //     of improve it. Just INTRADC clipping deserves changes in quantizer
3968                 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3969             }else
3970                 s->block_last_index[i]= -1;
3971         }
3972         if(s->avctx->quantizer_noise_shaping){
3973             for(i=0;i<6;i++) {
3974                 if(!skip_dct[i]){
3975                     s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
3976                 }
3977             }
3978         }
3979
3980         if(s->luma_elim_threshold && !s->mb_intra)
3981             for(i=0; i<4; i++)
3982                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3983         if(s->chroma_elim_threshold && !s->mb_intra)
3984             for(i=4; i<6; i++)
3985                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3986
3987         if(s->flags & CODEC_FLAG_CBP_RD){
3988             for(i=0;i<6;i++) {
3989                 if(s->block_last_index[i] == -1)
3990                     s->coded_score[i]= INT_MAX/256;
3991             }
3992         }
3993     }
3994
3995     if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3996         s->block_last_index[4]=
3997         s->block_last_index[5]= 0;
3998         s->block[4][0]=
3999         s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4000     }
4001
4002     //non c quantize code returns incorrect block_last_index FIXME
4003     if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4004         for(i=0; i<6; i++){
4005             int j;
4006             if(s->block_last_index[i]>0){
4007                 for(j=63; j>0; j--){
4008                     if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4009                 }
4010                 s->block_last_index[i]= j;
4011             }
4012         }
4013     }
4014
4015     /* huffman encode */
4016     switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4017     case CODEC_ID_MPEG1VIDEO:
4018     case CODEC_ID_MPEG2VIDEO:
4019         mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4020 #ifdef CONFIG_RISKY
4021     case CODEC_ID_MPEG4:
4022         mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4023     case CODEC_ID_MSMPEG4V2:
4024     case CODEC_ID_MSMPEG4V3:
4025     case CODEC_ID_WMV1:
4026         msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4027     case CODEC_ID_WMV2:
4028          ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4029     case CODEC_ID_H263:
4030     case CODEC_ID_H263P:
4031     case CODEC_ID_FLV1:
4032     case CODEC_ID_RV10:
4033         h263_encode_mb(s, s->block, motion_x, motion_y); break;
4034 #endif
4035     case CODEC_ID_MJPEG:
4036         mjpeg_encode_mb(s, s->block); break;
4037     default:
4038         assert(0);
4039     }
4040 }
4041
4042 #endif //CONFIG_ENCODERS
4043
4044 void ff_mpeg_flush(AVCodecContext *avctx){
4045     int i;
4046     MpegEncContext *s = avctx->priv_data;
4047
4048     if(s==NULL || s->picture==NULL)
4049         return;
4050
4051     for(i=0; i<MAX_PICTURE_COUNT; i++){
4052        if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4053                                     || s->picture[i].type == FF_BUFFER_TYPE_USER))
4054         avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4055     }
4056     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4057
4058     s->parse_context.state= -1;
4059     s->parse_context.frame_start_found= 0;
4060     s->parse_context.overread= 0;
4061     s->parse_context.overread_index= 0;
4062     s->parse_context.index= 0;
4063     s->parse_context.last_index= 0;
4064     s->bitstream_buffer_size=0;
4065 }
4066
4067 #ifdef CONFIG_ENCODERS
4068 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4069 {
4070     const uint16_t *srcw= (uint16_t*)src;
4071     int words= length>>4;
4072     int bits= length&15;
4073     int i;
4074
4075     if(length==0) return;
4076
4077     if(words < 16){
4078         for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4079     }else if(put_bits_count(pb)&7){
4080         for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4081     }else{
4082         for(i=0; put_bits_count(pb)&31; i++)
4083             put_bits(pb, 8, src[i]);
4084         flush_put_bits(pb);
4085         memcpy(pbBufPtr(pb), src+i, 2*words-i);
4086         skip_put_bytes(pb, 2*words-i);
4087     }
4088
4089     put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4090 }
4091
4092 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4093     int i;
4094
4095     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4096
4097     /* mpeg1 */
4098     d->mb_skip_run= s->mb_skip_run;
4099     for(i=0; i<3; i++)
4100         d->last_dc[i]= s->last_dc[i];
4101
4102     /* statistics */
4103     d->mv_bits= s->mv_bits;
4104     d->i_tex_bits= s->i_tex_bits;
4105     d->p_tex_bits= s->p_tex_bits;
4106     d->i_count= s->i_count;
4107     d->f_count= s->f_count;
4108     d->b_count= s->b_count;
4109     d->skip_count= s->skip_count;
4110     d->misc_bits= s->misc_bits;
4111     d->last_bits= 0;
4112
4113     d->mb_skiped= 0;
4114     d->qscale= s->qscale;
4115     d->dquant= s->dquant;
4116 }
4117
4118 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4119     int i;
4120
4121     memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4122     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4123
4124     /* mpeg1 */
4125     d->mb_skip_run= s->mb_skip_run;
4126     for(i=0; i<3; i++)
4127         d->last_dc[i]= s->last_dc[i];
4128
4129     /* statistics */
4130     d->mv_bits= s->mv_bits;
4131     d->i_tex_bits= s->i_tex_bits;
4132     d->p_tex_bits= s->p_tex_bits;
4133     d->i_count= s->i_count;
4134     d->f_count= s->f_count;
4135     d->b_count= s->b_count;
4136     d->skip_count= s->skip_count;
4137     d->misc_bits= s->misc_bits;
4138
4139     d->mb_intra= s->mb_intra;
4140     d->mb_skiped= s->mb_skiped;
4141     d->mv_type= s->mv_type;
4142     d->mv_dir= s->mv_dir;
4143     d->pb= s->pb;
4144     if(s->data_partitioning){
4145         d->pb2= s->pb2;
4146         d->tex_pb= s->tex_pb;
4147     }
4148     d->block= s->block;
4149     for(i=0; i<6; i++)
4150         d->block_last_index[i]= s->block_last_index[i];
4151     d->interlaced_dct= s->interlaced_dct;
4152     d->qscale= s->qscale;
4153 }
4154
4155 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4156                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4157                            int *dmin, int *next_block, int motion_x, int motion_y)
4158 {
4159     int score;
4160     uint8_t *dest_backup[3];
4161
4162     copy_context_before_encode(s, backup, type);
4163
4164     s->block= s->blocks[*next_block];
4165     s->pb= pb[*next_block];
4166     if(s->data_partitioning){
4167         s->pb2   = pb2   [*next_block];
4168         s->tex_pb= tex_pb[*next_block];
4169     }
4170
4171     if(*next_block){
4172         memcpy(dest_backup, s->dest, sizeof(s->dest));
4173         s->dest[0] = s->rd_scratchpad;
4174         s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4175         s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4176         assert(s->linesize >= 32); //FIXME
4177     }
4178
4179     encode_mb(s, motion_x, motion_y);
4180
4181     score= put_bits_count(&s->pb);
4182     if(s->data_partitioning){
4183         score+= put_bits_count(&s->pb2);
4184         score+= put_bits_count(&s->tex_pb);
4185     }
4186
4187     if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4188         MPV_decode_mb(s, s->block);
4189
4190         score *= s->lambda2;
4191         score += sse_mb(s) << FF_LAMBDA_SHIFT;
4192     }
4193
4194     if(*next_block){
4195         memcpy(s->dest, dest_backup, sizeof(s->dest));
4196     }
4197
4198     if(score<*dmin){
4199         *dmin= score;
4200         *next_block^=1;
4201
4202         copy_context_after_encode(best, s, type);
4203     }
4204 }
4205
4206 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4207     uint32_t *sq = squareTbl + 256;
4208     int acc=0;
4209     int x,y;
4210
4211     if(w==16 && h==16)
4212         return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4213     else if(w==8 && h==8)
4214         return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4215
4216     for(y=0; y<h; y++){
4217         for(x=0; x<w; x++){
4218             acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4219         }
4220     }
4221
4222     assert(acc>=0);
4223
4224     return acc;
4225 }
4226
4227 static int sse_mb(MpegEncContext *s){
4228     int w= 16;
4229     int h= 16;
4230
4231     if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4232     if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4233
4234     if(w==16 && h==16)
4235       if(s->avctx->mb_cmp == FF_CMP_NSSE){
4236         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)
4237                +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)
4238                +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);
4239       }else{
4240         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)
4241                +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)
4242                +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);
4243       }
4244     else
4245         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)
4246                +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)
4247                +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);
4248 }
4249
4250 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4251     MpegEncContext *s= arg;
4252
4253
4254     s->me.pre_pass=1;
4255     s->me.dia_size= s->avctx->pre_dia_size;
4256     s->first_slice_line=1;
4257     for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4258         for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4259             ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4260         }
4261         s->first_slice_line=0;
4262     }
4263
4264     s->me.pre_pass=0;
4265
4266     return 0;
4267 }
4268
4269 static int estimate_motion_thread(AVCodecContext *c, void *arg){
4270     MpegEncContext *s= arg;
4271
4272     s->me.dia_size= s->avctx->dia_size;
4273     s->first_slice_line=1;
4274     for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4275         s->mb_x=0; //for block init below
4276         ff_init_block_index(s);
4277         for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4278             s->block_index[0]+=2;
4279             s->block_index[1]+=2;
4280             s->block_index[2]+=2;
4281             s->block_index[3]+=2;
4282
4283             /* compute motion vector & mb_type and store in context */
4284             if(s->pict_type==B_TYPE)
4285                 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4286             else
4287                 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4288         }
4289         s->first_slice_line=0;
4290     }
4291     return 0;
4292 }
4293
4294 static int mb_var_thread(AVCodecContext *c, void *arg){
4295     MpegEncContext *s= arg;
4296     int mb_x, mb_y;
4297
4298     for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4299         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4300             int xx = mb_x * 16;
4301             int yy = mb_y * 16;
4302             uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4303             int varc;
4304             int sum = s->dsp.pix_sum(pix, s->linesize);
4305
4306             varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4307
4308             s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4309             s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4310             s->me.mb_var_sum_temp    += varc;
4311         }
4312     }
4313     return 0;
4314 }
4315
4316 static void write_slice_end(MpegEncContext *s){
4317     if(s->codec_id==CODEC_ID_MPEG4){
4318         if(s->partitioned_frame){
4319             ff_mpeg4_merge_partitions(s);
4320         }
4321
4322         ff_mpeg4_stuffing(&s->pb);
4323     }else if(s->out_format == FMT_MJPEG){
4324         ff_mjpeg_stuffing(&s->pb);
4325     }
4326
4327     align_put_bits(&s->pb);
4328     flush_put_bits(&s->pb);
4329 }
4330
4331 static int encode_thread(AVCodecContext *c, void *arg){
4332     MpegEncContext *s= arg;
4333     int mb_x, mb_y, pdif = 0;
4334     int i, j;
4335     MpegEncContext best_s, backup_s;
4336     uint8_t bit_buf[2][3000];
4337     uint8_t bit_buf2[2][3000];
4338     uint8_t bit_buf_tex[2][3000];
4339     PutBitContext pb[2], pb2[2], tex_pb[2];
4340 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4341
4342     for(i=0; i<2; i++){
4343         init_put_bits(&pb    [i], bit_buf    [i], 3000);
4344         init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4345         init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4346     }
4347
4348     s->last_bits= put_bits_count(&s->pb);
4349     s->mv_bits=0;
4350     s->misc_bits=0;
4351     s->i_tex_bits=0;
4352     s->p_tex_bits=0;
4353     s->i_count=0;
4354     s->f_count=0;
4355     s->b_count=0;
4356     s->skip_count=0;
4357
4358     for(i=0; i<3; i++){
4359         /* init last dc values */
4360         /* note: quant matrix value (8) is implied here */
4361         s->last_dc[i] = 128 << s->intra_dc_precision;
4362
4363         s->current_picture_ptr->error[i] = 0;
4364     }
4365     s->mb_skip_run = 0;
4366     memset(s->last_mv, 0, sizeof(s->last_mv));
4367
4368     s->last_mv_dir = 0;
4369
4370 #ifdef CONFIG_RISKY
4371     switch(s->codec_id){
4372     case CODEC_ID_H263:
4373     case CODEC_ID_H263P:
4374     case CODEC_ID_FLV1:
4375         s->gob_index = ff_h263_get_gob_height(s);
4376         break;
4377     case CODEC_ID_MPEG4:
4378         if(s->partitioned_frame)
4379             ff_mpeg4_init_partitions(s);
4380         break;
4381     }
4382 #endif
4383
4384     s->resync_mb_x=0;
4385     s->resync_mb_y=0;
4386     s->first_slice_line = 1;
4387     s->ptr_lastgob = s->pb.buf;
4388     for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4389 //    printf("row %d at %X\n", s->mb_y, (int)s);
4390         s->mb_x=0;
4391         s->mb_y= mb_y;
4392
4393         ff_set_qscale(s, s->qscale);
4394         ff_init_block_index(s);
4395
4396         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4397             const int xy= mb_y*s->mb_stride + mb_x;
4398             int mb_type= s->mb_type[xy];
4399 //            int d;
4400             int dmin= INT_MAX;
4401             int dir;
4402
4403             s->mb_x = mb_x;
4404             ff_update_block_index(s);
4405
4406             /* write gob / video packet header  */
4407 #ifdef CONFIG_RISKY
4408             if(s->rtp_mode){
4409                 int current_packet_size, is_gob_start;
4410
4411                 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4412
4413                 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
4414
4415                 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4416
4417                 switch(s->codec_id){
4418                 case CODEC_ID_H263:
4419                 case CODEC_ID_H263P:
4420                     if(!s->h263_slice_structured)
4421                         if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4422                     break;
4423                 case CODEC_ID_MPEG2VIDEO:
4424                     if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4425                 case CODEC_ID_MPEG1VIDEO:
4426                     if(s->mb_skip_run) is_gob_start=0;
4427                     break;
4428                 }
4429
4430                 if(is_gob_start){
4431                     if(s->start_mb_y != mb_y || mb_x!=0){
4432                         write_slice_end(s);
4433
4434                         if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4435                             ff_mpeg4_init_partitions(s);
4436                         }
4437                     }
4438
4439                     assert((put_bits_count(&s->pb)&7) == 0);
4440                     current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4441
4442                     if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4443                         int r= put_bits_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4444                         int d= 100 / s->avctx->error_rate;
4445                         if(r % d == 0){
4446                             current_packet_size=0;
4447 #ifndef ALT_BITSTREAM_WRITER
4448                             s->pb.buf_ptr= s->ptr_lastgob;
4449 #endif
4450                             assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4451                         }
4452                     }
4453
4454                     if (s->avctx->rtp_callback)
4455                         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
4456
4457                     switch(s->codec_id){
4458                     case CODEC_ID_MPEG4:
4459                         ff_mpeg4_encode_video_packet_header(s);
4460                         ff_mpeg4_clean_buffers(s);
4461                     break;
4462                     case CODEC_ID_MPEG1VIDEO:
4463                     case CODEC_ID_MPEG2VIDEO:
4464                         ff_mpeg1_encode_slice_header(s);
4465                         ff_mpeg1_clean_buffers(s);
4466                     break;
4467                     case CODEC_ID_H263:
4468                     case CODEC_ID_H263P:
4469                         h263_encode_gob_header(s, mb_y);
4470                     break;
4471                     }
4472
4473                     if(s->flags&CODEC_FLAG_PASS1){
4474                         int bits= put_bits_count(&s->pb);
4475                         s->misc_bits+= bits - s->last_bits;
4476                         s->last_bits= bits;
4477                     }
4478
4479                     s->ptr_lastgob += current_packet_size;
4480                     s->first_slice_line=1;
4481                     s->resync_mb_x=mb_x;
4482                     s->resync_mb_y=mb_y;
4483                 }
4484             }
4485 #endif
4486
4487             if(  (s->resync_mb_x   == s->mb_x)
4488                && s->resync_mb_y+1 == s->mb_y){
4489                 s->first_slice_line=0;
4490             }
4491
4492             s->mb_skiped=0;
4493             s->dquant=0; //only for QP_RD
4494
4495             if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
4496                 int next_block=0;
4497                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4498
4499                 copy_context_before_encode(&backup_s, s, -1);
4500                 backup_s.pb= s->pb;
4501                 best_s.data_partitioning= s->data_partitioning;
4502                 best_s.partitioned_frame= s->partitioned_frame;
4503                 if(s->data_partitioning){
4504                     backup_s.pb2= s->pb2;
4505                     backup_s.tex_pb= s->tex_pb;
4506                 }
4507
4508                 if(mb_type&CANDIDATE_MB_TYPE_INTER){
4509                     s->mv_dir = MV_DIR_FORWARD;
4510                     s->mv_type = MV_TYPE_16X16;
4511                     s->mb_intra= 0;
4512                     s->mv[0][0][0] = s->p_mv_table[xy][0];
4513                     s->mv[0][0][1] = s->p_mv_table[xy][1];
4514                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
4515                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4516                 }
4517                 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
4518                     s->mv_dir = MV_DIR_FORWARD;
4519                     s->mv_type = MV_TYPE_FIELD;
4520                     s->mb_intra= 0;
4521                     for(i=0; i<2; i++){
4522                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4523                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4524                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4525                     }
4526                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
4527                                  &dmin, &next_block, 0, 0);
4528                 }
4529                 if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4530                     s->mv_dir = MV_DIR_FORWARD;
4531                     s->mv_type = MV_TYPE_16X16;
4532                     s->mb_intra= 0;
4533                     s->mv[0][0][0] = 0;
4534                     s->mv[0][0][1] = 0;
4535                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb,
4536                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4537                 }
4538                 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
4539                     s->mv_dir = MV_DIR_FORWARD;
4540                     s->mv_type = MV_TYPE_8X8;
4541                     s->mb_intra= 0;
4542                     for(i=0; i<4; i++){
4543                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4544                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4545                     }
4546                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
4547                                  &dmin, &next_block, 0, 0);
4548                 }
4549                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
4550                     s->mv_dir = MV_DIR_FORWARD;
4551                     s->mv_type = MV_TYPE_16X16;
4552                     s->mb_intra= 0;
4553                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4554                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4555                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
4556                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4557                 }
4558                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
4559                     s->mv_dir = MV_DIR_BACKWARD;
4560                     s->mv_type = MV_TYPE_16X16;
4561                     s->mb_intra= 0;
4562                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4563                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4564                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
4565                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4566                 }
4567                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
4568                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4569                     s->mv_type = MV_TYPE_16X16;
4570                     s->mb_intra= 0;
4571                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4572                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4573                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4574                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4575                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
4576                                  &dmin, &next_block, 0, 0);
4577                 }
4578                 if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
4579                     int mx= s->b_direct_mv_table[xy][0];
4580                     int my= s->b_direct_mv_table[xy][1];
4581
4582                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4583                     s->mb_intra= 0;
4584 #ifdef CONFIG_RISKY
4585                     ff_mpeg4_set_direct_mv(s, mx, my);
4586 #endif
4587                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
4588                                  &dmin, &next_block, mx, my);
4589                 }
4590                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
4591                     s->mv_dir = MV_DIR_FORWARD;
4592                     s->mv_type = MV_TYPE_FIELD;
4593                     s->mb_intra= 0;
4594                     for(i=0; i<2; i++){
4595                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4596                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4597                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4598                     }
4599                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
4600                                  &dmin, &next_block, 0, 0);
4601                 }
4602                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
4603                     s->mv_dir = MV_DIR_BACKWARD;
4604                     s->mv_type = MV_TYPE_FIELD;
4605                     s->mb_intra= 0;
4606                     for(i=0; i<2; i++){
4607                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4608                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4609                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4610                     }
4611                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
4612                                  &dmin, &next_block, 0, 0);
4613                 }
4614                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
4615                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4616                     s->mv_type = MV_TYPE_FIELD;
4617                     s->mb_intra= 0;
4618                     for(dir=0; dir<2; dir++){
4619                         for(i=0; i<2; i++){
4620                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4621                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4622                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4623                         }
4624                     }
4625                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
4626                                  &dmin, &next_block, 0, 0);
4627                 }
4628                 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
4629                     s->mv_dir = 0;
4630                     s->mv_type = MV_TYPE_16X16;
4631                     s->mb_intra= 1;
4632                     s->mv[0][0][0] = 0;
4633                     s->mv[0][0][1] = 0;
4634                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
4635                                  &dmin, &next_block, 0, 0);
4636                     if(s->h263_pred || s->h263_aic){
4637                         if(best_s.mb_intra)
4638                             s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4639                         else
4640                             ff_clean_intra_table_entries(s); //old mode?
4641                     }
4642                 }
4643
4644                 if(s->flags & CODEC_FLAG_QP_RD){
4645                     if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4646                         const int last_qp= backup_s.qscale;
4647                         int dquant, dir, qp, dc[6];
4648                         DCTELEM ac[6][16];
4649                         const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4650
4651                         assert(backup_s.dquant == 0);
4652
4653                         //FIXME intra
4654                         s->mv_dir= best_s.mv_dir;
4655                         s->mv_type = MV_TYPE_16X16;
4656                         s->mb_intra= best_s.mb_intra;
4657                         s->mv[0][0][0] = best_s.mv[0][0][0];
4658                         s->mv[0][0][1] = best_s.mv[0][0][1];
4659                         s->mv[1][0][0] = best_s.mv[1][0][0];
4660                         s->mv[1][0][1] = best_s.mv[1][0][1];
4661
4662                         dir= s->pict_type == B_TYPE ? 2 : 1;
4663                         if(last_qp + dir > s->avctx->qmax) dir= -dir;
4664                         for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4665                             qp= last_qp + dquant;
4666                             if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4667                                 break;
4668                             backup_s.dquant= dquant;
4669                             if(s->mb_intra && s->dc_val[0]){
4670                                 for(i=0; i<6; i++){
4671                                     dc[i]= s->dc_val[0][ s->block_index[i] ];
4672                                     memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4673                                 }
4674                             }
4675
4676                             encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
4677                                          &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4678                             if(best_s.qscale != qp){
4679                                 if(s->mb_intra && s->dc_val[0]){
4680                                     for(i=0; i<6; i++){
4681                                         s->dc_val[0][ s->block_index[i] ]= dc[i];
4682                                         memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4683                                     }
4684                                 }
4685                                 if(dir > 0 && dquant==dir){
4686                                     dquant= 0;
4687                                     dir= -dir;
4688                                 }else
4689                                     break;
4690                             }
4691                         }
4692                         qp= best_s.qscale;
4693                         s->current_picture.qscale_table[xy]= qp;
4694                     }
4695                 }
4696
4697                 copy_context_after_encode(s, &best_s, -1);
4698
4699                 pb_bits_count= put_bits_count(&s->pb);
4700                 flush_put_bits(&s->pb);
4701                 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4702                 s->pb= backup_s.pb;
4703
4704                 if(s->data_partitioning){
4705                     pb2_bits_count= put_bits_count(&s->pb2);
4706                     flush_put_bits(&s->pb2);
4707                     ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4708                     s->pb2= backup_s.pb2;
4709
4710                     tex_pb_bits_count= put_bits_count(&s->tex_pb);
4711                     flush_put_bits(&s->tex_pb);
4712                     ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4713                     s->tex_pb= backup_s.tex_pb;
4714                 }
4715                 s->last_bits= put_bits_count(&s->pb);
4716
4717 #ifdef CONFIG_RISKY
4718                 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4719                     ff_h263_update_motion_val(s);
4720 #endif
4721
4722                 if(next_block==0){ //FIXME 16 vs linesize16
4723                     s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
4724                     s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
4725                     s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
4726                 }
4727
4728                 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
4729                     MPV_decode_mb(s, s->block);
4730             } else {
4731                 int motion_x, motion_y;
4732                 s->mv_type=MV_TYPE_16X16;
4733                 // only one MB-Type possible
4734
4735                 switch(mb_type){
4736                 case CANDIDATE_MB_TYPE_INTRA:
4737                     s->mv_dir = 0;
4738                     s->mb_intra= 1;
4739                     motion_x= s->mv[0][0][0] = 0;
4740                     motion_y= s->mv[0][0][1] = 0;
4741                     break;
4742                 case CANDIDATE_MB_TYPE_INTER:
4743                     s->mv_dir = MV_DIR_FORWARD;
4744                     s->mb_intra= 0;
4745                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
4746                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
4747                     break;
4748                 case CANDIDATE_MB_TYPE_INTER_I:
4749                     s->mv_dir = MV_DIR_FORWARD;
4750                     s->mv_type = MV_TYPE_FIELD;
4751                     s->mb_intra= 0;
4752                     for(i=0; i<2; i++){
4753                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4754                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4755                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4756                     }
4757                     motion_x = motion_y = 0;
4758                     break;
4759                 case CANDIDATE_MB_TYPE_INTER4V:
4760                     s->mv_dir = MV_DIR_FORWARD;
4761                     s->mv_type = MV_TYPE_8X8;
4762                     s->mb_intra= 0;
4763                     for(i=0; i<4; i++){
4764                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4765                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4766                     }
4767                     motion_x= motion_y= 0;
4768                     break;
4769                 case CANDIDATE_MB_TYPE_DIRECT:
4770                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4771                     s->mb_intra= 0;
4772                     motion_x=s->b_direct_mv_table[xy][0];
4773                     motion_y=s->b_direct_mv_table[xy][1];
4774 #ifdef CONFIG_RISKY
4775                     ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
4776 #endif
4777                     break;
4778                 case CANDIDATE_MB_TYPE_BIDIR:
4779                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4780                     s->mb_intra= 0;
4781                     motion_x=0;
4782                     motion_y=0;
4783                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4784                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4785                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4786                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4787                     break;
4788                 case CANDIDATE_MB_TYPE_BACKWARD:
4789                     s->mv_dir = MV_DIR_BACKWARD;
4790                     s->mb_intra= 0;
4791                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4792                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4793                     break;
4794                 case CANDIDATE_MB_TYPE_FORWARD:
4795                     s->mv_dir = MV_DIR_FORWARD;
4796                     s->mb_intra= 0;
4797                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4798                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4799 //                    printf(" %d %d ", motion_x, motion_y);
4800                     break;
4801                 case CANDIDATE_MB_TYPE_FORWARD_I:
4802                     s->mv_dir = MV_DIR_FORWARD;
4803                     s->mv_type = MV_TYPE_FIELD;
4804                     s->mb_intra= 0;
4805                     for(i=0; i<2; i++){
4806                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4807                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4808                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4809                     }
4810                     motion_x=motion_y=0;
4811                     break;
4812                 case CANDIDATE_MB_TYPE_BACKWARD_I:
4813                     s->mv_dir = MV_DIR_BACKWARD;
4814                     s->mv_type = MV_TYPE_FIELD;
4815                     s->mb_intra= 0;
4816                     for(i=0; i<2; i++){
4817                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4818                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4819                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4820                     }
4821                     motion_x=motion_y=0;
4822                     break;
4823                 case CANDIDATE_MB_TYPE_BIDIR_I:
4824                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4825                     s->mv_type = MV_TYPE_FIELD;
4826                     s->mb_intra= 0;
4827                     for(dir=0; dir<2; dir++){
4828                         for(i=0; i<2; i++){
4829                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4830                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4831                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4832                         }
4833                     }
4834                     motion_x=motion_y=0;
4835                     break;
4836                 default:
4837                     motion_x=motion_y=0; //gcc warning fix
4838                     av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
4839                 }
4840
4841                 encode_mb(s, motion_x, motion_y);
4842
4843                 // RAL: Update last macrobloc type
4844                 s->last_mv_dir = s->mv_dir;
4845
4846 #ifdef CONFIG_RISKY
4847                 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4848                     ff_h263_update_motion_val(s);
4849 #endif
4850
4851                 MPV_decode_mb(s, s->block);
4852             }
4853
4854             /* clean the MV table in IPS frames for direct mode in B frames */
4855             if(s->mb_intra /* && I,P,S_TYPE */){
4856                 s->p_mv_table[xy][0]=0;
4857                 s->p_mv_table[xy][1]=0;
4858             }
4859
4860             if(s->flags&CODEC_FLAG_PSNR){
4861                 int w= 16;
4862                 int h= 16;
4863
4864                 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4865                 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4866
4867                 s->current_picture_ptr->error[0] += sse(
4868                     s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4869                     s->dest[0], w, h, s->linesize);
4870                 s->current_picture_ptr->error[1] += sse(
4871                     s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4872                     s->dest[1], w>>1, h>>1, s->uvlinesize);
4873                 s->current_picture_ptr->error[2] += sse(
4874                     s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4875                     s->dest[2], w>>1, h>>1, s->uvlinesize);
4876             }
4877             if(s->loop_filter)
4878                 ff_h263_loop_filter(s);
4879 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
4880         }
4881     }
4882
4883 #ifdef CONFIG_RISKY
4884     //not beautifull here but we must write it before flushing so it has to be here
4885     if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4886         msmpeg4_encode_ext_header(s);
4887 #endif
4888
4889     write_slice_end(s);
4890
4891     /* Send the last GOB if RTP */
4892     if (s->avctx->rtp_callback) {
4893         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4894         /* Call the RTP callback to send the last GOB */
4895         emms_c();
4896         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, 0);
4897     }
4898
4899     return 0;
4900 }
4901
4902 #define MERGE(field) dst->field += src->field; src->field=0
4903 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
4904     MERGE(me.scene_change_score);
4905     MERGE(me.mc_mb_var_sum_temp);
4906     MERGE(me.mb_var_sum_temp);
4907 }
4908
4909 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
4910     int i;
4911
4912     MERGE(dct_count[0]); //note, the other dct vars are not part of the context
4913     MERGE(dct_count[1]);
4914     MERGE(mv_bits);
4915     MERGE(i_tex_bits);
4916     MERGE(p_tex_bits);
4917     MERGE(i_count);
4918     MERGE(f_count);
4919     MERGE(b_count);
4920     MERGE(skip_count);
4921     MERGE(misc_bits);
4922     MERGE(error_count);
4923     MERGE(padding_bug_score);
4924
4925     if(dst->avctx->noise_reduction){
4926         for(i=0; i<64; i++){
4927             MERGE(dct_error_sum[0][i]);
4928             MERGE(dct_error_sum[1][i]);
4929         }
4930     }
4931
4932     assert(put_bits_count(&src->pb) % 8 ==0);
4933     assert(put_bits_count(&dst->pb) % 8 ==0);
4934     ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
4935     flush_put_bits(&dst->pb);
4936 }
4937
4938 static void encode_picture(MpegEncContext *s, int picture_number)
4939 {
4940     int i;
4941     int bits;
4942
4943     s->picture_number = picture_number;
4944
4945     /* Reset the average MB variance */
4946     s->me.mb_var_sum_temp    =
4947     s->me.mc_mb_var_sum_temp = 0;
4948
4949 #ifdef CONFIG_RISKY
4950     /* we need to initialize some time vars before we can encode b-frames */
4951     // RAL: Condition added for MPEG1VIDEO
4952     if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
4953         ff_set_mpeg4_time(s, s->picture_number);  //FIXME rename and use has_b_frames or similar
4954 #endif
4955
4956     s->me.scene_change_score=0;
4957
4958 //    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
4959
4960     if(s->pict_type==I_TYPE){
4961         if(s->msmpeg4_version >= 3) s->no_rounding=1;
4962         else                        s->no_rounding=0;
4963     }else if(s->pict_type!=B_TYPE){
4964         if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
4965             s->no_rounding ^= 1;
4966     }
4967
4968     s->mb_intra=0; //for the rate distoration & bit compare functions
4969     for(i=1; i<s->avctx->thread_count; i++){
4970         ff_update_duplicate_context(s->thread_context[i], s);
4971     }
4972
4973     ff_init_me(s);
4974
4975     /* Estimate motion for every MB */
4976     if(s->pict_type != I_TYPE){
4977         if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
4978             if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
4979                 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4980             }
4981         }
4982
4983         s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4984     }else /* if(s->pict_type == I_TYPE) */{
4985         /* I-Frame */
4986         for(i=0; i<s->mb_stride*s->mb_height; i++)
4987             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
4988
4989         if(!s->fixed_qscale){
4990             /* finding spatial complexity for I-frame rate control */
4991             s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4992         }
4993     }
4994     for(i=1; i<s->avctx->thread_count; i++){
4995         merge_context_after_me(s, s->thread_context[i]);
4996     }
4997     s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
4998     s->current_picture.   mb_var_sum= s->current_picture_ptr->   mb_var_sum= s->me.   mb_var_sum_temp;
4999     emms_c();
5000
5001     if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5002         s->pict_type= I_TYPE;
5003         for(i=0; i<s->mb_stride*s->mb_height; i++)
5004             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5005 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
5006     }
5007
5008     if(!s->umvplus){
5009         if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
5010             s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
5011
5012             if(s->flags & CODEC_FLAG_INTERLACED_ME){
5013                 int a,b;
5014                 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
5015                 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
5016                 s->f_code= FFMAX(s->f_code, FFMAX(a,b));
5017             }
5018
5019             ff_fix_long_p_mvs(s);
5020             ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
5021             if(s->flags & CODEC_FLAG_INTERLACED_ME){
5022                 int j;
5023                 for(i=0; i<2; i++){
5024                     for(j=0; j<2; j++)
5025                         ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5026                                         s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
5027                 }
5028             }
5029         }
5030
5031         if(s->pict_type==B_TYPE){
5032             int a, b;
5033
5034             a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
5035             b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5036             s->f_code = FFMAX(a, b);
5037
5038             a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
5039             b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5040             s->b_code = FFMAX(a, b);
5041
5042             ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
5043             ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
5044             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5045             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5046             if(s->flags & CODEC_FLAG_INTERLACED_ME){
5047                 int dir, j;
5048                 for(dir=0; dir<2; dir++){
5049                     for(i=0; i<2; i++){
5050                         for(j=0; j<2; j++){
5051                             int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
5052                                           : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
5053                             ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5054                                             s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
5055                         }
5056                     }
5057                 }
5058             }
5059         }
5060     }
5061
5062     if (!s->fixed_qscale)
5063         s->current_picture.quality = ff_rate_estimate_qscale(s); //FIXME pic_ptr
5064
5065     if(s->adaptive_quant){
5066 #ifdef CONFIG_RISKY
5067         switch(s->codec_id){
5068         case CODEC_ID_MPEG4:
5069             ff_clean_mpeg4_qscales(s);
5070             break;
5071         case CODEC_ID_H263:
5072         case CODEC_ID_H263P:
5073         case CODEC_ID_FLV1:
5074             ff_clean_h263_qscales(s);
5075             break;
5076         }
5077 #endif
5078
5079         s->lambda= s->lambda_table[0];
5080         //FIXME broken
5081     }else
5082         s->lambda= s->current_picture.quality;
5083 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
5084     update_qscale(s);
5085
5086     if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
5087         s->qscale= 3; //reduce cliping problems
5088
5089     if (s->out_format == FMT_MJPEG) {
5090         /* for mjpeg, we do include qscale in the matrix */
5091         s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
5092         for(i=1;i<64;i++){
5093             int j= s->dsp.idct_permutation[i];
5094
5095             s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
5096         }
5097         convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5098                        s->intra_matrix, s->intra_quant_bias, 8, 8);
5099         s->qscale= 8;
5100     }
5101
5102     //FIXME var duplication
5103     s->current_picture_ptr->key_frame=
5104     s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5105     s->current_picture_ptr->pict_type=
5106     s->current_picture.pict_type= s->pict_type;
5107
5108     if(s->current_picture.key_frame)
5109         s->picture_in_gop_number=0;
5110
5111     s->last_bits= put_bits_count(&s->pb);
5112     switch(s->out_format) {
5113     case FMT_MJPEG:
5114         mjpeg_picture_header(s);
5115         break;
5116 #ifdef CONFIG_RISKY
5117     case FMT_H263:
5118         if (s->codec_id == CODEC_ID_WMV2)
5119             ff_wmv2_encode_picture_header(s, picture_number);
5120         else if (s->h263_msmpeg4)
5121             msmpeg4_encode_picture_header(s, picture_number);
5122         else if (s->h263_pred)
5123             mpeg4_encode_picture_header(s, picture_number);
5124         else if (s->codec_id == CODEC_ID_RV10)
5125             rv10_encode_picture_header(s, picture_number);
5126         else if (s->codec_id == CODEC_ID_FLV1)
5127             ff_flv_encode_picture_header(s, picture_number);
5128         else
5129             h263_encode_picture_header(s, picture_number);
5130         break;
5131 #endif
5132     case FMT_MPEG1:
5133         mpeg1_encode_picture_header(s, picture_number);
5134         break;
5135     case FMT_H264:
5136         break;
5137     default:
5138         assert(0);
5139     }
5140     bits= put_bits_count(&s->pb);
5141     s->header_bits= bits - s->last_bits;
5142
5143     for(i=1; i<s->avctx->thread_count; i++){
5144         update_duplicate_context_after_me(s->thread_context[i], s);
5145     }
5146     s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5147     for(i=1; i<s->avctx->thread_count; i++){
5148         merge_context_after_encode(s, s->thread_context[i]);
5149     }
5150     emms_c();
5151 }
5152
5153 #endif //CONFIG_ENCODERS
5154
5155 static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block){
5156     const int intra= s->mb_intra;
5157     int i;
5158
5159     s->dct_count[intra]++;
5160
5161     for(i=0; i<64; i++){
5162         int level= block[i];
5163
5164         if(level){
5165             if(level>0){
5166                 s->dct_error_sum[intra][i] += level;
5167                 level -= s->dct_offset[intra][i];
5168                 if(level<0) level=0;
5169             }else{
5170                 s->dct_error_sum[intra][i] -= level;
5171                 level += s->dct_offset[intra][i];
5172                 if(level>0) level=0;
5173             }
5174             block[i]= level;
5175         }
5176     }
5177 }
5178
5179 #ifdef CONFIG_ENCODERS
5180
5181 static int dct_quantize_trellis_c(MpegEncContext *s,
5182                         DCTELEM *block, int n,
5183                         int qscale, int *overflow){
5184     const int *qmat;
5185     const uint8_t *scantable= s->intra_scantable.scantable;
5186     const uint8_t *perm_scantable= s->intra_scantable.permutated;
5187     int max=0;
5188     unsigned int threshold1, threshold2;
5189     int bias=0;
5190     int run_tab[65];
5191     int level_tab[65];
5192     int score_tab[65];
5193     int survivor[65];
5194     int survivor_count;
5195     int last_run=0;
5196     int last_level=0;
5197     int last_score= 0;
5198     int last_i;
5199     int coeff[2][64];
5200     int coeff_count[64];
5201     int qmul, qadd, start_i, last_non_zero, i, dc;
5202     const int esc_length= s->ac_esc_length;
5203     uint8_t * length;
5204     uint8_t * last_length;
5205     const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5206
5207     s->dsp.fdct (block);
5208
5209     if(s->dct_error_sum)
5210         s->denoise_dct(s, block);
5211     qmul= qscale*16;
5212     qadd= ((qscale-1)|1)*8;
5213
5214     if (s->mb_intra) {
5215         int q;
5216         if (!s->h263_aic) {
5217             if (n < 4)
5218                 q = s->y_dc_scale;
5219             else
5220                 q = s->c_dc_scale;
5221             q = q << 3;
5222         } else{
5223             /* For AIC we skip quant/dequant of INTRADC */
5224             q = 1 << 3;
5225             qadd=0;
5226         }
5227
5228         /* note: block[0] is assumed to be positive */
5229         block[0] = (block[0] + (q >> 1)) / q;
5230         start_i = 1;
5231         last_non_zero = 0;
5232         qmat = s->q_intra_matrix[qscale];
5233         if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5234             bias= 1<<(QMAT_SHIFT-1);
5235         length     = s->intra_ac_vlc_length;
5236         last_length= s->intra_ac_vlc_last_length;
5237     } else {
5238         start_i = 0;
5239         last_non_zero = -1;
5240         qmat = s->q_inter_matrix[qscale];
5241         length     = s->inter_ac_vlc_length;
5242         last_length= s->inter_ac_vlc_last_length;
5243     }
5244     last_i= start_i;
5245
5246     threshold1= (1<<QMAT_SHIFT) - bias - 1;
5247     threshold2= (threshold1<<1);
5248
5249     for(i=63; i>=start_i; i--) {
5250         const int j = scantable[i];
5251         int level = block[j] * qmat[j];
5252
5253         if(((unsigned)(level+threshold1))>threshold2){
5254             last_non_zero = i;
5255             break;
5256         }
5257     }
5258
5259     for(i=start_i; i<=last_non_zero; i++) {
5260         const int j = scantable[i];
5261         int level = block[j] * qmat[j];
5262
5263 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
5264 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
5265         if(((unsigned)(level+threshold1))>threshold2){
5266             if(level>0){
5267                 level= (bias + level)>>QMAT_SHIFT;
5268                 coeff[0][i]= level;
5269                 coeff[1][i]= level-1;
5270 //                coeff[2][k]= level-2;
5271             }else{
5272                 level= (bias - level)>>QMAT_SHIFT;
5273                 coeff[0][i]= -level;
5274                 coeff[1][i]= -level+1;
5275 //                coeff[2][k]= -level+2;
5276             }
5277             coeff_count[i]= FFMIN(level, 2);
5278             assert(coeff_count[i]);
5279             max |=level;
5280         }else{
5281             coeff[0][i]= (level>>31)|1;
5282             coeff_count[i]= 1;
5283         }
5284     }
5285
5286     *overflow= s->max_qcoeff < max; //overflow might have happend
5287
5288     if(last_non_zero < start_i){
5289         memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5290         return last_non_zero;
5291     }
5292
5293     score_tab[start_i]= 0;
5294     survivor[0]= start_i;
5295     survivor_count= 1;
5296
5297     for(i=start_i; i<=last_non_zero; i++){
5298         int level_index, j;
5299         const int dct_coeff= ABS(block[ scantable[i] ]);
5300         const int zero_distoration= dct_coeff*dct_coeff;
5301         int best_score=256*256*256*120;
5302         for(level_index=0; level_index < coeff_count[i]; level_index++){
5303             int distoration;
5304             int level= coeff[level_index][i];
5305             const int alevel= ABS(level);
5306             int unquant_coeff;
5307
5308             assert(level);
5309
5310             if(s->out_format == FMT_H263){
5311                 unquant_coeff= alevel*qmul + qadd;
5312             }else{ //MPEG1
5313                 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
5314                 if(s->mb_intra){
5315                         unquant_coeff = (int)(  alevel  * qscale * s->intra_matrix[j]) >> 3;
5316                         unquant_coeff =   (unquant_coeff - 1) | 1;
5317                 }else{
5318                         unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
5319                         unquant_coeff =   (unquant_coeff - 1) | 1;
5320                 }
5321                 unquant_coeff<<= 3;
5322             }
5323
5324             distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
5325             level+=64;
5326             if((level&(~127)) == 0){
5327                 for(j=survivor_count-1; j>=0; j--){
5328                     int run= i - survivor[j];
5329                     int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5330                     score += score_tab[i-run];
5331
5332                     if(score < best_score){
5333                         best_score= score;
5334                         run_tab[i+1]= run;
5335                         level_tab[i+1]= level-64;
5336                     }
5337                 }
5338
5339                 if(s->out_format == FMT_H263){
5340                     for(j=survivor_count-1; j>=0; j--){
5341                         int run= i - survivor[j];
5342                         int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5343                         score += score_tab[i-run];
5344                         if(score < last_score){
5345                             last_score= score;
5346                             last_run= run;
5347                             last_level= level-64;
5348                             last_i= i+1;
5349                         }
5350                     }
5351                 }
5352             }else{
5353                 distoration += esc_length*lambda;
5354                 for(j=survivor_count-1; j>=0; j--){
5355                     int run= i - survivor[j];
5356                     int score= distoration + score_tab[i-run];
5357
5358                     if(score < best_score){
5359                         best_score= score;
5360                         run_tab[i+1]= run;
5361                         level_tab[i+1]= level-64;
5362                     }
5363                 }
5364
5365                 if(s->out_format == FMT_H263){
5366                   for(j=survivor_count-1; j>=0; j--){
5367                         int run= i - survivor[j];
5368                         int score= distoration + score_tab[i-run];
5369                         if(score < last_score){
5370                             last_score= score;
5371                             last_run= run;
5372                             last_level= level-64;
5373                             last_i= i+1;
5374                         }
5375                     }
5376                 }
5377             }
5378         }
5379
5380         score_tab[i+1]= best_score;
5381
5382         //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
5383         if(last_non_zero <= 27){
5384             for(; survivor_count; survivor_count--){
5385                 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
5386                     break;
5387             }
5388         }else{
5389             for(; survivor_count; survivor_count--){
5390                 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
5391                     break;
5392             }
5393         }
5394
5395         survivor[ survivor_count++ ]= i+1;
5396     }
5397
5398     if(s->out_format != FMT_H263){
5399         last_score= 256*256*256*120;
5400         for(i= survivor[0]; i<=last_non_zero + 1; i++){
5401             int score= score_tab[i];
5402             if(i) score += lambda*2; //FIXME exacter?
5403
5404             if(score < last_score){
5405                 last_score= score;
5406                 last_i= i;
5407                 last_level= level_tab[i];
5408                 last_run= run_tab[i];
5409             }
5410         }
5411     }
5412
5413     s->coded_score[n] = last_score;
5414
5415     dc= ABS(block[0]);
5416     last_non_zero= last_i - 1;
5417     memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5418
5419     if(last_non_zero < start_i)
5420         return last_non_zero;
5421
5422     if(last_non_zero == 0 && start_i == 0){
5423         int best_level= 0;
5424         int best_score= dc * dc;
5425
5426         for(i=0; i<coeff_count[0]; i++){
5427             int level= coeff[i][0];
5428             int alevel= ABS(level);
5429             int unquant_coeff, score, distortion;
5430
5431             if(s->out_format == FMT_H263){
5432                     unquant_coeff= (alevel*qmul + qadd)>>3;
5433             }else{ //MPEG1
5434                     unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
5435                     unquant_coeff =   (unquant_coeff - 1) | 1;
5436             }
5437             unquant_coeff = (unquant_coeff + 4) >> 3;
5438             unquant_coeff<<= 3 + 3;
5439
5440             distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
5441             level+=64;
5442             if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
5443             else                    score= distortion + esc_length*lambda;
5444
5445             if(score < best_score){
5446                 best_score= score;
5447                 best_level= level - 64;
5448             }
5449         }
5450         block[0]= best_level;
5451         s->coded_score[n] = best_score - dc*dc;
5452         if(best_level == 0) return -1;
5453         else                return last_non_zero;
5454     }
5455
5456     i= last_i;
5457     assert(last_level);
5458
5459     block[ perm_scantable[last_non_zero] ]= last_level;
5460     i -= last_run + 1;
5461
5462     for(; i>start_i; i -= run_tab[i] + 1){
5463         block[ perm_scantable[i-1] ]= level_tab[i];
5464     }
5465
5466     return last_non_zero;
5467 }
5468
5469 //#define REFINE_STATS 1
5470 static int16_t basis[64][64];
5471
5472 static void build_basis(uint8_t *perm){
5473     int i, j, x, y;
5474     emms_c();
5475     for(i=0; i<8; i++){
5476         for(j=0; j<8; j++){
5477             for(y=0; y<8; y++){
5478                 for(x=0; x<8; x++){
5479                     double s= 0.25*(1<<BASIS_SHIFT);
5480                     int index= 8*i + j;
5481                     int perm_index= perm[index];
5482                     if(i==0) s*= sqrt(0.5);
5483                     if(j==0) s*= sqrt(0.5);
5484                     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)));
5485                 }
5486             }
5487         }
5488     }
5489 }
5490
5491 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
5492                         DCTELEM *block, int16_t *weight, DCTELEM *orig,
5493                         int n, int qscale){
5494     int16_t rem[64];
5495     DCTELEM d1[64];
5496     const int *qmat;
5497     const uint8_t *scantable= s->intra_scantable.scantable;
5498     const uint8_t *perm_scantable= s->intra_scantable.permutated;
5499 //    unsigned int threshold1, threshold2;
5500 //    int bias=0;
5501     int run_tab[65];
5502     int prev_run=0;
5503     int prev_level=0;
5504     int qmul, qadd, start_i, last_non_zero, i, dc;
5505     uint8_t * length;
5506     uint8_t * last_length;
5507     int lambda;
5508     int rle_index, run, q, sum;
5509 #ifdef REFINE_STATS
5510 static int count=0;
5511 static int after_last=0;
5512 static int to_zero=0;
5513 static int from_zero=0;
5514 static int raise=0;
5515 static int lower=0;
5516 static int messed_sign=0;
5517 #endif
5518
5519     if(basis[0][0] == 0)
5520         build_basis(s->dsp.idct_permutation);
5521
5522     qmul= qscale*2;
5523     qadd= (qscale-1)|1;
5524     if (s->mb_intra) {
5525         if (!s->h263_aic) {
5526             if (n < 4)
5527                 q = s->y_dc_scale;
5528             else
5529                 q = s->c_dc_scale;
5530         } else{
5531             /* For AIC we skip quant/dequant of INTRADC */
5532             q = 1;
5533             qadd=0;
5534         }
5535         q <<= RECON_SHIFT-3;
5536         /* note: block[0] is assumed to be positive */
5537         dc= block[0]*q;
5538 //        block[0] = (block[0] + (q >> 1)) / q;
5539         start_i = 1;
5540         qmat = s->q_intra_matrix[qscale];
5541 //        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5542 //            bias= 1<<(QMAT_SHIFT-1);
5543         length     = s->intra_ac_vlc_length;
5544         last_length= s->intra_ac_vlc_last_length;
5545     } else {
5546         dc= 0;
5547         start_i = 0;
5548         qmat = s->q_inter_matrix[qscale];
5549         length     = s->inter_ac_vlc_length;
5550         last_length= s->inter_ac_vlc_last_length;
5551     }
5552     last_non_zero = s->block_last_index[n];
5553
5554 #ifdef REFINE_STATS
5555 {START_TIMER
5556 #endif
5557     dc += (1<<(RECON_SHIFT-1));
5558     for(i=0; i<64; i++){
5559         rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME  use orig dirrectly insteadof copying to rem[]
5560     }
5561 #ifdef REFINE_STATS
5562 STOP_TIMER("memset rem[]")}
5563 #endif
5564     sum=0;
5565     for(i=0; i<64; i++){
5566         int one= 36;
5567         int qns=4;
5568         int w;
5569
5570         w= ABS(weight[i]) + qns*one;
5571         w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
5572
5573         weight[i] = w;
5574 //        w=weight[i] = (63*qns + (w/2)) / w;
5575
5576         assert(w>0);
5577         assert(w<(1<<6));
5578         sum += w*w;
5579     }
5580     lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
5581 #ifdef REFINE_STATS
5582 {START_TIMER
5583 #endif
5584     run=0;
5585     rle_index=0;
5586     for(i=start_i; i<=last_non_zero; i++){
5587         int j= perm_scantable[i];
5588         const int level= block[j];
5589         int coeff;
5590
5591         if(level){
5592             if(level<0) coeff= qmul*level - qadd;
5593             else        coeff= qmul*level + qadd;
5594             run_tab[rle_index++]=run;
5595             run=0;
5596
5597             s->dsp.add_8x8basis(rem, basis[j], coeff);
5598         }else{
5599             run++;
5600         }
5601     }
5602 #ifdef REFINE_STATS
5603 if(last_non_zero>0){
5604 STOP_TIMER("init rem[]")
5605 }
5606 }
5607
5608 {START_TIMER
5609 #endif
5610     for(;;){
5611         int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
5612         int best_coeff=0;
5613         int best_change=0;
5614         int run2, best_unquant_change=0, analyze_gradient;
5615 #ifdef REFINE_STATS
5616 {START_TIMER
5617 #endif
5618         analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
5619
5620         if(analyze_gradient){
5621 #ifdef REFINE_STATS
5622 {START_TIMER
5623 #endif
5624             for(i=0; i<64; i++){
5625                 int w= weight[i];
5626
5627                 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
5628             }
5629 #ifdef REFINE_STATS
5630 STOP_TIMER("rem*w*w")}
5631 {START_TIMER
5632 #endif
5633             s->dsp.fdct(d1);
5634 #ifdef REFINE_STATS
5635 STOP_TIMER("dct")}
5636 #endif
5637         }
5638
5639         if(start_i){
5640             const int level= block[0];
5641             int change, old_coeff;
5642
5643             assert(s->mb_intra);
5644
5645             old_coeff= q*level;
5646
5647             for(change=-1; change<=1; change+=2){
5648                 int new_level= level + change;
5649                 int score, new_coeff;
5650
5651                 new_coeff= q*new_level;
5652                 if(new_coeff >= 2048 || new_coeff < 0)
5653                     continue;
5654
5655                 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
5656                 if(score<best_score){
5657                     best_score= score;
5658                     best_coeff= 0;
5659                     best_change= change;
5660                     best_unquant_change= new_coeff - old_coeff;
5661                 }
5662             }
5663         }
5664
5665         run=0;
5666         rle_index=0;
5667         run2= run_tab[rle_index++];
5668         prev_level=0;
5669         prev_run=0;
5670
5671         for(i=start_i; i<64; i++){
5672             int j= perm_scantable[i];
5673             const int level= block[j];
5674             int change, old_coeff;
5675
5676             if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
5677                 break;
5678
5679             if(level){
5680                 if(level<0) old_coeff= qmul*level - qadd;
5681                 else        old_coeff= qmul*level + qadd;
5682                 run2= run_tab[rle_index++]; //FIXME ! maybe after last
5683             }else{
5684                 old_coeff=0;
5685                 run2--;
5686                 assert(run2>=0 || i >= last_non_zero );
5687             }
5688
5689             for(change=-1; change<=1; change+=2){
5690                 int new_level= level + change;
5691                 int score, new_coeff, unquant_change;
5692
5693                 score=0;
5694                 if(s->avctx->quantizer_noise_shaping < 2 && ABS(new_level) > ABS(level))
5695                    continue;
5696
5697                 if(new_level){
5698                     if(new_level<0) new_coeff= qmul*new_level - qadd;
5699                     else            new_coeff= qmul*new_level + qadd;
5700                     if(new_coeff >= 2048 || new_coeff <= -2048)
5701                         continue;
5702                     //FIXME check for overflow
5703
5704                     if(level){
5705                         if(level < 63 && level > -63){
5706                             if(i < last_non_zero)
5707                                 score +=   length[UNI_AC_ENC_INDEX(run, new_level+64)]
5708                                          - length[UNI_AC_ENC_INDEX(run, level+64)];
5709                             else
5710                                 score +=   last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
5711                                          - last_length[UNI_AC_ENC_INDEX(run, level+64)];
5712                         }
5713                     }else{
5714                         assert(ABS(new_level)==1);
5715
5716                         if(analyze_gradient){
5717                             int g= d1[ scantable[i] ];
5718                             if(g && (g^new_level) >= 0)
5719                                 continue;
5720                         }
5721
5722                         if(i < last_non_zero){
5723                             int next_i= i + run2 + 1;
5724                             int next_level= block[ perm_scantable[next_i] ] + 64;
5725
5726                             if(next_level&(~127))
5727                                 next_level= 0;
5728
5729                             if(next_i < last_non_zero)
5730                                 score +=   length[UNI_AC_ENC_INDEX(run, 65)]
5731                                          + length[UNI_AC_ENC_INDEX(run2, next_level)]
5732                                          - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
5733                             else
5734                                 score +=  length[UNI_AC_ENC_INDEX(run, 65)]
5735                                         + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
5736                                         - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
5737                         }else{
5738                             score += last_length[UNI_AC_ENC_INDEX(run, 65)];
5739                             if(prev_level){
5740                                 score +=  length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
5741                                         - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
5742                             }
5743                         }
5744                     }
5745                 }else{
5746                     new_coeff=0;
5747                     assert(ABS(level)==1);
5748
5749                     if(i < last_non_zero){
5750                         int next_i= i + run2 + 1;
5751                         int next_level= block[ perm_scantable[next_i] ] + 64;
5752
5753                         if(next_level&(~127))
5754                             next_level= 0;
5755
5756                         if(next_i < last_non_zero)
5757                             score +=   length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
5758                                      - length[UNI_AC_ENC_INDEX(run2, next_level)]
5759                                      - length[UNI_AC_ENC_INDEX(run, 65)];
5760                         else
5761                             score +=   last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
5762                                      - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
5763                                      - length[UNI_AC_ENC_INDEX(run, 65)];
5764                     }else{
5765                         score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
5766                         if(prev_level){
5767                             score +=  last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
5768                                     - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
5769                         }
5770                     }
5771                 }
5772
5773                 score *= lambda;
5774
5775                 unquant_change= new_coeff - old_coeff;
5776                 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
5777
5778                 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
5779                 if(score<best_score){
5780                     best_score= score;
5781                     best_coeff= i;
5782                     best_change= change;
5783                     best_unquant_change= unquant_change;
5784                 }
5785             }
5786             if(level){
5787                 prev_level= level + 64;
5788                 if(prev_level&(~127))
5789                     prev_level= 0;
5790                 prev_run= run;
5791                 run=0;
5792             }else{
5793                 run++;
5794             }
5795         }
5796 #ifdef REFINE_STATS
5797 STOP_TIMER("iterative step")}
5798 #endif
5799
5800         if(best_change){
5801             int j= perm_scantable[ best_coeff ];
5802
5803             block[j] += best_change;
5804
5805             if(best_coeff > last_non_zero){
5806                 last_non_zero= best_coeff;
5807                 assert(block[j]);
5808 #ifdef REFINE_STATS
5809 after_last++;
5810 #endif
5811             }else{
5812 #ifdef REFINE_STATS
5813 if(block[j]){
5814     if(block[j] - best_change){
5815         if(ABS(block[j]) > ABS(block[j] - best_change)){
5816             raise++;
5817         }else{
5818             lower++;
5819         }
5820     }else{
5821         from_zero++;
5822     }
5823 }else{
5824     to_zero++;
5825 }
5826 #endif
5827                 for(; last_non_zero>=start_i; last_non_zero--){
5828                     if(block[perm_scantable[last_non_zero]])
5829                         break;
5830                 }
5831             }
5832 #ifdef REFINE_STATS
5833 count++;
5834 if(256*256*256*64 % count == 0){
5835     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);
5836 }
5837 #endif
5838             run=0;
5839             rle_index=0;
5840             for(i=start_i; i<=last_non_zero; i++){
5841                 int j= perm_scantable[i];
5842                 const int level= block[j];
5843
5844                  if(level){
5845                      run_tab[rle_index++]=run;
5846                      run=0;
5847                  }else{
5848                      run++;
5849                  }
5850             }
5851
5852             s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
5853         }else{
5854             break;
5855         }
5856     }
5857 #ifdef REFINE_STATS
5858 if(last_non_zero>0){
5859 STOP_TIMER("iterative search")
5860 }
5861 }
5862 #endif
5863
5864     return last_non_zero;
5865 }
5866
5867 static int dct_quantize_c(MpegEncContext *s,
5868                         DCTELEM *block, int n,
5869                         int qscale, int *overflow)
5870 {
5871     int i, j, level, last_non_zero, q, start_i;
5872     const int *qmat;
5873     const uint8_t *scantable= s->intra_scantable.scantable;
5874     int bias;
5875     int max=0;
5876     unsigned int threshold1, threshold2;
5877
5878     s->dsp.fdct (block);
5879
5880     if(s->dct_error_sum)
5881         s->denoise_dct(s, block);
5882
5883     if (s->mb_intra) {
5884         if (!s->h263_aic) {
5885             if (n < 4)
5886                 q = s->y_dc_scale;
5887             else
5888                 q = s->c_dc_scale;
5889             q = q << 3;
5890         } else
5891             /* For AIC we skip quant/dequant of INTRADC */
5892             q = 1 << 3;
5893
5894         /* note: block[0] is assumed to be positive */
5895         block[0] = (block[0] + (q >> 1)) / q;
5896         start_i = 1;
5897         last_non_zero = 0;
5898         qmat = s->q_intra_matrix[qscale];
5899         bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
5900     } else {
5901         start_i = 0;
5902         last_non_zero = -1;
5903         qmat = s->q_inter_matrix[qscale];
5904         bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
5905     }
5906     threshold1= (1<<QMAT_SHIFT) - bias - 1;
5907     threshold2= (threshold1<<1);
5908     for(i=63;i>=start_i;i--) {
5909         j = scantable[i];
5910         level = block[j] * qmat[j];
5911
5912         if(((unsigned)(level+threshold1))>threshold2){
5913             last_non_zero = i;
5914             break;
5915         }else{
5916             block[j]=0;
5917         }
5918     }
5919     for(i=start_i; i<=last_non_zero; i++) {
5920         j = scantable[i];
5921         level = block[j] * qmat[j];
5922
5923 //        if(   bias+level >= (1<<QMAT_SHIFT)
5924 //           || bias-level >= (1<<QMAT_SHIFT)){
5925         if(((unsigned)(level+threshold1))>threshold2){
5926             if(level>0){
5927                 level= (bias + level)>>QMAT_SHIFT;
5928                 block[j]= level;
5929             }else{
5930                 level= (bias - level)>>QMAT_SHIFT;
5931                 block[j]= -level;
5932             }
5933             max |=level;
5934         }else{
5935             block[j]=0;
5936         }
5937     }
5938     *overflow= s->max_qcoeff < max; //overflow might have happend
5939
5940     /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
5941     if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
5942         ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
5943
5944     return last_non_zero;
5945 }
5946
5947 #endif //CONFIG_ENCODERS
5948
5949 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
5950                                    DCTELEM *block, int n, int qscale)
5951 {
5952     int i, level, nCoeffs;
5953     const uint16_t *quant_matrix;
5954
5955     nCoeffs= s->block_last_index[n];
5956
5957     if (n < 4)
5958         block[0] = block[0] * s->y_dc_scale;
5959     else
5960         block[0] = block[0] * s->c_dc_scale;
5961     /* XXX: only mpeg1 */
5962     quant_matrix = s->intra_matrix;
5963     for(i=1;i<=nCoeffs;i++) {
5964         int j= s->intra_scantable.permutated[i];
5965         level = block[j];
5966         if (level) {
5967             if (level < 0) {
5968                 level = -level;
5969                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
5970                 level = (level - 1) | 1;
5971                 level = -level;
5972             } else {
5973                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
5974                 level = (level - 1) | 1;
5975             }
5976             block[j] = level;
5977         }
5978     }
5979 }
5980
5981 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
5982                                    DCTELEM *block, int n, int qscale)
5983 {
5984     int i, level, nCoeffs;
5985     const uint16_t *quant_matrix;
5986
5987     nCoeffs= s->block_last_index[n];
5988
5989     quant_matrix = s->inter_matrix;
5990     for(i=0; i<=nCoeffs; i++) {
5991         int j= s->intra_scantable.permutated[i];
5992         level = block[j];
5993         if (level) {
5994             if (level < 0) {
5995                 level = -level;
5996                 level = (((level << 1) + 1) * qscale *
5997                          ((int) (quant_matrix[j]))) >> 4;
5998                 level = (level - 1) | 1;
5999                 level = -level;
6000             } else {
6001                 level = (((level << 1) + 1) * qscale *
6002                          ((int) (quant_matrix[j]))) >> 4;
6003                 level = (level - 1) | 1;
6004             }
6005             block[j] = level;
6006         }
6007     }
6008 }
6009
6010 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6011                                    DCTELEM *block, int n, int qscale)
6012 {
6013     int i, level, nCoeffs;
6014     const uint16_t *quant_matrix;
6015
6016     if(s->alternate_scan) nCoeffs= 63;
6017     else nCoeffs= s->block_last_index[n];
6018
6019     if (n < 4)
6020         block[0] = block[0] * s->y_dc_scale;
6021     else
6022         block[0] = block[0] * s->c_dc_scale;
6023     quant_matrix = s->intra_matrix;
6024     for(i=1;i<=nCoeffs;i++) {
6025         int j= s->intra_scantable.permutated[i];
6026         level = block[j];
6027         if (level) {
6028             if (level < 0) {
6029                 level = -level;
6030                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6031                 level = -level;
6032             } else {
6033                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6034             }
6035             block[j] = level;
6036         }
6037     }
6038 }
6039
6040 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
6041                                    DCTELEM *block, int n, int qscale)
6042 {
6043     int i, level, nCoeffs;
6044     const uint16_t *quant_matrix;
6045     int sum=-1;
6046
6047     if(s->alternate_scan) nCoeffs= 63;
6048     else nCoeffs= s->block_last_index[n];
6049
6050     quant_matrix = s->inter_matrix;
6051     for(i=0; i<=nCoeffs; i++) {
6052         int j= s->intra_scantable.permutated[i];
6053         level = block[j];
6054         if (level) {
6055             if (level < 0) {
6056                 level = -level;
6057                 level = (((level << 1) + 1) * qscale *
6058                          ((int) (quant_matrix[j]))) >> 4;
6059                 level = -level;
6060             } else {
6061                 level = (((level << 1) + 1) * qscale *
6062                          ((int) (quant_matrix[j]))) >> 4;
6063             }
6064             block[j] = level;
6065             sum+=level;
6066         }
6067     }
6068     block[63]^=sum&1;
6069 }
6070
6071 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
6072                                   DCTELEM *block, int n, int qscale)
6073 {
6074     int i, level, qmul, qadd;
6075     int nCoeffs;
6076
6077     assert(s->block_last_index[n]>=0);
6078
6079     qmul = qscale << 1;
6080
6081     if (!s->h263_aic) {
6082         if (n < 4)
6083             block[0] = block[0] * s->y_dc_scale;
6084         else
6085             block[0] = block[0] * s->c_dc_scale;
6086         qadd = (qscale - 1) | 1;
6087     }else{
6088         qadd = 0;
6089     }
6090     if(s->ac_pred)
6091         nCoeffs=63;
6092     else
6093         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6094
6095     for(i=1; i<=nCoeffs; i++) {
6096         level = block[i];
6097         if (level) {
6098             if (level < 0) {
6099                 level = level * qmul - qadd;
6100             } else {
6101                 level = level * qmul + qadd;
6102             }
6103             block[i] = level;
6104         }
6105     }
6106 }
6107
6108 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6109                                   DCTELEM *block, int n, int qscale)
6110 {
6111     int i, level, qmul, qadd;
6112     int nCoeffs;
6113
6114     assert(s->block_last_index[n]>=0);
6115
6116     qadd = (qscale - 1) | 1;
6117     qmul = qscale << 1;
6118
6119     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6120
6121     for(i=0; i<=nCoeffs; i++) {
6122         level = block[i];
6123         if (level) {
6124             if (level < 0) {
6125                 level = level * qmul - qadd;
6126             } else {
6127                 level = level * qmul + qadd;
6128             }
6129             block[i] = level;
6130         }
6131     }
6132 }
6133
6134 static void dct_unquantize_h261_intra_c(MpegEncContext *s,
6135                                   DCTELEM *block, int n, int qscale)
6136 {
6137     int i, level, even;
6138     int nCoeffs;
6139
6140     assert(s->block_last_index[n]>=0);
6141
6142     if (n < 4)
6143         block[0] = block[0] * s->y_dc_scale;
6144     else
6145         block[0] = block[0] * s->c_dc_scale;
6146     even = (qscale & 1)^1;
6147     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6148
6149     for(i=1; i<=nCoeffs; i++){
6150         level = block[i];
6151         if (level){
6152             if (level < 0){
6153                 level = qscale * ((level << 1) - 1) + even;
6154             }else{
6155                 level = qscale * ((level << 1) + 1) - even;
6156             }
6157         }
6158         block[i] = level;
6159     }
6160 }
6161
6162 static void dct_unquantize_h261_inter_c(MpegEncContext *s,
6163                                   DCTELEM *block, int n, int qscale)
6164 {
6165     int i, level, even;
6166     int nCoeffs;
6167
6168     assert(s->block_last_index[n]>=0);
6169
6170     even = (qscale & 1)^1;
6171
6172     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6173
6174     for(i=0; i<=nCoeffs; i++){
6175         level = block[i];
6176         if (level){
6177             if (level < 0){
6178                 level = qscale * ((level << 1) - 1) + even;
6179             }else{
6180                 level = qscale * ((level << 1) + 1) - even;
6181             }
6182         }
6183         block[i] = level;
6184     }
6185 }
6186
6187 static const AVOption mpeg4_options[] =
6188 {
6189     AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
6190     AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
6191                        "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
6192                        bit_rate_tolerance, 4, 240000000, 8000),
6193     AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
6194     AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
6195     AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
6196                           rc_eq, "tex^qComp,option1,options2", 0),
6197     AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
6198                        rc_min_rate, 4, 24000000, 0),
6199     AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
6200                        rc_max_rate, 4, 24000000, 0),
6201     AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
6202                           rc_buffer_aggressivity, 4, 24000000, 0),
6203     AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
6204                           rc_initial_cplx, 0., 9999999., 0),
6205     AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
6206                           i_quant_factor, 0., 0., 0),
6207     AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
6208                           i_quant_factor, -999999., 999999., 0),
6209     AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
6210                        dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
6211     AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
6212                           lumi_masking, 0., 999999., 0),
6213     AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
6214                           temporal_cplx_masking, 0., 999999., 0),
6215     AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
6216                           spatial_cplx_masking, 0., 999999., 0),
6217     AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
6218                           p_masking, 0., 999999., 0),
6219     AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
6220                           dark_masking, 0., 999999., 0),
6221     AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
6222                        idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
6223
6224     AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
6225                        mb_qmin, 0, 8, 0),
6226     AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
6227                        mb_qmin, 0, 8, 0),
6228
6229     AVOPTION_CODEC_INT("me_cmp", "ME compare function",
6230                        me_cmp, 0, 24000000, 0),
6231     AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
6232                        me_sub_cmp, 0, 24000000, 0),
6233
6234
6235     AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
6236                        dia_size, 0, 24000000, 0),
6237     AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
6238                        last_predictor_count, 0, 24000000, 0),
6239
6240     AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
6241                        pre_me, 0, 24000000, 0),
6242     AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
6243                        me_pre_cmp, 0, 24000000, 0),
6244
6245     AVOPTION_CODEC_INT("me_range", "maximum ME search range",
6246                        me_range, 0, 24000000, 0),
6247     AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
6248                        pre_dia_size, 0, 24000000, 0),
6249     AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
6250                        me_subpel_quality, 0, 24000000, 0),
6251     AVOPTION_CODEC_INT("me_range", "maximum ME search range",
6252                        me_range, 0, 24000000, 0),
6253     AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
6254                         flags, CODEC_FLAG_PSNR, 0),
6255     AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
6256                               rc_override),
6257     AVOPTION_SUB(avoptions_common),
6258     AVOPTION_END()
6259 };
6260
6261 #ifdef CONFIG_ENCODERS
6262 #ifdef CONFIG_RISKY
6263 AVCodec h263_encoder = {
6264     "h263",
6265     CODEC_TYPE_VIDEO,
6266     CODEC_ID_H263,
6267     sizeof(MpegEncContext),
6268     MPV_encode_init,
6269     MPV_encode_picture,
6270     MPV_encode_end,
6271 };
6272
6273 AVCodec h263p_encoder = {
6274     "h263p",
6275     CODEC_TYPE_VIDEO,
6276     CODEC_ID_H263P,
6277     sizeof(MpegEncContext),
6278     MPV_encode_init,
6279     MPV_encode_picture,
6280     MPV_encode_end,
6281 };
6282
6283 AVCodec flv_encoder = {
6284     "flv",
6285     CODEC_TYPE_VIDEO,
6286     CODEC_ID_FLV1,
6287     sizeof(MpegEncContext),
6288     MPV_encode_init,
6289     MPV_encode_picture,
6290     MPV_encode_end,
6291 };
6292
6293 AVCodec rv10_encoder = {
6294     "rv10",
6295     CODEC_TYPE_VIDEO,
6296     CODEC_ID_RV10,
6297     sizeof(MpegEncContext),
6298     MPV_encode_init,
6299     MPV_encode_picture,
6300     MPV_encode_end,
6301 };
6302
6303 AVCodec mpeg4_encoder = {
6304     "mpeg4",
6305     CODEC_TYPE_VIDEO,
6306     CODEC_ID_MPEG4,
6307     sizeof(MpegEncContext),
6308     MPV_encode_init,
6309     MPV_encode_picture,
6310     MPV_encode_end,
6311     .options = mpeg4_options,
6312     .capabilities= CODEC_CAP_DELAY,
6313 };
6314
6315 AVCodec msmpeg4v1_encoder = {
6316     "msmpeg4v1",
6317     CODEC_TYPE_VIDEO,
6318     CODEC_ID_MSMPEG4V1,
6319     sizeof(MpegEncContext),
6320     MPV_encode_init,
6321     MPV_encode_picture,
6322     MPV_encode_end,
6323     .options = mpeg4_options,
6324 };
6325
6326 AVCodec msmpeg4v2_encoder = {
6327     "msmpeg4v2",
6328     CODEC_TYPE_VIDEO,
6329     CODEC_ID_MSMPEG4V2,
6330     sizeof(MpegEncContext),
6331     MPV_encode_init,
6332     MPV_encode_picture,
6333     MPV_encode_end,
6334     .options = mpeg4_options,
6335 };
6336
6337 AVCodec msmpeg4v3_encoder = {
6338     "msmpeg4",
6339     CODEC_TYPE_VIDEO,
6340     CODEC_ID_MSMPEG4V3,
6341     sizeof(MpegEncContext),
6342     MPV_encode_init,
6343     MPV_encode_picture,
6344     MPV_encode_end,
6345     .options = mpeg4_options,
6346 };
6347
6348 AVCodec wmv1_encoder = {
6349     "wmv1",
6350     CODEC_TYPE_VIDEO,
6351     CODEC_ID_WMV1,
6352     sizeof(MpegEncContext),
6353     MPV_encode_init,
6354     MPV_encode_picture,
6355     MPV_encode_end,
6356     .options = mpeg4_options,
6357 };
6358
6359 #endif
6360
6361 AVCodec mjpeg_encoder = {
6362     "mjpeg",
6363     CODEC_TYPE_VIDEO,
6364     CODEC_ID_MJPEG,
6365     sizeof(MpegEncContext),
6366     MPV_encode_init,
6367     MPV_encode_picture,
6368     MPV_encode_end,
6369 };
6370
6371 #endif //CONFIG_ENCODERS