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  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
  20  */
  21 #include "avcodec.h"
  22 #include "dsputil.h"
  23 #include "mpegvideo.h"
  24
  25 #ifdef USE_FASTMEMCPY
  26 #include "fastmemcpy.h"
  27 #endif
  28
  29 static void encode_picture(MpegEncContext *s, int picture_number);
  30 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
  31                                    DCTELEM *block, int n, int qscale);
  32 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
  33                                    DCTELEM *block, int n, int qscale);
  34 static void dct_unquantize_h263_c(MpegEncContext *s,
  35                                   DCTELEM *block, int n, int qscale);
  36 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);
  37 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
  38
  39 void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
  40 static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h,
  41                                     int src_x, int src_y, int w, int h);
  42
  43 #define EDGE_WIDTH 16
  44
  45 /* enable all paranoid tests for rounding, overflows, etc... */
  46 //#define PARANOID
  47
  48 //#define DEBUG
  49
  50
  51 /* for jpeg fast DCT */
  52 #define CONST_BITS 14
  53
  54 static const unsigned short aanscales[64] = {
  55     /* precomputed values scaled up by 14 bits */
  56     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  57     22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
  58     21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
  59     19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
  60     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  61     12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
  62     8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
  63     4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
  64 };
  65
  66 static UINT8 h263_chroma_roundtab[16] = {
  67     0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
  68 };
  69
  70 static UINT16 default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
  71 static UINT8 default_fcode_tab[MAX_MV*2+1];
  72
  73 extern UINT8 zigzag_end[64];
  74
  75 /* default motion estimation */
  76 int motion_estimation_method = ME_EPZS;
  77
  78 static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
  79                            const UINT16 *quant_matrix, int bias)
  80 {
  81     int qscale;
  82
  83     for(qscale=1; qscale<32; qscale++){
  84         int i;
  85         if (s->fdct == ff_jpeg_fdct_islow) {
  86             for(i=0;i<64;i++) {
  87                 const int j= block_permute_op(i);
  88                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
  89                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
  90                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
  91                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
  92
  93                 qmat[qscale][j] = (int)((UINT64_C(1) << (QMAT_SHIFT-3)) /
  94                                 (qscale * quant_matrix[j]));
  95             }
  96         } else if (s->fdct == fdct_ifast) {
  97             for(i=0;i<64;i++) {
  98                 const int j= block_permute_op(i);
  99                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
 100                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
 101                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
 102                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
 103
 104                 qmat[qscale][j] = (int)((UINT64_C(1) << (QMAT_SHIFT + 11)) /
 105                                 (aanscales[i] * qscale * quant_matrix[j]));
 106             }
 107         } else {
 108             for(i=0;i<64;i++) {
 109                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
 110                    So 16           <= qscale * quant_matrix[i]             <= 7905
 111                    so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
 112                    so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
 113                 */
 114                 qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
 115                 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[block_permute_op(i)]);
 116
 117                 if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
 118
 119                 qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
 120             }
 121         }
 122     }
 123 }
 124 // move into common.c perhaps
 125 #define CHECKED_ALLOCZ(p, size)\
 126 {\
 127     p= av_mallocz(size);\
 128     if(p==NULL){\
 129         perror("malloc");\
 130         goto fail;\
 131     }\
 132 }
 133
 134 /* init common structure for both encoder and decoder */
 135 int MPV_common_init(MpegEncContext *s)
 136 {
 137     int c_size, i;
 138     UINT8 *pict;
 139
 140     s->dct_unquantize_h263 = dct_unquantize_h263_c;
 141     s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
 142     s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
 143     s->dct_quantize= dct_quantize_c;
 144
 145     if(s->avctx->dct_algo==FF_DCT_FASTINT)
 146         s->fdct = fdct_ifast;
 147     else
 148         s->fdct = ff_jpeg_fdct_islow;
 149
 150 #ifdef HAVE_MMX
 151     MPV_common_init_mmx(s);
 152 #endif
 153 #ifdef ARCH_ALPHA
 154     MPV_common_init_axp(s);
 155 #endif
 156 #ifdef HAVE_MLIB
 157     MPV_common_init_mlib(s);
 158 #endif
 159
 160     s->mb_width = (s->width + 15) / 16;
 161     s->mb_height = (s->height + 15) / 16;
 162
 163     /* set default edge pos, will be overriden in decode_header if needed */
 164     s->h_edge_pos= s->mb_width*16;
 165     s->v_edge_pos= s->mb_height*16;
 166
 167     s->mb_num = s->mb_width * s->mb_height;
 168     if(!(s->flags&CODEC_FLAG_DR1)){
 169       s->linesize   = s->mb_width * 16 + 2 * EDGE_WIDTH;
 170       s->uvlinesize = s->mb_width * 8  +     EDGE_WIDTH;
 171
 172       for(i=0;i<3;i++) {
 173         int w, h, shift, pict_start;
 174
 175         w = s->linesize;
 176         h = s->mb_height * 16 + 2 * EDGE_WIDTH;
 177         shift = (i == 0) ? 0 : 1;
 178         c_size = (s->linesize>>shift) * (h >> shift);
 179         pict_start = (s->linesize>>shift) * (EDGE_WIDTH >> shift) + (EDGE_WIDTH >> shift);
 180
 181         CHECKED_ALLOCZ(pict, c_size)
 182         s->last_picture_base[i] = pict;
 183         s->last_picture[i] = pict + pict_start;
 184         if(i>0) memset(s->last_picture_base[i], 128, c_size);
 185
 186         CHECKED_ALLOCZ(pict, c_size)
 187         s->next_picture_base[i] = pict;
 188         s->next_picture[i] = pict + pict_start;
 189         if(i>0) memset(s->next_picture_base[i], 128, c_size);
 190
 191         if (s->has_b_frames || s->codec_id==CODEC_ID_MPEG4) {
 192         /* Note the MPEG4 stuff is here cuz of buggy encoders which dont set the low_delay flag but
 193            do low-delay encoding, so we cant allways distinguish b-frame containing streams from low_delay streams */
 194             CHECKED_ALLOCZ(pict, c_size)
 195             s->aux_picture_base[i] = pict;
 196             s->aux_picture[i] = pict + pict_start;
 197             if(i>0) memset(s->aux_picture_base[i], 128, c_size);
 198         }
 199       }
 200       s->ip_buffer_count= 2;
 201     }
 202
 203     CHECKED_ALLOCZ(s->edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
 204
 205     if (s->encoding) {
 206         int j;
 207         int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
 208
 209         CHECKED_ALLOCZ(s->mb_var   , s->mb_num * sizeof(INT16))
 210         CHECKED_ALLOCZ(s->mc_mb_var, s->mb_num * sizeof(INT16))
 211
 212         /* Allocate MV tables */
 213         CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(INT16))
 214         CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(INT16))
 215         CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(INT16))
 216         CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
 217         CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
 218         CHECKED_ALLOCZ(s->b_direct_forw_mv_table, mv_table_size * 2 * sizeof(INT16))
 219         CHECKED_ALLOCZ(s->b_direct_back_mv_table, mv_table_size * 2 * sizeof(INT16))
 220         CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(INT16))
 221
 222         CHECKED_ALLOCZ(s->me_scratchpad,  s->linesize*16*3*sizeof(uint8_t))
 223
 224         CHECKED_ALLOCZ(s->me_map      , ME_MAP_SIZE*sizeof(uint32_t))
 225         CHECKED_ALLOCZ(s->me_score_map, ME_MAP_SIZE*sizeof(uint16_t))
 226
 227         if(s->max_b_frames){
 228             for(j=0; j<REORDER_BUFFER_SIZE; j++){
 229                 int i;
 230                 for(i=0;i<3;i++) {
 231                     int w, h, shift;
 232
 233                     w = s->linesize;
 234                     h = s->mb_height * 16;
 235                     shift = (i == 0) ? 0 : 1;
 236                     c_size = (w >> shift) * (h >> shift);
 237
 238                     CHECKED_ALLOCZ(pict, c_size);
 239                     s->picture_buffer[j][i] = pict;
 240                 }
 241             }
 242         }
 243
 244         if(s->codec_id==CODEC_ID_MPEG4){
 245             CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
 246             CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
 247         }
 248
 249         CHECKED_ALLOCZ(s->avctx->stats_out, 256);
 250     }
 251
 252     if (s->out_format == FMT_H263 || s->encoding) {
 253         int size;
 254         /* Allocate MB type table */
 255         CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(UINT8))
 256
 257         /* MV prediction */
 258         size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
 259         CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
 260
 261         /* 4mv direct mode decoding table */
 262         CHECKED_ALLOCZ(s->non_b_mv4_table, size * sizeof(UINT8))
 263     }
 264
 265     if (s->h263_pred || s->h263_plus) {
 266         int y_size, c_size, i, size;
 267
 268         /* dc values */
 269
 270         y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
 271         c_size = (s->mb_width + 2) * (s->mb_height + 2);
 272         size = y_size + 2 * c_size;
 273         CHECKED_ALLOCZ(s->dc_val[0], size * sizeof(INT16));
 274         s->dc_val[1] = s->dc_val[0] + y_size;
 275         s->dc_val[2] = s->dc_val[1] + c_size;
 276         for(i=0;i<size;i++)
 277             s->dc_val[0][i] = 1024;
 278
 279         /* ac values */
 280         CHECKED_ALLOCZ(s->ac_val[0], size * sizeof(INT16) * 16);
 281         s->ac_val[1] = s->ac_val[0] + y_size;
 282         s->ac_val[2] = s->ac_val[1] + c_size;
 283
 284         /* cbp values */
 285         CHECKED_ALLOCZ(s->coded_block, y_size);
 286
 287         /* divx501 bitstream reorder buffer */
 288         CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
 289
 290         /* cbp, ac_pred, pred_dir */
 291         CHECKED_ALLOCZ(s->cbp_table  , s->mb_num * sizeof(UINT8))
 292         CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
 293     }
 294     CHECKED_ALLOCZ(s->qscale_table  , s->mb_num * sizeof(UINT8))
 295
 296     /* which mb is a intra block */
 297     CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
 298     memset(s->mbintra_table, 1, s->mb_num);
 299
 300     /* default structure is frame */
 301     s->picture_structure = PICT_FRAME;
 302
 303     /* init macroblock skip table */
 304     CHECKED_ALLOCZ(s->mbskip_table, s->mb_num);
 305
 306     s->block= s->blocks[0];
 307
 308     s->context_initialized = 1;
 309     return 0;
 310  fail:
 311     MPV_common_end(s);
 312     return -1;
 313 }
 314
 315
 316 //extern int sads;
 317
 318 /* init common structure for both encoder and decoder */
 319 void MPV_common_end(MpegEncContext *s)
 320 {
 321     int i;
 322
 323     av_freep(&s->mb_type);
 324     av_freep(&s->mb_var);
 325     av_freep(&s->mc_mb_var);
 326     av_freep(&s->p_mv_table);
 327     av_freep(&s->b_forw_mv_table);
 328     av_freep(&s->b_back_mv_table);
 329     av_freep(&s->b_bidir_forw_mv_table);
 330     av_freep(&s->b_bidir_back_mv_table);
 331     av_freep(&s->b_direct_forw_mv_table);
 332     av_freep(&s->b_direct_back_mv_table);
 333     av_freep(&s->b_direct_mv_table);
 334     av_freep(&s->motion_val);
 335     av_freep(&s->dc_val[0]);
 336     av_freep(&s->ac_val[0]);
 337     av_freep(&s->coded_block);
 338     av_freep(&s->mbintra_table);
 339     av_freep(&s->cbp_table);
 340     av_freep(&s->pred_dir_table);
 341     av_freep(&s->qscale_table);
 342     av_freep(&s->me_scratchpad);
 343     av_freep(&s->me_map);
 344     av_freep(&s->me_score_map);
 345
 346     av_freep(&s->mbskip_table);
 347     av_freep(&s->bitstream_buffer);
 348     av_freep(&s->tex_pb_buffer);
 349     av_freep(&s->pb2_buffer);
 350     av_freep(&s->edge_emu_buffer);
 351     av_freep(&s->non_b_mv4_table);
 352     av_freep(&s->avctx->stats_out);
 353
 354     for(i=0;i<3;i++) {
 355         int j;
 356         if(!(s->flags&CODEC_FLAG_DR1)){
 357             av_freep(&s->last_picture_base[i]);
 358             av_freep(&s->next_picture_base[i]);
 359             av_freep(&s->aux_picture_base[i]);
 360         }
 361         s->last_picture_base[i]=
 362         s->next_picture_base[i]=
 363         s->aux_picture_base [i] = NULL;
 364         s->last_picture[i]=
 365         s->next_picture[i]=
 366         s->aux_picture [i] = NULL;
 367
 368         for(j=0; j<REORDER_BUFFER_SIZE; j++){
 369             av_freep(&s->picture_buffer[j][i]);
 370         }
 371     }
 372     s->context_initialized = 0;
 373 }
 374
 375 /* init video encoder */
 376 int MPV_encode_init(AVCodecContext *avctx)
 377 {
 378     MpegEncContext *s = avctx->priv_data;
 379     int i;
 380
 381     avctx->pix_fmt = PIX_FMT_YUV420P;
 382
 383     s->bit_rate = avctx->bit_rate;
 384     s->bit_rate_tolerance = avctx->bit_rate_tolerance;
 385     s->frame_rate = avctx->frame_rate;
 386     s->width = avctx->width;
 387     s->height = avctx->height;
 388     if(avctx->gop_size > 600){
 389         fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
 390         avctx->gop_size=600;
 391     }
 392     s->gop_size = avctx->gop_size;
 393     s->rtp_mode = avctx->rtp_mode;
 394     s->rtp_payload_size = avctx->rtp_payload_size;
 395     if (avctx->rtp_callback)
 396         s->rtp_callback = avctx->rtp_callback;
 397     s->qmin= avctx->qmin;
 398     s->qmax= avctx->qmax;
 399     s->max_qdiff= avctx->max_qdiff;
 400     s->qcompress= avctx->qcompress;
 401     s->qblur= avctx->qblur;
 402     s->avctx = avctx;
 403     s->aspect_ratio_info= avctx->aspect_ratio_info;
 404     if (avctx->aspect_ratio_info == FF_ASPECT_EXTENDED)
 405     {
 406         s->aspected_width = avctx->aspected_width;
 407         s->aspected_height = avctx->aspected_height;
 408     }
 409     s->flags= avctx->flags;
 410     s->max_b_frames= avctx->max_b_frames;
 411     s->b_frame_strategy= avctx->b_frame_strategy;
 412     s->codec_id= avctx->codec->id;
 413     s->luma_elim_threshold  = avctx->luma_elim_threshold;
 414     s->chroma_elim_threshold= avctx->chroma_elim_threshold;
 415     s->strict_std_compliance= avctx->strict_std_compliance;
 416     s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
 417     s->mpeg_quant= avctx->mpeg_quant;
 418
 419     if (s->gop_size <= 1) {
 420         s->intra_only = 1;
 421         s->gop_size = 12;
 422     } else {
 423         s->intra_only = 0;
 424     }
 425
 426     /* ME algorithm */
 427     if (avctx->me_method == 0)
 428         /* For compatibility */
 429         s->me_method = motion_estimation_method;
 430     else
 431         s->me_method = avctx->me_method;
 432
 433     /* Fixed QSCALE */
 434     s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
 435
 436     switch(avctx->codec->id) {
 437     case CODEC_ID_MPEG1VIDEO:
 438         s->out_format = FMT_MPEG1;
 439         avctx->delay=0; //FIXME not sure, should check the spec
 440         break;
 441     case CODEC_ID_MJPEG:
 442         s->out_format = FMT_MJPEG;
 443         s->intra_only = 1; /* force intra only for jpeg */
 444         s->mjpeg_write_tables = 1; /* write all tables */
 445         s->mjpeg_data_only_frames = 0; /* write all the needed headers */
 446         s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
 447         s->mjpeg_vsample[1] = 1; /* the only currently supported values */
 448         s->mjpeg_vsample[2] = 1;
 449         s->mjpeg_hsample[0] = 2;
 450         s->mjpeg_hsample[1] = 1;
 451         s->mjpeg_hsample[2] = 1;
 452         if (mjpeg_init(s) < 0)
 453             return -1;
 454         avctx->delay=0;
 455         break;
 456     case CODEC_ID_H263:
 457         if (h263_get_picture_format(s->width, s->height) == 7) {
 458             printf("Input picture size isn't suitable for h263 codec! try h263+\n");
 459             return -1;
 460         }
 461         s->out_format = FMT_H263;
 462         avctx->delay=0;
 463         break;
 464     case CODEC_ID_H263P:
 465         s->out_format = FMT_H263;
 466         s->rtp_mode = 1;
 467         s->rtp_payload_size = 1200;
 468         s->h263_plus = 1;
 469         s->unrestricted_mv = 1;
 470         s->h263_aic = 1;
 471
 472         /* These are just to be sure */
 473         s->umvplus = 0;
 474         s->umvplus_dec = 0;
 475         avctx->delay=0;
 476         break;
 477     case CODEC_ID_RV10:
 478         s->out_format = FMT_H263;
 479         s->h263_rv10 = 1;
 480         avctx->delay=0;
 481         break;
 482     case CODEC_ID_MPEG4:
 483         s->out_format = FMT_H263;
 484         s->h263_pred = 1;
 485         s->unrestricted_mv = 1;
 486         s->has_b_frames= s->max_b_frames ? 1 : 0;
 487         s->low_delay=0;
 488         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
 489         break;
 490     case CODEC_ID_MSMPEG4V1:
 491         s->out_format = FMT_H263;
 492         s->h263_msmpeg4 = 1;
 493         s->h263_pred = 1;
 494         s->unrestricted_mv = 1;
 495         s->msmpeg4_version= 1;
 496         avctx->delay=0;
 497         break;
 498     case CODEC_ID_MSMPEG4V2:
 499         s->out_format = FMT_H263;
 500         s->h263_msmpeg4 = 1;
 501         s->h263_pred = 1;
 502         s->unrestricted_mv = 1;
 503         s->msmpeg4_version= 2;
 504         avctx->delay=0;
 505         break;
 506     case CODEC_ID_MSMPEG4V3:
 507         s->out_format = FMT_H263;
 508         s->h263_msmpeg4 = 1;
 509         s->h263_pred = 1;
 510         s->unrestricted_mv = 1;
 511         s->msmpeg4_version= 3;
 512         avctx->delay=0;
 513         break;
 514     case CODEC_ID_WMV1:
 515         s->out_format = FMT_H263;
 516         s->h263_msmpeg4 = 1;
 517         s->h263_pred = 1;
 518         s->unrestricted_mv = 1;
 519         s->msmpeg4_version= 4;
 520         avctx->delay=0;
 521         break;
 522     case CODEC_ID_WMV2:
 523         s->out_format = FMT_H263;
 524         s->h263_msmpeg4 = 1;
 525         s->h263_pred = 1;
 526         s->unrestricted_mv = 1;
 527         s->msmpeg4_version= 5;
 528         avctx->delay=0;
 529         break;
 530     default:
 531         return -1;
 532     }
 533
 534     { /* set up some save defaults, some codecs might override them later */
 535         static int done=0;
 536         if(!done){
 537             int i;
 538             done=1;
 539             memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
 540             memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
 541
 542             for(i=-16; i<16; i++){
 543                 default_fcode_tab[i + MAX_MV]= 1;
 544             }
 545         }
 546     }
 547     s->mv_penalty= default_mv_penalty;
 548     s->fcode_tab= default_fcode_tab;
 549     s->y_dc_scale_table=
 550     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 551
 552     if (s->out_format == FMT_H263)
 553         h263_encode_init(s);
 554     else if (s->out_format == FMT_MPEG1)
 555         ff_mpeg1_encode_init(s);
 556     if(s->msmpeg4_version)
 557         ff_msmpeg4_encode_init(s);
 558
 559     /* dont use mv_penalty table for crap MV as it would be confused */
 560     if (s->me_method < ME_EPZS) s->mv_penalty = default_mv_penalty;
 561
 562     s->encoding = 1;
 563
 564     /* init */
 565     if (MPV_common_init(s) < 0)
 566         return -1;
 567
 568     /* init default q matrix */
 569     for(i=0;i<64;i++) {
 570         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
 571             s->intra_matrix[i] = ff_mpeg4_default_intra_matrix[i];
 572             s->inter_matrix[i] = ff_mpeg4_default_non_intra_matrix[i];
 573         }else if(s->out_format == FMT_H263){
 574             s->intra_matrix[i] =
 575             s->inter_matrix[i] = ff_mpeg1_default_non_intra_matrix[i];
 576         }else{ /* mpeg1 */
 577             s->intra_matrix[i] = ff_mpeg1_default_intra_matrix[i];
 578             s->inter_matrix[i] = ff_mpeg1_default_non_intra_matrix[i];
 579         }
 580     }
 581
 582     /* precompute matrix */
 583     /* for mjpeg, we do include qscale in the matrix */
 584     if (s->out_format != FMT_MJPEG) {
 585         convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias,
 586                        s->intra_matrix, s->intra_quant_bias);
 587         convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias,
 588                        s->inter_matrix, s->inter_quant_bias);
 589     }
 590
 591     if(ff_rate_control_init(s) < 0)
 592         return -1;
 593
 594     s->picture_number = 0;
 595     s->picture_in_gop_number = 0;
 596     s->fake_picture_number = 0;
 597     /* motion detector init */
 598     s->f_code = 1;
 599     s->b_code = 1;
 600
 601     return 0;
 602 }
 603
 604 int MPV_encode_end(AVCodecContext *avctx)
 605 {
 606     MpegEncContext *s = avctx->priv_data;
 607
 608 #ifdef STATS
 609     print_stats();
 610 #endif
 611
 612     ff_rate_control_uninit(s);
 613
 614     MPV_common_end(s);
 615     if (s->out_format == FMT_MJPEG)
 616         mjpeg_close(s);
 617
 618     return 0;
 619 }
 620
 621 /* draw the edges of width 'w' of an image of size width, height */
 622 //FIXME check that this is ok for mpeg4 interlaced
 623 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
 624 {
 625     UINT8 *ptr, *last_line;
 626     int i;
 627
 628     last_line = buf + (height - 1) * wrap;
 629     for(i=0;i<w;i++) {
 630         /* top and bottom */
 631         memcpy(buf - (i + 1) * wrap, buf, width);
 632         memcpy(last_line + (i + 1) * wrap, last_line, width);
 633     }
 634     /* left and right */
 635     ptr = buf;
 636     for(i=0;i<height;i++) {
 637         memset(ptr - w, ptr[0], w);
 638         memset(ptr + width, ptr[width-1], w);
 639         ptr += wrap;
 640     }
 641     /* corners */
 642     for(i=0;i<w;i++) {
 643         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
 644         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
 645         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
 646         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
 647     }
 648 }
 649
 650 /* generic function for encode/decode called before a frame is coded/decoded */
 651 void MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
 652 {
 653     int i;
 654     UINT8 *tmp;
 655
 656     s->mb_skiped = 0;
 657     s->decoding_error=0;
 658     avctx->mbskip_table= s->mbskip_table;
 659
 660     if(avctx->flags&CODEC_FLAG_DR1){
 661         avctx->get_buffer_callback(avctx, s->width, s->height, s->pict_type);
 662
 663         s->linesize  = avctx->dr_stride;
 664         s->uvlinesize= avctx->dr_uvstride;
 665         s->ip_buffer_count= avctx->dr_ip_buffer_count;
 666     }
 667     avctx->dr_ip_buffer_count= s->ip_buffer_count;
 668
 669     if (s->pict_type == B_TYPE) {
 670         for(i=0;i<3;i++) {
 671             if(avctx->flags&CODEC_FLAG_DR1)
 672                 s->aux_picture[i]= avctx->dr_buffer[i];
 673
 674             //FIXME the following should never be needed, the decoder should drop b frames if no reference is available
 675             if(s->next_picture[i]==NULL)
 676                 s->next_picture[i]= s->aux_picture[i];
 677             if(s->last_picture[i]==NULL)
 678                 s->last_picture[i]= s->next_picture[i];
 679
 680             s->current_picture[i] = s->aux_picture[i];
 681         }
 682     } else {
 683         for(i=0;i<3;i++) {
 684             /* swap next and last */
 685             if(avctx->flags&CODEC_FLAG_DR1)
 686                 tmp= avctx->dr_buffer[i];
 687             else
 688                 tmp = s->last_picture[i];
 689
 690             s->last_picture[i] = s->next_picture[i];
 691             s->next_picture[i] = tmp;
 692             s->current_picture[i] = tmp;
 693
 694             if(s->last_picture[i]==NULL)
 695                 s->last_picture[i]= s->next_picture[i];
 696
 697             s->last_dr_opaque= s->next_dr_opaque;
 698             s->next_dr_opaque= avctx->dr_opaque_frame;
 699
 700             if(s->has_b_frames && s->last_dr_opaque && s->codec_id!=CODEC_ID_SVQ1)
 701                 avctx->dr_opaque_frame= s->last_dr_opaque;
 702             else
 703                 avctx->dr_opaque_frame= s->next_dr_opaque;
 704         }
 705     }
 706     /* set dequantizer, we cant do it during init as it might change for mpeg4
 707        and we cant do it in the header decode as init isnt called for mpeg4 there yet */
 708     if(s->out_format == FMT_H263){
 709         if(s->mpeg_quant)
 710             s->dct_unquantize = s->dct_unquantize_mpeg2;
 711         else
 712             s->dct_unquantize = s->dct_unquantize_h263;
 713     }else
 714         s->dct_unquantize = s->dct_unquantize_mpeg1;
 715 }
 716
 717 /* generic function for encode/decode called after a frame has been coded/decoded */
 718 void MPV_frame_end(MpegEncContext *s)
 719 {
 720 //    if((s->picture_number%100)==0 && s->encoding) printf("sads:%d //\n", sads);
 721
 722     /* draw edge for correct motion prediction if outside */
 723     if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
 724         draw_edges(s->current_picture[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
 725         draw_edges(s->current_picture[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
 726         draw_edges(s->current_picture[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
 727     }
 728     emms_c();
 729
 730     s->last_pict_type    = s->pict_type;
 731     if(s->pict_type!=B_TYPE){
 732         s->last_non_b_pict_type= s->pict_type;
 733         s->num_available_buffers++;
 734         if(s->num_available_buffers>2) s->num_available_buffers= 2;
 735     }
 736 }
 737
 738 /* reorder input for encoding */
 739 void reorder_input(MpegEncContext *s, AVPicture *pict)
 740 {
 741     int i, j, index;
 742
 743     if(s->max_b_frames > FF_MAX_B_FRAMES) s->max_b_frames= FF_MAX_B_FRAMES;
 744
 745 //        delay= s->max_b_frames+1; (or 0 if no b frames cuz decoder diff)
 746
 747     for(j=0; j<REORDER_BUFFER_SIZE-1; j++){
 748         s->coded_order[j]= s->coded_order[j+1];
 749     }
 750     s->coded_order[j].picture[0]= s->coded_order[j].picture[1]= s->coded_order[j].picture[2]= NULL; //catch uninitalized buffers
 751     s->coded_order[j].pict_type=0;
 752
 753     switch(s->input_pict_type){
 754     default:
 755     case I_TYPE:
 756     case S_TYPE:
 757     case P_TYPE:
 758         index= s->max_b_frames - s->b_frames_since_non_b;
 759         s->b_frames_since_non_b=0;
 760         break;
 761     case B_TYPE:
 762         index= s->max_b_frames + 1;
 763         s->b_frames_since_non_b++;
 764         break;
 765     }
 766 //printf("index:%d type:%d strides: %d %d\n", index, s->input_pict_type, pict->linesize[0], s->linesize);
 767     if(   (index==0 || (s->flags&CODEC_FLAG_INPUT_PRESERVED))
 768        && pict->linesize[0] == s->linesize
 769        && pict->linesize[1] == s->uvlinesize
 770        && pict->linesize[2] == s->uvlinesize){
 771 //printf("ptr\n");
 772         for(i=0; i<3; i++){
 773             s->coded_order[index].picture[i]= pict->data[i];
 774         }
 775     }else{
 776 //printf("copy\n");
 777         for(i=0; i<3; i++){
 778             uint8_t *src = pict->data[i];
 779             uint8_t *dest;
 780             int src_wrap = pict->linesize[i];
 781             int dest_wrap = s->linesize;
 782             int w = s->width;
 783             int h = s->height;
 784
 785             if(index==0) dest= s->last_picture[i]+16; //is current_picture indeed but the switch hapens after reordering
 786             else         dest= s->picture_buffer[s->picture_buffer_index][i];
 787
 788             if (i >= 1) {
 789                 dest_wrap >>= 1;
 790                 w >>= 1;
 791                 h >>= 1;
 792             }
 793
 794             s->coded_order[index].picture[i]= dest;
 795             for(j=0;j<h;j++) {
 796                 memcpy(dest, src, w);
 797                 dest += dest_wrap;
 798                 src += src_wrap;
 799             }
 800         }
 801         if(index!=0){
 802             s->picture_buffer_index++;
 803             if(s->picture_buffer_index >= REORDER_BUFFER_SIZE) s->picture_buffer_index=0;
 804         }
 805     }
 806     s->coded_order[index].pict_type = s->input_pict_type;
 807     s->coded_order[index].qscale    = s->input_qscale;
 808     s->coded_order[index].force_type= s->force_input_type;
 809     s->coded_order[index].picture_in_gop_number= s->input_picture_in_gop_number;
 810     s->coded_order[index].picture_number= s->input_picture_number;
 811
 812     for(i=0; i<3; i++){
 813         s->new_picture[i]= s->coded_order[0].picture[i];
 814     }
 815 }
 816
 817 int MPV_encode_picture(AVCodecContext *avctx,
 818                        unsigned char *buf, int buf_size, void *data)
 819 {
 820     MpegEncContext *s = avctx->priv_data;
 821     AVPicture *pict = data;
 822
 823     s->input_qscale = avctx->quality;
 824
 825     init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
 826
 827     if(avctx->flags&CODEC_FLAG_TYPE){
 828         s->input_pict_type=
 829         s->force_input_type= avctx->key_frame ? I_TYPE : P_TYPE;
 830     }else if(s->flags&CODEC_FLAG_PASS2){
 831         s->input_pict_type=
 832         s->force_input_type= s->rc_context.entry[s->input_picture_number].new_pict_type;
 833     }else{
 834         s->force_input_type=0;
 835         if (!s->intra_only) {
 836             /* first picture of GOP is intra */
 837             if (s->input_picture_in_gop_number % s->gop_size==0){
 838                 s->input_pict_type = I_TYPE;
 839             }else if(s->max_b_frames==0){
 840                 s->input_pict_type = P_TYPE;
 841             }else{
 842                 if(s->b_frames_since_non_b < s->max_b_frames) //FIXME more IQ
 843                     s->input_pict_type = B_TYPE;
 844                 else
 845                     s->input_pict_type = P_TYPE;
 846             }
 847         } else {
 848             s->input_pict_type = I_TYPE;
 849         }
 850     }
 851
 852     if(s->input_pict_type==I_TYPE)
 853         s->input_picture_in_gop_number=0;
 854
 855     reorder_input(s, pict);
 856
 857     /* output? */
 858     if(s->coded_order[0].picture[0]){
 859
 860         s->pict_type= s->coded_order[0].pict_type;
 861         if (s->fixed_qscale) /* the ratecontrol needs the last qscale so we dont touch it for CBR */
 862             s->qscale= s->coded_order[0].qscale;
 863         s->force_type= s->coded_order[0].force_type;
 864         s->picture_in_gop_number= s->coded_order[0].picture_in_gop_number;
 865         s->picture_number= s->coded_order[0].picture_number;
 866
 867         MPV_frame_start(s, avctx);
 868
 869         encode_picture(s, s->picture_number);
 870         avctx->key_frame   = (s->pict_type == I_TYPE);
 871         avctx->pict_type   = s->pict_type;
 872         avctx->real_pict_num  = s->picture_number;
 873         avctx->header_bits = s->header_bits;
 874         avctx->mv_bits     = s->mv_bits;
 875         avctx->misc_bits   = s->misc_bits;
 876         avctx->i_tex_bits  = s->i_tex_bits;
 877         avctx->p_tex_bits  = s->p_tex_bits;
 878         avctx->i_count     = s->i_count;
 879         avctx->p_count     = s->p_count;
 880         avctx->skip_count  = s->skip_count;
 881
 882         MPV_frame_end(s);
 883
 884         if (s->out_format == FMT_MJPEG)
 885             mjpeg_picture_trailer(s);
 886
 887         avctx->quality = s->qscale;
 888
 889         if(s->flags&CODEC_FLAG_PASS1)
 890             ff_write_pass1_stats(s);
 891
 892     }
 893
 894     s->input_picture_number++;
 895     s->input_picture_in_gop_number++;
 896
 897     flush_put_bits(&s->pb);
 898     s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
 899
 900     s->total_bits += s->frame_bits;
 901     avctx->frame_bits  = s->frame_bits;
 902 //printf("fcode: %d, type: %d, head: %d, mv: %d, misc: %d, frame: %d, itex: %d, ptex: %d\n",
 903 //s->f_code, avctx->key_frame, s->header_bits, s->mv_bits, s->misc_bits, s->frame_bits, s->i_tex_bits, s->p_tex_bits);
 904 #if 0 //dump some stats to stats.txt for testing/debuging
 905 if(s->max_b_frames==0)
 906 {
 907     static FILE *f=NULL;
 908     if(!f) f= fopen("stats.txt", "wb");
 909     get_psnr(pict->data, s->current_picture,
 910              pict->linesize, s->linesize, avctx);
 911     fprintf(f, "%7d, %7d, %2.4f\n", pbBufPtr(&s->pb) - s->pb.buf, s->qscale, avctx->psnr_y);
 912 }
 913 #endif
 914
 915     if (avctx->get_psnr) {
 916         /* At this point pict->data should have the original frame   */
 917         /* an s->current_picture should have the coded/decoded frame */
 918         get_psnr(pict->data, s->current_picture,
 919                  pict->linesize, s->linesize, avctx);
 920 //        printf("%f\n", avctx->psnr_y);
 921     }
 922     return pbBufPtr(&s->pb) - s->pb.buf;
 923 }
 924
 925 static inline void gmc1_motion(MpegEncContext *s,
 926                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
 927                                int dest_offset,
 928                                UINT8 **ref_picture, int src_offset,
 929                                int h)
 930 {
 931     UINT8 *ptr;
 932     int offset, src_x, src_y, linesize, uvlinesize;
 933     int motion_x, motion_y;
 934     int emu=0;
 935
 936     if(s->real_sprite_warping_points>1) printf("more than 1 warp point isnt supported\n");
 937     motion_x= s->sprite_offset[0][0];
 938     motion_y= s->sprite_offset[0][1];
 939     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
 940     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
 941     motion_x<<=(3-s->sprite_warping_accuracy);
 942     motion_y<<=(3-s->sprite_warping_accuracy);
 943     src_x = clip(src_x, -16, s->width);
 944     if (src_x == s->width)
 945         motion_x =0;
 946     src_y = clip(src_y, -16, s->height);
 947     if (src_y == s->height)
 948         motion_y =0;
 949
 950     linesize = s->linesize;
 951     uvlinesize = s->uvlinesize;
 952     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
 953
 954     dest_y+=dest_offset;
 955     if(s->flags&CODEC_FLAG_EMU_EDGE){
 956         if(src_x<0 || src_y<0 || src_x + (motion_x&15) + 16 > s->h_edge_pos
 957                               || src_y + (motion_y&15) + h  > s->v_edge_pos){
 958             emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
 959             ptr= s->edge_emu_buffer;
 960             emu=1;
 961         }
 962     }
 963     gmc1(dest_y  , ptr  , linesize, h, motion_x&15, motion_y&15, s->no_rounding);
 964     gmc1(dest_y+8, ptr+8, linesize, h, motion_x&15, motion_y&15, s->no_rounding);
 965
 966     motion_x= s->sprite_offset[1][0];
 967     motion_y= s->sprite_offset[1][1];
 968     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
 969     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
 970     motion_x<<=(3-s->sprite_warping_accuracy);
 971     motion_y<<=(3-s->sprite_warping_accuracy);
 972     src_x = clip(src_x, -8, s->width>>1);
 973     if (src_x == s->width>>1)
 974         motion_x =0;
 975     src_y = clip(src_y, -8, s->height>>1);
 976     if (src_y == s->height>>1)
 977         motion_y =0;
 978
 979     offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
 980     ptr = ref_picture[1] + offset;
 981     if(emu){
 982         emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
 983         ptr= s->edge_emu_buffer;
 984     }
 985     gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
 986
 987     ptr = ref_picture[2] + offset;
 988     if(emu){
 989         emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
 990         ptr= s->edge_emu_buffer;
 991     }
 992     gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
 993
 994     return;
 995 }
 996
 997 static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h,
 998                                     int src_x, int src_y, int w, int h){
 999     int x, y;
1000     int start_y, start_x, end_y, end_x;
1001     UINT8 *buf= s->edge_emu_buffer;
1002
1003     if(src_y>= h){
1004         src+= (h-1-src_y)*linesize;
1005         src_y=h-1;
1006     }else if(src_y<=-block_h){
1007         src+= (1-block_h-src_y)*linesize;
1008         src_y=1-block_h;
1009     }
1010     if(src_x>= w){
1011         src+= (w-1-src_x);
1012         src_x=w-1;
1013     }else if(src_x<=-block_w){
1014         src+= (1-block_w-src_x);
1015         src_x=1-block_w;
1016     }
1017
1018     start_y= MAX(0, -src_y);
1019     start_x= MAX(0, -src_x);
1020     end_y= MIN(block_h, h-src_y);
1021     end_x= MIN(block_w, w-src_x);
1022
1023     // copy existing part
1024     for(y=start_y; y<end_y; y++){
1025         for(x=start_x; x<end_x; x++){
1026             buf[x + y*linesize]= src[x + y*linesize];
1027         }
1028     }
1029
1030     //top
1031     for(y=0; y<start_y; y++){
1032         for(x=start_x; x<end_x; x++){
1033             buf[x + y*linesize]= buf[x + start_y*linesize];
1034         }
1035     }
1036
1037     //bottom
1038     for(y=end_y; y<block_h; y++){
1039         for(x=start_x; x<end_x; x++){
1040             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1041         }
1042     }
1043
1044     for(y=0; y<block_h; y++){
1045        //left
1046         for(x=0; x<start_x; x++){
1047             buf[x + y*linesize]= buf[start_x + y*linesize];
1048         }
1049
1050        //right
1051         for(x=end_x; x<block_w; x++){
1052             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1053         }
1054     }
1055 }
1056
1057
1058 /* apply one mpeg motion vector to the three components */
1059 static inline void mpeg_motion(MpegEncContext *s,
1060                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1061                                int dest_offset,
1062                                UINT8 **ref_picture, int src_offset,
1063                                int field_based, op_pixels_func *pix_op,
1064                                int motion_x, int motion_y, int h)
1065 {
1066     UINT8 *ptr;
1067     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1068     int emu=0;
1069
1070 if(s->quarter_sample)
1071 {
1072     motion_x>>=1;
1073     motion_y>>=1;
1074 }
1075     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1076     src_x = s->mb_x * 16 + (motion_x >> 1);
1077     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1078
1079     /* WARNING: do no forget half pels */
1080     height = s->height >> field_based;
1081     v_edge_pos = s->v_edge_pos >> field_based;
1082     src_x = clip(src_x, -16, s->width);
1083     if (src_x == s->width)
1084         dxy &= ~1;
1085     src_y = clip(src_y, -16, height);
1086     if (src_y == height)
1087         dxy &= ~2;
1088     linesize   = s->linesize << field_based;
1089     uvlinesize = s->uvlinesize << field_based;
1090     ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1091     dest_y += dest_offset;
1092
1093     if(s->flags&CODEC_FLAG_EMU_EDGE){
1094         if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1095                               || src_y + (motion_y&1) + h  > v_edge_pos){
1096             emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, v_edge_pos);
1097             ptr= s->edge_emu_buffer;
1098             emu=1;
1099         }
1100     }
1101     pix_op[dxy](dest_y, ptr, linesize, h);
1102     pix_op[dxy](dest_y + 8, ptr + 8, linesize, h);
1103
1104     if(s->flags&CODEC_FLAG_GRAY) return;
1105
1106     if (s->out_format == FMT_H263) {
1107         dxy = 0;
1108         if ((motion_x & 3) != 0)
1109             dxy |= 1;
1110         if ((motion_y & 3) != 0)
1111             dxy |= 2;
1112         mx = motion_x >> 2;
1113         my = motion_y >> 2;
1114     } else {
1115         mx = motion_x / 2;
1116         my = motion_y / 2;
1117         dxy = ((my & 1) << 1) | (mx & 1);
1118         mx >>= 1;
1119         my >>= 1;
1120     }
1121
1122     src_x = s->mb_x * 8 + mx;
1123     src_y = s->mb_y * (8 >> field_based) + my;
1124     src_x = clip(src_x, -8, s->width >> 1);
1125     if (src_x == (s->width >> 1))
1126         dxy &= ~1;
1127     src_y = clip(src_y, -8, height >> 1);
1128     if (src_y == (height >> 1))
1129         dxy &= ~2;
1130     offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1131     ptr = ref_picture[1] + offset;
1132     if(emu){
1133         emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1134         ptr= s->edge_emu_buffer;
1135     }
1136     pix_op[dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1137
1138     ptr = ref_picture[2] + offset;
1139     if(emu){
1140         emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1141         ptr= s->edge_emu_buffer;
1142     }
1143     pix_op[dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1144 }
1145
1146 static inline void qpel_motion(MpegEncContext *s,
1147                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1148                                int dest_offset,
1149                                UINT8 **ref_picture, int src_offset,
1150                                int field_based, op_pixels_func *pix_op,
1151                                qpel_mc_func *qpix_op,
1152                                int motion_x, int motion_y, int h)
1153 {
1154     UINT8 *ptr;
1155     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize;
1156     int emu=0;
1157
1158     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1159     src_x = s->mb_x * 16 + (motion_x >> 2);
1160     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1161
1162     height = s->height >> field_based;
1163     v_edge_pos = s->v_edge_pos >> field_based;
1164     src_x = clip(src_x, -16, s->width);
1165     if (src_x == s->width)
1166         dxy &= ~3;
1167     src_y = clip(src_y, -16, height);
1168     if (src_y == height)
1169         dxy &= ~12;
1170     linesize = s->linesize << field_based;
1171     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1172     dest_y += dest_offset;
1173 //printf("%d %d %d\n", src_x, src_y, dxy);
1174
1175     if(s->flags&CODEC_FLAG_EMU_EDGE){
1176         if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1177                               || src_y + (motion_y&3) + h  > v_edge_pos){
1178             emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, v_edge_pos);
1179             ptr= s->edge_emu_buffer;
1180             emu=1;
1181         }
1182     }
1183     qpix_op[dxy](dest_y                 , ptr                 , linesize, linesize, motion_x&3, motion_y&3);
1184     qpix_op[dxy](dest_y              + 8, ptr              + 8, linesize, linesize, motion_x&3, motion_y&3);
1185     qpix_op[dxy](dest_y + linesize*8    , ptr + linesize*8    , linesize, linesize, motion_x&3, motion_y&3);
1186     qpix_op[dxy](dest_y + linesize*8 + 8, ptr + linesize*8 + 8, linesize, linesize, motion_x&3, motion_y&3);
1187
1188     if(s->flags&CODEC_FLAG_GRAY) return;
1189
1190     mx= (motion_x>>1) | (motion_x&1);
1191     my= (motion_y>>1) | (motion_y&1);
1192
1193     dxy = 0;
1194     if ((mx & 3) != 0)
1195         dxy |= 1;
1196     if ((my & 3) != 0)
1197         dxy |= 2;
1198     mx = mx >> 2;
1199     my = my >> 2;
1200
1201     src_x = s->mb_x * 8 + mx;
1202     src_y = s->mb_y * (8 >> field_based) + my;
1203     src_x = clip(src_x, -8, s->width >> 1);
1204     if (src_x == (s->width >> 1))
1205         dxy &= ~1;
1206     src_y = clip(src_y, -8, height >> 1);
1207     if (src_y == (height >> 1))
1208         dxy &= ~2;
1209
1210     offset = (src_y * s->uvlinesize) + src_x + (src_offset >> 1);
1211     ptr = ref_picture[1] + offset;
1212     if(emu){
1213         emulated_edge_mc(s, ptr,  s->uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1214         ptr= s->edge_emu_buffer;
1215     }
1216     pix_op[dxy](dest_cb + (dest_offset >> 1), ptr,  s->uvlinesize, h >> 1);
1217
1218     ptr = ref_picture[2] + offset;
1219     if(emu){
1220         emulated_edge_mc(s, ptr,  s->uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1221         ptr= s->edge_emu_buffer;
1222     }
1223     pix_op[dxy](dest_cr + (dest_offset >> 1), ptr,  s->uvlinesize, h >> 1);
1224 }
1225
1226
1227 static inline void MPV_motion(MpegEncContext *s,
1228                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1229                               int dir, UINT8 **ref_picture,
1230                               op_pixels_func *pix_op, qpel_mc_func *qpix_op)
1231 {
1232     int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1233     int mb_x, mb_y, i;
1234     UINT8 *ptr, *dest;
1235     int emu=0;
1236
1237     mb_x = s->mb_x;
1238     mb_y = s->mb_y;
1239
1240     switch(s->mv_type) {
1241     case MV_TYPE_16X16:
1242         if(s->mcsel){
1243 #if 0
1244             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1245                         ref_picture, 0,
1246                         0, pix_op,
1247                         s->sprite_offset[0][0]>>3,
1248                         s->sprite_offset[0][1]>>3,
1249                         16);
1250 #else
1251             gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1252                         ref_picture, 0,
1253                         16);
1254 #endif
1255         }else if(s->quarter_sample && dir==0){ //FIXME
1256             qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1257                         ref_picture, 0,
1258                         0, pix_op, qpix_op,
1259                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
1260         }else{
1261             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1262                         ref_picture, 0,
1263                         0, pix_op,
1264                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
1265         }
1266         break;
1267     case MV_TYPE_8X8:
1268         for(i=0;i<4;i++) {
1269             motion_x = s->mv[dir][i][0];
1270             motion_y = s->mv[dir][i][1];
1271
1272             dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1273             src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1274             src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1275
1276             /* WARNING: do no forget half pels */
1277             src_x = clip(src_x, -16, s->width);
1278             if (src_x == s->width)
1279                 dxy &= ~1;
1280             src_y = clip(src_y, -16, s->height);
1281             if (src_y == s->height)
1282                 dxy &= ~2;
1283
1284             ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1285             if(s->flags&CODEC_FLAG_EMU_EDGE){
1286                 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1287                                       || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1288                     emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1289                     ptr= s->edge_emu_buffer;
1290                 }
1291             }
1292             dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1293             pix_op[dxy](dest, ptr, s->linesize, 8);
1294         }
1295
1296         if(s->flags&CODEC_FLAG_GRAY) break;
1297         /* In case of 8X8, we construct a single chroma motion vector
1298            with a special rounding */
1299         mx = 0;
1300         my = 0;
1301         for(i=0;i<4;i++) {
1302             mx += s->mv[dir][i][0];
1303             my += s->mv[dir][i][1];
1304         }
1305         if (mx >= 0)
1306             mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1307         else {
1308             mx = -mx;
1309             mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1310         }
1311         if (my >= 0)
1312             my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1313         else {
1314             my = -my;
1315             my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1316         }
1317         dxy = ((my & 1) << 1) | (mx & 1);
1318         mx >>= 1;
1319         my >>= 1;
1320
1321         src_x = mb_x * 8 + mx;
1322         src_y = mb_y * 8 + my;
1323         src_x = clip(src_x, -8, s->width/2);
1324         if (src_x == s->width/2)
1325             dxy &= ~1;
1326         src_y = clip(src_y, -8, s->height/2);
1327         if (src_y == s->height/2)
1328             dxy &= ~2;
1329
1330         offset = (src_y * (s->uvlinesize)) + src_x;
1331         ptr = ref_picture[1] + offset;
1332         if(s->flags&CODEC_FLAG_EMU_EDGE){
1333                 if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1334                                       || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1335                     emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1336                     ptr= s->edge_emu_buffer;
1337                     emu=1;
1338                 }
1339             }
1340         pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
1341
1342         ptr = ref_picture[2] + offset;
1343         if(emu){
1344             emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1345             ptr= s->edge_emu_buffer;
1346         }
1347         pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
1348         break;
1349     case MV_TYPE_FIELD:
1350         if (s->picture_structure == PICT_FRAME) {
1351             /* top field */
1352             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1353                         ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1354                         1, pix_op,
1355                         s->mv[dir][0][0], s->mv[dir][0][1], 8);
1356             /* bottom field */
1357             mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1358                         ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1359                         1, pix_op,
1360                         s->mv[dir][1][0], s->mv[dir][1][1], 8);
1361         } else {
1362
1363
1364         }
1365         break;
1366     }
1367 }
1368
1369
1370 /* put block[] to dest[] */
1371 static inline void put_dct(MpegEncContext *s,
1372                            DCTELEM *block, int i, UINT8 *dest, int line_size)
1373 {
1374     if (!s->mpeg2)
1375         s->dct_unquantize(s, block, i, s->qscale);
1376     ff_idct_put (dest, line_size, block);
1377 }
1378
1379 /* add block[] to dest[] */
1380 static inline void add_dct(MpegEncContext *s,
1381                            DCTELEM *block, int i, UINT8 *dest, int line_size)
1382 {
1383     if (s->block_last_index[i] >= 0) {
1384         ff_idct_add (dest, line_size, block);
1385     }
1386 }
1387
1388 static inline void add_dequant_dct(MpegEncContext *s,
1389                            DCTELEM *block, int i, UINT8 *dest, int line_size)
1390 {
1391     if (s->block_last_index[i] >= 0) {
1392         s->dct_unquantize(s, block, i, s->qscale);
1393
1394         ff_idct_add (dest, line_size, block);
1395     }
1396 }
1397
1398 /**
1399  * cleans dc, ac, coded_block for the current non intra MB
1400  */
1401 void ff_clean_intra_table_entries(MpegEncContext *s)
1402 {
1403     int wrap = s->block_wrap[0];
1404     int xy = s->block_index[0];
1405
1406     s->dc_val[0][xy           ] =
1407     s->dc_val[0][xy + 1       ] =
1408     s->dc_val[0][xy     + wrap] =
1409     s->dc_val[0][xy + 1 + wrap] = 1024;
1410     /* ac pred */
1411     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(INT16));
1412     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
1413     if (s->msmpeg4_version>=3) {
1414         s->coded_block[xy           ] =
1415         s->coded_block[xy + 1       ] =
1416         s->coded_block[xy     + wrap] =
1417         s->coded_block[xy + 1 + wrap] = 0;
1418     }
1419     /* chroma */
1420     wrap = s->block_wrap[4];
1421     xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
1422     s->dc_val[1][xy] =
1423     s->dc_val[2][xy] = 1024;
1424     /* ac pred */
1425     memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
1426     memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
1427
1428     s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1429 }
1430
1431 /* generic function called after a macroblock has been parsed by the
1432    decoder or after it has been encoded by the encoder.
1433
1434    Important variables used:
1435    s->mb_intra : true if intra macroblock
1436    s->mv_dir   : motion vector direction
1437    s->mv_type  : motion vector type
1438    s->mv       : motion vector
1439    s->interlaced_dct : true if interlaced dct used (mpeg2)
1440  */
1441 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1442 {
1443     int mb_x, mb_y;
1444     const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
1445
1446     mb_x = s->mb_x;
1447     mb_y = s->mb_y;
1448
1449 #ifdef FF_POSTPROCESS
1450     /* Obsolete. Exists for compatibility with mplayer only. */
1451     quant_store[mb_y][mb_x]=s->qscale;
1452     //printf("[%02d][%02d] %d\n",mb_x,mb_y,s->qscale);
1453 #else
1454     /* even more obsolete, exists for mplayer xp only */
1455     if(s->avctx->quant_store) s->avctx->quant_store[mb_y*s->avctx->qstride+mb_x] = s->qscale;
1456 #endif
1457     s->qscale_table[mb_xy]= s->qscale;
1458
1459     /* update DC predictors for P macroblocks */
1460     if (!s->mb_intra) {
1461         if (s->h263_pred || s->h263_aic) {
1462             if(s->mbintra_table[mb_xy])
1463                 ff_clean_intra_table_entries(s);
1464         } else {
1465             s->last_dc[0] =
1466             s->last_dc[1] =
1467             s->last_dc[2] = 128 << s->intra_dc_precision;
1468         }
1469     }
1470     else if (s->h263_pred || s->h263_aic)
1471         s->mbintra_table[mb_xy]=1;
1472
1473     /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
1474     if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
1475
1476         const int wrap = s->block_wrap[0];
1477         const int xy = s->block_index[0];
1478         if(s->mv_type == MV_TYPE_8X8){
1479             s->non_b_mv4_table[xy]=1;
1480         } else {
1481             int motion_x, motion_y;
1482             if (s->mb_intra) {
1483                 motion_x = 0;
1484                 motion_y = 0;
1485             } else if (s->mv_type == MV_TYPE_16X16) {
1486                 motion_x = s->mv[0][0][0];
1487                 motion_y = s->mv[0][0][1];
1488             } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1489                 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1490                 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1491                 motion_x = (motion_x>>1) | (motion_x&1);
1492                 motion_y = (motion_y>>1) | (motion_y&1);
1493             }
1494             /* no update if 8X8 because it has been done during parsing */
1495             s->motion_val[xy][0] = motion_x;
1496             s->motion_val[xy][1] = motion_y;
1497             s->motion_val[xy + 1][0] = motion_x;
1498             s->motion_val[xy + 1][1] = motion_y;
1499             s->motion_val[xy + wrap][0] = motion_x;
1500             s->motion_val[xy + wrap][1] = motion_y;
1501             s->motion_val[xy + 1 + wrap][0] = motion_x;
1502             s->motion_val[xy + 1 + wrap][1] = motion_y;
1503             s->non_b_mv4_table[xy]=0;
1504         }
1505     }
1506
1507     if (!(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) {
1508         UINT8 *dest_y, *dest_cb, *dest_cr;
1509         int dct_linesize, dct_offset;
1510         op_pixels_func *op_pix;
1511         qpel_mc_func *op_qpix;
1512
1513         /* avoid copy if macroblock skipped in last frame too
1514            dont touch it for B-frames as they need the skip info from the next p-frame */
1515         if (s->pict_type != B_TYPE) {
1516             UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
1517             if (s->mb_skiped) {
1518                 s->mb_skiped = 0;
1519
1520                 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
1521                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1522
1523                 /* if previous was skipped too, then nothing to do !
1524                    skip only during decoding as we might trash the buffers during encoding a bit */
1525                 if (*mbskip_ptr >= s->ip_buffer_count  && !s->encoding)
1526                     goto the_end;
1527             } else {
1528                 *mbskip_ptr = 0; /* not skipped */
1529             }
1530         }
1531
1532         dest_y = s->current_picture [0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
1533         dest_cb = s->current_picture[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1534         dest_cr = s->current_picture[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1535
1536         if (s->interlaced_dct) {
1537             dct_linesize = s->linesize * 2;
1538             dct_offset = s->linesize;
1539         } else {
1540             dct_linesize = s->linesize;
1541             dct_offset = s->linesize * 8;
1542         }
1543
1544         if (!s->mb_intra) {
1545             /* motion handling */
1546             /* decoding or more than one mb_type (MC was allready done otherwise) */
1547             if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
1548                 if ((!s->no_rounding) || s->pict_type==B_TYPE){
1549                     op_pix = put_pixels_tab;
1550                     op_qpix= qpel_mc_rnd_tab;
1551                 }else{
1552                     op_pix = put_no_rnd_pixels_tab;
1553                     op_qpix= qpel_mc_no_rnd_tab;
1554                 }
1555
1556                 if (s->mv_dir & MV_DIR_FORWARD) {
1557                     MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
1558                     if ((!s->no_rounding) || s->pict_type==B_TYPE)
1559                         op_pix = avg_pixels_tab;
1560                     else
1561                         op_pix = avg_no_rnd_pixels_tab;
1562                 }
1563                 if (s->mv_dir & MV_DIR_BACKWARD) {
1564                     MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
1565                 }
1566             }
1567
1568             /* skip dequant / idct if we are really late ;) */
1569             if(s->hurry_up>1) goto the_end;
1570
1571             /* add dct residue */
1572             if(s->encoding || !(s->mpeg2 || s->h263_msmpeg4 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1573                 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
1574                 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1575                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1576                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1577
1578                 if(!(s->flags&CODEC_FLAG_GRAY)){
1579                     add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1580                     add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1581                 }
1582             } else {
1583                 add_dct(s, block[0], 0, dest_y, dct_linesize);
1584                 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1585                 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1586                 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1587
1588                 if(!(s->flags&CODEC_FLAG_GRAY)){
1589                     add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1590                     add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1591                 }
1592             }
1593         } else {
1594             /* dct only in intra block */
1595             put_dct(s, block[0], 0, dest_y, dct_linesize);
1596             put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1597             put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1598             put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1599
1600             if(!(s->flags&CODEC_FLAG_GRAY)){
1601                 put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1602                 put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1603             }
1604         }
1605     }
1606  the_end:
1607     emms_c(); //FIXME remove
1608 }
1609
1610 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
1611 {
1612     static const char tab[64]=
1613         {3,2,2,1,1,1,1,1,
1614          1,1,1,1,1,1,1,1,
1615          1,1,1,1,1,1,1,1,
1616          0,0,0,0,0,0,0,0,
1617          0,0,0,0,0,0,0,0,
1618          0,0,0,0,0,0,0,0,
1619          0,0,0,0,0,0,0,0,
1620          0,0,0,0,0,0,0,0};
1621     int score=0;
1622     int run=0;
1623     int i;
1624     DCTELEM *block= s->block[n];
1625     const int last_index= s->block_last_index[n];
1626     int skip_dc;
1627
1628     if(threshold<0){
1629         skip_dc=0;
1630         threshold= -threshold;
1631     }else
1632         skip_dc=1;
1633
1634     /* are all which we could set to zero are allready zero? */
1635     if(last_index<=skip_dc - 1) return;
1636
1637     for(i=0; i<=last_index; i++){
1638         const int j = zigzag_direct[i];
1639         const int level = ABS(block[j]);
1640         if(level==1){
1641             if(skip_dc && i==0) continue;
1642             score+= tab[run];
1643             run=0;
1644         }else if(level>1){
1645             return;
1646         }else{
1647             run++;
1648         }
1649     }
1650     if(score >= threshold) return;
1651     for(i=skip_dc; i<=last_index; i++){
1652         const int j = zigzag_direct[i];
1653         block[j]=0;
1654     }
1655     if(block[0]) s->block_last_index[n]= 0;
1656     else         s->block_last_index[n]= -1;
1657 }
1658
1659 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
1660 {
1661     int i;
1662     const int maxlevel= s->max_qcoeff;
1663     const int minlevel= s->min_qcoeff;
1664
1665     for(i=0;i<=last_index; i++){
1666         const int j = zigzag_direct[i];
1667         int level = block[j];
1668
1669         if     (level>maxlevel) level=maxlevel;
1670         else if(level<minlevel) level=minlevel;
1671         block[j]= level;
1672     }
1673 }
1674
1675 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
1676 {
1677     const int mb_x= s->mb_x;
1678     const int mb_y= s->mb_y;
1679     int i;
1680     int skip_dct[6];
1681 #if 0
1682         if (s->interlaced_dct) {
1683             dct_linesize = s->linesize * 2;
1684             dct_offset = s->linesize;
1685         } else {
1686             dct_linesize = s->linesize;
1687             dct_offset = s->linesize * 8;
1688         }
1689 #endif
1690     for(i=0; i<6; i++) skip_dct[i]=0;
1691
1692     if (s->mb_intra) {
1693         UINT8 *ptr;
1694         int wrap;
1695         int emu=0;
1696
1697         wrap = s->linesize;
1698         ptr = s->new_picture[0] + (mb_y * 16 * wrap) + mb_x * 16;
1699         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
1700             emulated_edge_mc(s, ptr, wrap, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
1701             ptr= s->edge_emu_buffer;
1702             emu=1;
1703         }
1704         get_pixels(s->block[0], ptr               , wrap);
1705         get_pixels(s->block[1], ptr            + 8, wrap);
1706         get_pixels(s->block[2], ptr + 8 * wrap    , wrap);
1707         get_pixels(s->block[3], ptr + 8 * wrap + 8, wrap);
1708
1709         if(s->flags&CODEC_FLAG_GRAY){
1710             skip_dct[4]= 1;
1711             skip_dct[5]= 1;
1712         }else{
1713             wrap >>=1;
1714             ptr = s->new_picture[1] + (mb_y * 8 * wrap) + mb_x * 8;
1715             if(emu){
1716                 emulated_edge_mc(s, ptr, wrap, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
1717                 ptr= s->edge_emu_buffer;
1718             }
1719             get_pixels(s->block[4], ptr, wrap);
1720
1721             ptr = s->new_picture[2] + (mb_y * 8 * wrap) + mb_x * 8;
1722             if(emu){
1723                 emulated_edge_mc(s, ptr, wrap, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
1724                 ptr= s->edge_emu_buffer;
1725             }
1726             get_pixels(s->block[5], ptr, wrap);
1727         }
1728     }else{
1729         op_pixels_func *op_pix;
1730         qpel_mc_func *op_qpix;
1731         UINT8 *dest_y, *dest_cb, *dest_cr;
1732         UINT8 *ptr_y, *ptr_cb, *ptr_cr;
1733         int wrap_y, wrap_c;
1734         int emu=0;
1735
1736         dest_y  = s->current_picture[0] + (mb_y * 16 * s->linesize       ) + mb_x * 16;
1737         dest_cb = s->current_picture[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
1738         dest_cr = s->current_picture[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
1739         wrap_y = s->linesize;
1740         wrap_c = wrap_y>>1;
1741         ptr_y  = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
1742         ptr_cb = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
1743         ptr_cr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
1744
1745         if ((!s->no_rounding) || s->pict_type==B_TYPE){
1746             op_pix = put_pixels_tab;
1747             op_qpix= qpel_mc_rnd_tab;
1748         }else{
1749             op_pix = put_no_rnd_pixels_tab;
1750             op_qpix= qpel_mc_no_rnd_tab;
1751         }
1752
1753         if (s->mv_dir & MV_DIR_FORWARD) {
1754             MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
1755            if ((!s->no_rounding) || s->pict_type==B_TYPE)
1756                 op_pix = avg_pixels_tab;
1757             else
1758                 op_pix = avg_no_rnd_pixels_tab;
1759         }
1760         if (s->mv_dir & MV_DIR_BACKWARD) {
1761             MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
1762         }
1763
1764         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
1765             emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
1766             ptr_y= s->edge_emu_buffer;
1767             emu=1;
1768         }
1769         diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
1770         diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
1771         diff_pixels(s->block[2], ptr_y + 8 * wrap_y    , dest_y + 8 * wrap_y    , wrap_y);
1772         diff_pixels(s->block[3], ptr_y + 8 * wrap_y + 8, dest_y + 8 * wrap_y + 8, wrap_y);
1773
1774         if(s->flags&CODEC_FLAG_GRAY){
1775             skip_dct[4]= 1;
1776             skip_dct[5]= 1;
1777         }else{
1778             if(emu){
1779                 emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
1780                 ptr_cb= s->edge_emu_buffer;
1781             }
1782             diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1783             if(emu){
1784                 emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
1785                 ptr_cr= s->edge_emu_buffer;
1786             }
1787             diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1788         }
1789
1790         /* pre quantization */
1791         if(s->mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
1792             if(pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
1793             if(pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
1794             if(pix_abs8x8(ptr_y + 8*wrap_y    , dest_y + 8*wrap_y    , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
1795             if(pix_abs8x8(ptr_y + 8*wrap_y + 8, dest_y + 8*wrap_y + 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
1796             if(pix_abs8x8(ptr_cb              , dest_cb              , wrap_y) < 20*s->qscale) skip_dct[4]= 1;
1797             if(pix_abs8x8(ptr_cr              , dest_cr              , wrap_y) < 20*s->qscale) skip_dct[5]= 1;
1798 #if 0
1799 {
1800  static int stat[7];
1801  int num=0;
1802  for(i=0; i<6; i++)
1803   if(skip_dct[i]) num++;
1804  stat[num]++;
1805
1806  if(s->mb_x==0 && s->mb_y==0){
1807   for(i=0; i<7; i++){
1808    printf("%6d %1d\n", stat[i], i);
1809   }
1810  }
1811 }
1812 #endif
1813         }
1814
1815     }
1816
1817 #if 0
1818             {
1819                 float adap_parm;
1820
1821                 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
1822                             ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
1823
1824                 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d",
1825                         (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P',
1826                         s->qscale, adap_parm, s->qscale*adap_parm,
1827                         s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
1828             }
1829 #endif
1830     /* DCT & quantize */
1831     if(s->out_format==FMT_MJPEG){
1832         for(i=0;i<6;i++) {
1833             int overflow;
1834             s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
1835             if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
1836         }
1837     }else{
1838         for(i=0;i<6;i++) {
1839             if(!skip_dct[i]){
1840                 int overflow;
1841                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
1842             // FIXME we could decide to change to quantizer instead of clipping
1843             // JS: I don't think that would be a good idea it could lower quality instead
1844             //     of improve it. Just INTRADC clipping deserves changes in quantizer
1845                 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
1846             }else
1847                 s->block_last_index[i]= -1;
1848         }
1849         if(s->luma_elim_threshold && !s->mb_intra)
1850             for(i=0; i<4; i++)
1851                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
1852         if(s->chroma_elim_threshold && !s->mb_intra)
1853             for(i=4; i<6; i++)
1854                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
1855     }
1856
1857     if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
1858         s->block_last_index[4]=
1859         s->block_last_index[5]= 0;
1860         s->block[4][0]=
1861         s->block[5][0]= 128;
1862     }
1863
1864     /* huffman encode */
1865     switch(s->out_format) {
1866     case FMT_MPEG1:
1867         mpeg1_encode_mb(s, s->block, motion_x, motion_y);
1868         break;
1869     case FMT_H263:
1870         if (s->h263_msmpeg4)
1871             msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
1872         else if(s->h263_pred)
1873             mpeg4_encode_mb(s, s->block, motion_x, motion_y);
1874         else
1875             h263_encode_mb(s, s->block, motion_x, motion_y);
1876         break;
1877     case FMT_MJPEG:
1878         mjpeg_encode_mb(s, s->block);
1879         break;
1880     }
1881 }
1882
1883 void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
1884 {
1885     int bytes= length>>4;
1886     int bits= length&15;
1887     int i;
1888
1889     if(length==0) return;
1890
1891     for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
1892     put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
1893 }
1894
1895 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
1896     int i;
1897
1898     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
1899
1900     /* mpeg1 */
1901     d->mb_incr= s->mb_incr;
1902     for(i=0; i<3; i++)
1903         d->last_dc[i]= s->last_dc[i];
1904
1905     /* statistics */
1906     d->mv_bits= s->mv_bits;
1907     d->i_tex_bits= s->i_tex_bits;
1908     d->p_tex_bits= s->p_tex_bits;
1909     d->i_count= s->i_count;
1910     d->p_count= s->p_count;
1911     d->skip_count= s->skip_count;
1912     d->misc_bits= s->misc_bits;
1913     d->last_bits= 0;
1914
1915     d->mb_skiped= s->mb_skiped;
1916 }
1917
1918 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
1919     int i;
1920
1921     memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
1922     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
1923
1924     /* mpeg1 */
1925     d->mb_incr= s->mb_incr;
1926     for(i=0; i<3; i++)
1927         d->last_dc[i]= s->last_dc[i];
1928
1929     /* statistics */
1930     d->mv_bits= s->mv_bits;
1931     d->i_tex_bits= s->i_tex_bits;
1932     d->p_tex_bits= s->p_tex_bits;
1933     d->i_count= s->i_count;
1934     d->p_count= s->p_count;
1935     d->skip_count= s->skip_count;
1936     d->misc_bits= s->misc_bits;
1937
1938     d->mb_intra= s->mb_intra;
1939     d->mb_skiped= s->mb_skiped;
1940     d->mv_type= s->mv_type;
1941     d->mv_dir= s->mv_dir;
1942     d->pb= s->pb;
1943     if(s->data_partitioning){
1944         d->pb2= s->pb2;
1945         d->tex_pb= s->tex_pb;
1946     }
1947     d->block= s->block;
1948     for(i=0; i<6; i++)
1949         d->block_last_index[i]= s->block_last_index[i];
1950 }
1951
1952 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
1953                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
1954                            int *dmin, int *next_block, int motion_x, int motion_y)
1955 {
1956     int bits_count;
1957
1958     copy_context_before_encode(s, backup, type);
1959
1960     s->block= s->blocks[*next_block];
1961     s->pb= pb[*next_block];
1962     if(s->data_partitioning){
1963         s->pb2   = pb2   [*next_block];
1964         s->tex_pb= tex_pb[*next_block];
1965     }
1966
1967     encode_mb(s, motion_x, motion_y);
1968
1969     bits_count= get_bit_count(&s->pb);
1970     if(s->data_partitioning){
1971         bits_count+= get_bit_count(&s->pb2);
1972         bits_count+= get_bit_count(&s->tex_pb);
1973     }
1974
1975     if(bits_count<*dmin){
1976         *dmin= bits_count;
1977         *next_block^=1;
1978
1979         copy_context_after_encode(best, s, type);
1980     }
1981 }
1982
1983 static void encode_picture(MpegEncContext *s, int picture_number)
1984 {
1985     int mb_x, mb_y, last_gob, pdif = 0;
1986     int i;
1987     int bits;
1988     MpegEncContext best_s, backup_s;
1989     UINT8 bit_buf[2][3000];
1990     UINT8 bit_buf2[2][3000];
1991     UINT8 bit_buf_tex[2][3000];
1992     PutBitContext pb[2], pb2[2], tex_pb[2];
1993
1994     for(i=0; i<2; i++){
1995         init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
1996         init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
1997         init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
1998     }
1999
2000     s->picture_number = picture_number;
2001
2002     s->block_wrap[0]=
2003     s->block_wrap[1]=
2004     s->block_wrap[2]=
2005     s->block_wrap[3]= s->mb_width*2 + 2;
2006     s->block_wrap[4]=
2007     s->block_wrap[5]= s->mb_width + 2;
2008
2009     /* Reset the average MB variance */
2010     s->mb_var_sum = 0;
2011     s->mc_mb_var_sum = 0;
2012
2013     /* we need to initialize some time vars before we can encode b-frames */
2014     if (s->h263_pred && !s->h263_msmpeg4)
2015         ff_set_mpeg4_time(s, s->picture_number);
2016
2017     s->scene_change_score=0;
2018
2019     /* Estimate motion for every MB */
2020     if(s->pict_type != I_TYPE){
2021         for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2022             s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2023             s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2024             s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2025             s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2026             for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2027                 s->mb_x = mb_x;
2028                 s->mb_y = mb_y;
2029                 s->block_index[0]+=2;
2030                 s->block_index[1]+=2;
2031                 s->block_index[2]+=2;
2032                 s->block_index[3]+=2;
2033
2034                 /* compute motion vector & mb_type and store in context */
2035                 if(s->pict_type==B_TYPE)
2036                     ff_estimate_b_frame_motion(s, mb_x, mb_y);
2037                 else
2038                     ff_estimate_p_frame_motion(s, mb_x, mb_y);
2039 //                s->mb_type[mb_y*s->mb_width + mb_x]=MB_TYPE_INTER;
2040             }
2041         }
2042         emms_c();
2043     }else /* if(s->pict_type == I_TYPE) */{
2044         /* I-Frame */
2045         //FIXME do we need to zero them?
2046         memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2047         memset(s->p_mv_table   , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
2048         memset(s->mb_type      , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2049
2050         if(!s->fixed_qscale){
2051             /* finding spatial complexity for I-frame rate control */
2052             for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2053                 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2054                     int xx = mb_x * 16;
2055                     int yy = mb_y * 16;
2056                     uint8_t *pix = s->new_picture[0] + (yy * s->linesize) + xx;
2057                     int varc;
2058                     int sum = pix_sum(pix, s->linesize);
2059
2060                     sum= (sum+8)>>4;
2061                     varc = (pix_norm1(pix, s->linesize) - sum*sum + 500 + 128)>>8;
2062
2063                     s->mb_var[s->mb_width * mb_y + mb_x] = varc;
2064                     s->mb_var_sum    += varc;
2065                 }
2066             }
2067         }
2068     }
2069     if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2070         s->pict_type= I_TYPE;
2071         memset(s->mb_type   , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2072         if(s->max_b_frames==0){
2073             s->input_pict_type= I_TYPE;
2074             s->input_picture_in_gop_number=0;
2075         }
2076 //printf("Scene change detected, encoding as I Frame %d %d\n", s->mb_var_sum, s->mc_mb_var_sum);
2077     }
2078
2079     if(s->pict_type==P_TYPE || s->pict_type==S_TYPE)
2080         s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2081         ff_fix_long_p_mvs(s);
2082     if(s->pict_type==B_TYPE){
2083         s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2084         s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2085
2086         ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2087         ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2088         ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2089         ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2090     }
2091
2092 //printf("f_code %d ///\n", s->f_code);
2093
2094 //    printf("%d %d\n", s->avg_mb_var, s->mc_mb_var);
2095     if (!s->fixed_qscale)
2096         s->qscale = ff_rate_estimate_qscale(s);
2097
2098     if (s->out_format == FMT_MJPEG) {
2099         /* for mjpeg, we do include qscale in the matrix */
2100         s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2101         for(i=1;i<64;i++)
2102             s->intra_matrix[i] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2103         convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
2104                        s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias);
2105     }
2106
2107     s->last_bits= get_bit_count(&s->pb);
2108     switch(s->out_format) {
2109     case FMT_MJPEG:
2110         mjpeg_picture_header(s);
2111         break;
2112     case FMT_H263:
2113         if (s->h263_msmpeg4)
2114             msmpeg4_encode_picture_header(s, picture_number);
2115         else if (s->h263_pred)
2116             mpeg4_encode_picture_header(s, picture_number);
2117         else if (s->h263_rv10)
2118             rv10_encode_picture_header(s, picture_number);
2119         else
2120             h263_encode_picture_header(s, picture_number);
2121         break;
2122     case FMT_MPEG1:
2123         mpeg1_encode_picture_header(s, picture_number);
2124         break;
2125     }
2126     bits= get_bit_count(&s->pb);
2127     s->header_bits= bits - s->last_bits;
2128     s->last_bits= bits;
2129     s->mv_bits=0;
2130     s->misc_bits=0;
2131     s->i_tex_bits=0;
2132     s->p_tex_bits=0;
2133     s->i_count=0;
2134     s->p_count=0;
2135     s->skip_count=0;
2136
2137     /* init last dc values */
2138     /* note: quant matrix value (8) is implied here */
2139     s->last_dc[0] = 128;
2140     s->last_dc[1] = 128;
2141     s->last_dc[2] = 128;
2142     s->mb_incr = 1;
2143     s->last_mv[0][0][0] = 0;
2144     s->last_mv[0][0][1] = 0;
2145
2146     /* Get the GOB height based on picture height */
2147     if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4) {
2148         if (s->height <= 400)
2149             s->gob_index = 1;
2150         else if (s->height <= 800)
2151             s->gob_index = 2;
2152         else
2153             s->gob_index = 4;
2154     }else if(s->codec_id==CODEC_ID_MPEG4){
2155         s->gob_index = 1;
2156     }
2157
2158     if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
2159         ff_mpeg4_init_partitions(s);
2160
2161     s->resync_mb_x=0;
2162     s->resync_mb_y=0;
2163     for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2164         /* Put GOB header based on RTP MTU for formats which support it per line (H263*)*/
2165         /* TODO: Put all this stuff in a separate generic function */
2166         if (s->rtp_mode) {
2167             if (!mb_y) {
2168                 s->ptr_lastgob = s->pb.buf;
2169                 s->ptr_last_mb_line = s->pb.buf;
2170             } else if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4 && !(mb_y % s->gob_index)) {
2171                 // MN: we could move the space check from h263 -> here, as its not h263 specific
2172                 last_gob = h263_encode_gob_header(s, mb_y);
2173                 if (last_gob) {
2174                     s->first_slice_line = 1;
2175                 }else{
2176                     /*MN: we reset it here instead at the end of each line cuz mpeg4 can have
2177                           slice lines starting & ending in the middle*/
2178                     s->first_slice_line = 0;
2179                 }
2180             }
2181         }
2182
2183         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2184         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2185
2186         s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2187         s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2188         s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2189         s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2190         s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
2191         s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
2192         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2193             const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
2194             const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
2195 //            int d;
2196             int dmin=10000000;
2197
2198             s->mb_x = mb_x;
2199             s->mb_y = mb_y;
2200             s->block_index[0]+=2;
2201             s->block_index[1]+=2;
2202             s->block_index[2]+=2;
2203             s->block_index[3]+=2;
2204             s->block_index[4]++;
2205             s->block_index[5]++;
2206
2207             /* write gob / video packet header for formats which support it at any MB (MPEG4) */
2208             if(s->rtp_mode && s->mb_y>0 && s->codec_id==CODEC_ID_MPEG4){
2209                 int pdif= pbBufPtr(&s->pb) - s->ptr_lastgob;
2210
2211                 //the *2 is there so we stay below the requested size
2212                 if(pdif + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size){
2213                     if(s->codec_id==CODEC_ID_MPEG4){
2214                         if(s->data_partitioning && s->pict_type!=B_TYPE){
2215                             ff_mpeg4_merge_partitions(s);
2216                             ff_mpeg4_init_partitions(s);
2217                         }
2218                         ff_mpeg4_encode_video_packet_header(s);
2219
2220                         if(s->flags&CODEC_FLAG_PASS1){
2221                             int bits= get_bit_count(&s->pb);
2222                             s->misc_bits+= bits - s->last_bits;
2223                             s->last_bits= bits;
2224                         }
2225                         ff_mpeg4_clean_buffers(s);
2226                     }
2227                     s->ptr_lastgob = pbBufPtr(&s->pb);
2228                     s->first_slice_line=1;
2229                     s->resync_mb_x=mb_x;
2230                     s->resync_mb_y=mb_y;
2231                 }
2232
2233                 if(  (s->resync_mb_x   == s->mb_x)
2234                    && s->resync_mb_y+1 == s->mb_y){
2235                     s->first_slice_line=0;
2236                 }
2237             }
2238
2239             if(mb_type & (mb_type-1)){ // more than 1 MB type possible
2240                 int next_block=0;
2241                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2242
2243                 copy_context_before_encode(&backup_s, s, -1);
2244                 backup_s.pb= s->pb;
2245                 best_s.data_partitioning= s->data_partitioning;
2246                 if(s->data_partitioning){
2247                     backup_s.pb2= s->pb2;
2248                     backup_s.tex_pb= s->tex_pb;
2249                 }
2250
2251                 if(mb_type&MB_TYPE_INTER){
2252                     s->mv_dir = MV_DIR_FORWARD;
2253                     s->mv_type = MV_TYPE_16X16;
2254                     s->mb_intra= 0;
2255                     s->mv[0][0][0] = s->p_mv_table[xy][0];
2256                     s->mv[0][0][1] = s->p_mv_table[xy][1];
2257                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,
2258                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2259                 }
2260                 if(mb_type&MB_TYPE_INTER4V){
2261                     s->mv_dir = MV_DIR_FORWARD;
2262                     s->mv_type = MV_TYPE_8X8;
2263                     s->mb_intra= 0;
2264                     for(i=0; i<4; i++){
2265                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2266                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2267                     }
2268                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,
2269                                  &dmin, &next_block, 0, 0);
2270                 }
2271                 if(mb_type&MB_TYPE_FORWARD){
2272                     s->mv_dir = MV_DIR_FORWARD;
2273                     s->mv_type = MV_TYPE_16X16;
2274                     s->mb_intra= 0;
2275                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2276                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2277                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,
2278                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2279                 }
2280                 if(mb_type&MB_TYPE_BACKWARD){
2281                     s->mv_dir = MV_DIR_BACKWARD;
2282                     s->mv_type = MV_TYPE_16X16;
2283                     s->mb_intra= 0;
2284                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2285                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2286                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2287                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2288                 }
2289                 if(mb_type&MB_TYPE_BIDIR){
2290                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2291                     s->mv_type = MV_TYPE_16X16;
2292                     s->mb_intra= 0;
2293                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2294                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2295                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2296                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2297                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,
2298                                  &dmin, &next_block, 0, 0);
2299                 }
2300                 if(mb_type&MB_TYPE_DIRECT){
2301                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2302                     s->mv_type = MV_TYPE_16X16; //FIXME
2303                     s->mb_intra= 0;
2304                     s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2305                     s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2306                     s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2307                     s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2308                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
2309                                  &dmin, &next_block, s->b_direct_mv_table[xy][0], s->b_direct_mv_table[xy][1]);
2310                 }
2311                 if(mb_type&MB_TYPE_INTRA){
2312                     s->mv_dir = MV_DIR_FORWARD;
2313                     s->mv_type = MV_TYPE_16X16;
2314                     s->mb_intra= 1;
2315                     s->mv[0][0][0] = 0;
2316                     s->mv[0][0][1] = 0;
2317                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
2318                                  &dmin, &next_block, 0, 0);
2319                     /* force cleaning of ac/dc pred stuff if needed ... */
2320                     if(s->h263_pred || s->h263_aic)
2321                         s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
2322                 }
2323                 copy_context_after_encode(s, &best_s, -1);
2324
2325                 pb_bits_count= get_bit_count(&s->pb);
2326                 flush_put_bits(&s->pb);
2327                 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2328                 s->pb= backup_s.pb;
2329
2330                 if(s->data_partitioning){
2331                     pb2_bits_count= get_bit_count(&s->pb2);
2332                     flush_put_bits(&s->pb2);
2333                     ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2334                     s->pb2= backup_s.pb2;
2335
2336                     tex_pb_bits_count= get_bit_count(&s->tex_pb);
2337                     flush_put_bits(&s->tex_pb);
2338                     ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2339                     s->tex_pb= backup_s.tex_pb;
2340                 }
2341                 s->last_bits= get_bit_count(&s->pb);
2342             } else {
2343                 int motion_x, motion_y;
2344                 s->mv_type=MV_TYPE_16X16;
2345                 // only one MB-Type possible
2346                 switch(mb_type){
2347                 case MB_TYPE_INTRA:
2348                     s->mv_dir = MV_DIR_FORWARD;
2349                     s->mb_intra= 1;
2350                     motion_x= s->mv[0][0][0] = 0;
2351                     motion_y= s->mv[0][0][1] = 0;
2352                     break;
2353                 case MB_TYPE_INTER:
2354                     s->mv_dir = MV_DIR_FORWARD;
2355                     s->mb_intra= 0;
2356                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2357                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2358                     break;
2359                 case MB_TYPE_INTER4V:
2360                     s->mv_dir = MV_DIR_FORWARD;
2361                     s->mv_type = MV_TYPE_8X8;
2362                     s->mb_intra= 0;
2363                     for(i=0; i<4; i++){
2364                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2365                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2366                     }
2367                     motion_x= motion_y= 0;
2368                     break;
2369                 case MB_TYPE_DIRECT:
2370                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2371                     s->mb_intra= 0;
2372                     motion_x=s->b_direct_mv_table[xy][0];
2373                     motion_y=s->b_direct_mv_table[xy][1];
2374                     s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2375                     s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2376                     s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2377                     s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2378                     break;
2379                 case MB_TYPE_BIDIR:
2380                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2381                     s->mb_intra= 0;
2382                     motion_x=0;
2383                     motion_y=0;
2384                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2385                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2386                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2387                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2388                     break;
2389                 case MB_TYPE_BACKWARD:
2390                     s->mv_dir = MV_DIR_BACKWARD;
2391                     s->mb_intra= 0;
2392                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2393                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2394                     break;
2395                 case MB_TYPE_FORWARD:
2396                     s->mv_dir = MV_DIR_FORWARD;
2397                     s->mb_intra= 0;
2398                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2399                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2400 //                    printf(" %d %d ", motion_x, motion_y);
2401                     break;
2402                 default:
2403                     motion_x=motion_y=0; //gcc warning fix
2404                     printf("illegal MB type\n");
2405                 }
2406                 encode_mb(s, motion_x, motion_y);
2407             }
2408             /* clean the MV table in IPS frames for direct mode in B frames */
2409             if(s->mb_intra /* && I,P,S_TYPE */){
2410                 s->p_mv_table[xy][0]=0;
2411                 s->p_mv_table[xy][1]=0;
2412             }
2413
2414             MPV_decode_mb(s, s->block);
2415 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
2416         }
2417
2418
2419         /* Obtain average GOB size for RTP */
2420         if (s->rtp_mode) {
2421             if (!mb_y)
2422                 s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
2423             else if (!(mb_y % s->gob_index)) {
2424                 s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
2425                 s->ptr_last_mb_line = pbBufPtr(&s->pb);
2426             }
2427             //fprintf(stderr, "\nMB line: %d\tSize: %u\tAvg. Size: %u", s->mb_y,
2428             //                    (s->pb.buf_ptr - s->ptr_last_mb_line), s->mb_line_avgsize);
2429             if(s->codec_id!=CODEC_ID_MPEG4) s->first_slice_line = 0; //FIXME clean
2430         }
2431     }
2432     emms_c();
2433
2434     if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
2435         ff_mpeg4_merge_partitions(s);
2436
2437     if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
2438         msmpeg4_encode_ext_header(s);
2439
2440     if(s->codec_id==CODEC_ID_MPEG4)
2441         ff_mpeg4_stuffing(&s->pb);
2442
2443     //if (s->gob_number)
2444     //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
2445
2446     /* Send the last GOB if RTP */
2447     if (s->rtp_mode) {
2448         flush_put_bits(&s->pb);
2449         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
2450         /* Call the RTP callback to send the last GOB */
2451         if (s->rtp_callback)
2452             s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
2453         s->ptr_lastgob = pbBufPtr(&s->pb);
2454         //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
2455     }
2456 }
2457
2458 static int dct_quantize_c(MpegEncContext *s,
2459                         DCTELEM *block, int n,
2460                         int qscale, int *overflow)
2461 {
2462     int i, j, level, last_non_zero, q;
2463     const int *qmat;
2464     int bias;
2465     int max=0;
2466     unsigned int threshold1, threshold2;
2467
2468     s->fdct (block);
2469
2470     /* we need this permutation so that we correct the IDCT
2471        permutation. will be moved into DCT code */
2472     block_permute(block);
2473
2474     if (s->mb_intra) {
2475         if (!s->h263_aic) {
2476             if (n < 4)
2477                 q = s->y_dc_scale;
2478             else
2479                 q = s->c_dc_scale;
2480             q = q << 3;
2481         } else
2482             /* For AIC we skip quant/dequant of INTRADC */
2483             q = 1 << 3;
2484
2485         /* note: block[0] is assumed to be positive */
2486         block[0] = (block[0] + (q >> 1)) / q;
2487         i = 1;
2488         last_non_zero = 0;
2489         qmat = s->q_intra_matrix[qscale];
2490         bias= s->intra_quant_bias<<(QMAT_SHIFT - 3 - QUANT_BIAS_SHIFT);
2491     } else {
2492         i = 0;
2493         last_non_zero = -1;
2494         qmat = s->q_inter_matrix[qscale];
2495         bias= s->inter_quant_bias<<(QMAT_SHIFT - 3 - QUANT_BIAS_SHIFT);
2496     }
2497     threshold1= (1<<(QMAT_SHIFT - 3)) - bias - 1;
2498     threshold2= threshold1<<1;
2499
2500     for(;i<64;i++) {
2501         j = zigzag_direct[i];
2502         level = block[j];
2503         level = level * qmat[j];
2504
2505 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
2506 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
2507         if(((unsigned)(level+threshold1))>threshold2){
2508             if(level>0){
2509                 level= (bias + level)>>(QMAT_SHIFT - 3);
2510                 block[j]= level;
2511             }else{
2512                 level= (bias - level)>>(QMAT_SHIFT - 3);
2513                 block[j]= -level;
2514             }
2515             max |=level;
2516             last_non_zero = i;
2517         }else{
2518             block[j]=0;
2519         }
2520     }
2521     *overflow= s->max_qcoeff < max; //overflow might have happend
2522
2523     return last_non_zero;
2524 }
2525
2526 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
2527                                    DCTELEM *block, int n, int qscale)
2528 {
2529     int i, level, nCoeffs;
2530     const UINT16 *quant_matrix;
2531
2532     if(s->alternate_scan) nCoeffs= 64;
2533     else nCoeffs= s->block_last_index[n]+1;
2534
2535     if (s->mb_intra) {
2536         if (n < 4)
2537             block[0] = block[0] * s->y_dc_scale;
2538         else
2539             block[0] = block[0] * s->c_dc_scale;
2540         /* XXX: only mpeg1 */
2541         quant_matrix = s->intra_matrix;
2542         for(i=1;i<nCoeffs;i++) {
2543             int j= zigzag_direct[i];
2544             level = block[j];
2545             if (level) {
2546                 if (level < 0) {
2547                     level = -level;
2548                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
2549                     level = (level - 1) | 1;
2550                     level = -level;
2551                 } else {
2552                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
2553                     level = (level - 1) | 1;
2554                 }
2555 #ifdef PARANOID
2556                 if (level < -2048 || level > 2047)
2557                     fprintf(stderr, "unquant error %d %d\n", i, level);
2558 #endif
2559                 block[j] = level;
2560             }
2561         }
2562     } else {
2563         i = 0;
2564         quant_matrix = s->inter_matrix;
2565         for(;i<nCoeffs;i++) {
2566             int j= zigzag_direct[i];
2567             level = block[j];
2568             if (level) {
2569                 if (level < 0) {
2570                     level = -level;
2571                     level = (((level << 1) + 1) * qscale *
2572                              ((int) (quant_matrix[j]))) >> 4;
2573                     level = (level - 1) | 1;
2574                     level = -level;
2575                 } else {
2576                     level = (((level << 1) + 1) * qscale *
2577                              ((int) (quant_matrix[j]))) >> 4;
2578                     level = (level - 1) | 1;
2579                 }
2580 #ifdef PARANOID
2581                 if (level < -2048 || level > 2047)
2582                     fprintf(stderr, "unquant error %d %d\n", i, level);
2583 #endif
2584                 block[j] = level;
2585             }
2586         }
2587     }
2588 }
2589
2590 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
2591                                    DCTELEM *block, int n, int qscale)
2592 {
2593     int i, level, nCoeffs;
2594     const UINT16 *quant_matrix;
2595
2596     if(s->alternate_scan) nCoeffs= 64;
2597     else nCoeffs= s->block_last_index[n]+1;
2598
2599     if (s->mb_intra) {
2600         if (n < 4)
2601             block[0] = block[0] * s->y_dc_scale;
2602         else
2603             block[0] = block[0] * s->c_dc_scale;
2604         quant_matrix = s->intra_matrix;
2605         for(i=1;i<nCoeffs;i++) {
2606             int j= zigzag_direct[i];
2607             level = block[j];
2608             if (level) {
2609                 if (level < 0) {
2610                     level = -level;
2611                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
2612                     level = -level;
2613                 } else {
2614                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
2615                 }
2616 #ifdef PARANOID
2617                 if (level < -2048 || level > 2047)
2618                     fprintf(stderr, "unquant error %d %d\n", i, level);
2619 #endif
2620                 block[j] = level;
2621             }
2622         }
2623     } else {
2624         int sum=-1;
2625         i = 0;
2626         quant_matrix = s->inter_matrix;
2627         for(;i<nCoeffs;i++) {
2628             int j= zigzag_direct[i];
2629             level = block[j];
2630             if (level) {
2631                 if (level < 0) {
2632                     level = -level;
2633                     level = (((level << 1) + 1) * qscale *
2634                              ((int) (quant_matrix[j]))) >> 4;
2635                     level = -level;
2636                 } else {
2637                     level = (((level << 1) + 1) * qscale *
2638                              ((int) (quant_matrix[j]))) >> 4;
2639                 }
2640 #ifdef PARANOID
2641                 if (level < -2048 || level > 2047)
2642                     fprintf(stderr, "unquant error %d %d\n", i, level);
2643 #endif
2644                 block[j] = level;
2645                 sum+=level;
2646             }
2647         }
2648         block[63]^=sum&1;
2649     }
2650 }
2651
2652
2653 static void dct_unquantize_h263_c(MpegEncContext *s,
2654                                   DCTELEM *block, int n, int qscale)
2655 {
2656     int i, level, qmul, qadd;
2657     int nCoeffs;
2658
2659     if (s->mb_intra) {
2660         if (!s->h263_aic) {
2661             if (n < 4)
2662                 block[0] = block[0] * s->y_dc_scale;
2663             else
2664                 block[0] = block[0] * s->c_dc_scale;
2665         }
2666         i = 1;
2667         nCoeffs= 64; //does not allways use zigzag table
2668     } else {
2669         i = 0;
2670         nCoeffs= zigzag_end[ s->block_last_index[n] ];
2671     }
2672
2673     qmul = s->qscale << 1;
2674     if (s->h263_aic && s->mb_intra)
2675         qadd = 0;
2676     else
2677         qadd = (s->qscale - 1) | 1;
2678
2679     for(;i<nCoeffs;i++) {
2680         level = block[i];
2681         if (level) {
2682             if (level < 0) {
2683                 level = level * qmul - qadd;
2684             } else {
2685                 level = level * qmul + qadd;
2686             }
2687 #ifdef PARANOID
2688                 if (level < -2048 || level > 2047)
2689                     fprintf(stderr, "unquant error %d %d\n", i, level);
2690 #endif
2691             block[i] = level;
2692         }
2693     }
2694 }
2695
2696 static void remove_ac(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y)
2697 {
2698     int dc, dcb, dcr, y, i;
2699     for(i=0; i<4; i++){
2700         dc= s->dc_val[0][mb_x*2+1 + (i&1) + (mb_y*2+1 + (i>>1))*(s->mb_width*2+2)];
2701         for(y=0; y<8; y++){
2702             int x;
2703             for(x=0; x<8; x++){
2704                 dest_y[x + (i&1)*8 + (y + (i>>1)*8)*s->linesize]= dc/8;
2705             }
2706         }
2707     }
2708     dcb = s->dc_val[1][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
2709     dcr= s->dc_val[2][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
2710     for(y=0; y<8; y++){
2711         int x;
2712         for(x=0; x<8; x++){
2713             dest_cb[x + y*(s->uvlinesize)]= dcb/8;
2714             dest_cr[x + y*(s->uvlinesize)]= dcr/8;
2715         }
2716     }
2717 }
2718
2719 /**
2720  * will conceal past errors, and allso drop b frames if needed
2721  *
2722  */
2723 void ff_conceal_past_errors(MpegEncContext *s, int unknown_pos)
2724 {
2725     int mb_x= s->mb_x;
2726     int mb_y= s->mb_y;
2727     int mb_dist=0;
2728     int i, intra_count=0, inter_count=0;
2729     int intra_conceal= s->msmpeg4_version ? 50 : 50; //FIXME finetune
2730     int inter_conceal= s->msmpeg4_version ? 50 : 50;
2731
2732     // for last block
2733     if(mb_x>=s->mb_width)  mb_x= s->mb_width -1;
2734     if(mb_y>=s->mb_height) mb_y= s->mb_height-1;
2735
2736     if(s->decoding_error==0 && unknown_pos){
2737         if(s->data_partitioning && s->pict_type!=B_TYPE)
2738                 s->decoding_error= DECODING_AC_LOST;
2739         else
2740                 s->decoding_error= DECODING_DESYNC;
2741     }
2742
2743     if(s->decoding_error==DECODING_DESYNC && s->pict_type!=B_TYPE) s->next_p_frame_damaged=1;
2744
2745     for(i=mb_x + mb_y*s->mb_width; i>=0; i--){
2746         if(s->mbintra_table[i]) intra_count++;
2747         else                    inter_count++;
2748     }
2749
2750     if(s->decoding_error==DECODING_AC_LOST){
2751         intra_conceal*=2;
2752         inter_conceal*=2;
2753     }else if(s->decoding_error==DECODING_ACDC_LOST){
2754         intra_conceal*=2;
2755         inter_conceal*=2;
2756     }
2757
2758     if(unknown_pos && (intra_count<inter_count)){
2759         intra_conceal= inter_conceal= s->mb_num;
2760 //        printf("%d %d\n",intra_count, inter_count);
2761     }
2762
2763     fprintf(stderr, "concealing errors\n");
2764
2765     /* for all MBs from the current one back until the last resync marker */
2766     for(; mb_y>=0 && mb_y>=s->resync_mb_y; mb_y--){
2767         for(; mb_x>=0; mb_x--){
2768             uint8_t *dest_y  = s->current_picture[0] + (mb_y * 16*  s->linesize      ) + mb_x * 16;
2769             uint8_t *dest_cb = s->current_picture[1] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
2770             uint8_t *dest_cr = s->current_picture[2] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
2771             int mb_x_backup= s->mb_x; //FIXME pass xy to mpeg_motion
2772             int mb_y_backup= s->mb_y;
2773             s->mb_x=mb_x;
2774             s->mb_y=mb_y;
2775             if(s->mbintra_table[mb_y*s->mb_width + mb_x] && mb_dist<intra_conceal){
2776                 if(s->decoding_error==DECODING_AC_LOST){
2777                     remove_ac(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
2778 //                    printf("remove ac to %d %d\n", mb_x, mb_y);
2779                 }else{
2780                     mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2781                                 s->last_picture, 0, 0, put_pixels_tab,
2782                                 0/*mx*/, 0/*my*/, 16);
2783                 }
2784             }
2785             else if(!s->mbintra_table[mb_y*s->mb_width + mb_x] && mb_dist<inter_conceal){
2786                 int mx=0;
2787                 int my=0;
2788
2789                 if(s->decoding_error!=DECODING_DESYNC){
2790                     int xy= mb_x*2+1 + (mb_y*2+1)*(s->mb_width*2+2);
2791                     mx= s->motion_val[ xy ][0];
2792                     my= s->motion_val[ xy ][1];
2793                 }
2794
2795                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2796                             s->last_picture, 0, 0, put_pixels_tab,
2797                             mx, my, 16);
2798             }
2799             s->mb_x= mb_x_backup;
2800             s->mb_y= mb_y_backup;
2801
2802             if(mb_x== s->resync_mb_x && mb_y== s->resync_mb_y) return;
2803             if(!s->mbskip_table[mb_x + mb_y*s->mb_width]) mb_dist++;
2804         }
2805         mb_x=s->mb_width-1;
2806     }
2807 }
2808
2809 AVCodec mpeg1video_encoder = {
2810     "mpeg1video",
2811     CODEC_TYPE_VIDEO,
2812     CODEC_ID_MPEG1VIDEO,
2813     sizeof(MpegEncContext),
2814     MPV_encode_init,
2815     MPV_encode_picture,
2816     MPV_encode_end,
2817 };
2818
2819 AVCodec h263_encoder = {
2820     "h263",
2821     CODEC_TYPE_VIDEO,
2822     CODEC_ID_H263,
2823     sizeof(MpegEncContext),
2824     MPV_encode_init,
2825     MPV_encode_picture,
2826     MPV_encode_end,
2827 };
2828
2829 AVCodec h263p_encoder = {
2830     "h263p",
2831     CODEC_TYPE_VIDEO,
2832     CODEC_ID_H263P,
2833     sizeof(MpegEncContext),
2834     MPV_encode_init,
2835     MPV_encode_picture,
2836     MPV_encode_end,
2837 };
2838
2839 AVCodec rv10_encoder = {
2840     "rv10",
2841     CODEC_TYPE_VIDEO,
2842     CODEC_ID_RV10,
2843     sizeof(MpegEncContext),
2844     MPV_encode_init,
2845     MPV_encode_picture,
2846     MPV_encode_end,
2847 };
2848
2849 AVCodec mjpeg_encoder = {
2850     "mjpeg",
2851     CODEC_TYPE_VIDEO,
2852     CODEC_ID_MJPEG,
2853     sizeof(MpegEncContext),
2854     MPV_encode_init,
2855     MPV_encode_picture,
2856     MPV_encode_end,
2857 };
2858
2859 AVCodec mpeg4_encoder = {
2860     "mpeg4",
2861     CODEC_TYPE_VIDEO,
2862     CODEC_ID_MPEG4,
2863     sizeof(MpegEncContext),
2864     MPV_encode_init,
2865     MPV_encode_picture,
2866     MPV_encode_end,
2867 };
2868
2869 AVCodec msmpeg4v1_encoder = {
2870     "msmpeg4v1",
2871     CODEC_TYPE_VIDEO,
2872     CODEC_ID_MSMPEG4V1,
2873     sizeof(MpegEncContext),
2874     MPV_encode_init,
2875     MPV_encode_picture,
2876     MPV_encode_end,
2877 };
2878
2879 AVCodec msmpeg4v2_encoder = {
2880     "msmpeg4v2",
2881     CODEC_TYPE_VIDEO,
2882     CODEC_ID_MSMPEG4V2,
2883     sizeof(MpegEncContext),
2884     MPV_encode_init,
2885     MPV_encode_picture,
2886     MPV_encode_end,
2887 };
2888
2889 AVCodec msmpeg4v3_encoder = {
2890     "msmpeg4",
2891     CODEC_TYPE_VIDEO,
2892     CODEC_ID_MSMPEG4V3,
2893     sizeof(MpegEncContext),
2894     MPV_encode_init,
2895     MPV_encode_picture,
2896     MPV_encode_end,
2897 };
2898
2899 AVCodec wmv1_encoder = {
2900     "wmv1",
2901     CODEC_TYPE_VIDEO,
2902     CODEC_ID_WMV1,
2903     sizeof(MpegEncContext),
2904     MPV_encode_init,
2905     MPV_encode_picture,
2906     MPV_encode_end,
2907 };
2908
2909 AVCodec wmv2_encoder = {
2910     "wmv2",
2911     CODEC_TYPE_VIDEO,
2912     CODEC_ID_WMV2,
2913     sizeof(MpegEncContext),
2914     MPV_encode_init,
2915     MPV_encode_picture,
2916     MPV_encode_end,
2917 };