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