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