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
  22 #include <ctype.h>
  23 #include <limits.h>
  24 #include "avcodec.h"
  25 #include "dsputil.h"
  26 #include "mpegvideo.h"
  27 #include "simple_idct.h"
  28
  29 #ifdef USE_FASTMEMCPY
  30 #include "fastmemcpy.h"
  31 #endif
  32
  33 //#undef NDEBUG
  34 //#include <assert.h>
  35
  36 static void encode_picture(MpegEncContext *s, int picture_number);
  37 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
  38                                    DCTELEM *block, int n, int qscale);
  39 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
  40                                    DCTELEM *block, int n, int qscale);
  41 static void dct_unquantize_h263_c(MpegEncContext *s,
  42                                   DCTELEM *block, int n, int qscale);
  43 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);
  44 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
  45 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
  46
  47 void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
  48
  49
  50 /* enable all paranoid tests for rounding, overflows, etc... */
  51 //#define PARANOID
  52
  53 //#define DEBUG
  54
  55
  56 /* for jpeg fast DCT */
  57 #define CONST_BITS 14
  58
  59 static const uint16_t aanscales[64] = {
  60     /* precomputed values scaled up by 14 bits */
  61     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  62     22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
  63     21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
  64     19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
  65     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  66     12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
  67     8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
  68     4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
  69 };
  70
  71 /* Input permutation for the simple_idct_mmx */
  72 static const uint8_t simple_mmx_permutation[64]={
  73         0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
  74         0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
  75         0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
  76         0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
  77         0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
  78         0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
  79         0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
  80         0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
  81 };
  82
  83 static const uint8_t h263_chroma_roundtab[16] = {
  84 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  85     0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
  86 };
  87
  88 static UINT16 (*default_mv_penalty)[MAX_MV*2+1]=NULL;
  89 static UINT8 default_fcode_tab[MAX_MV*2+1];
  90
  91 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
  92
  93 static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
  94                            const UINT16 *quant_matrix, int bias, int qmin, int qmax)
  95 {
  96     int qscale;
  97
  98     for(qscale=qmin; qscale<=qmax; qscale++){
  99         int i;
 100         if (s->fdct == ff_jpeg_fdct_islow) {
 101             for(i=0;i<64;i++) {
 102                 const int j= s->idct_permutation[i];
 103                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
 104                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
 105                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
 106                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
 107
 108                 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
 109                                 (qscale * quant_matrix[j]));
 110             }
 111         } else if (s->fdct == fdct_ifast) {
 112             for(i=0;i<64;i++) {
 113                 const int j= s->idct_permutation[i];
 114                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
 115                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
 116                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
 117                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
 118
 119                 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
 120                                 (aanscales[i] * qscale * quant_matrix[j]));
 121             }
 122         } else {
 123             for(i=0;i<64;i++) {
 124                 const int j= s->idct_permutation[i];
 125                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
 126                    So 16           <= qscale * quant_matrix[i]             <= 7905
 127                    so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
 128                    so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
 129                 */
 130                 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
 131 //                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
 132                 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
 133
 134                 if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
 135                 qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
 136             }
 137         }
 138     }
 139 }
 140 // move into common.c perhaps
 141 #define CHECKED_ALLOCZ(p, size)\
 142 {\
 143     p= av_mallocz(size);\
 144     if(p==NULL){\
 145         perror("malloc");\
 146         goto fail;\
 147     }\
 148 }
 149
 150 void ff_init_scantable(MpegEncContext *s, ScanTable *st, const UINT8 *src_scantable){
 151     int i;
 152     int end;
 153
 154     st->scantable= src_scantable;
 155
 156     for(i=0; i<64; i++){
 157         int j;
 158         j = src_scantable[i];
 159         st->permutated[i] = s->idct_permutation[j];
 160 #ifdef ARCH_POWERPC
 161         st->inverse[j] = i;
 162 #endif
 163     }
 164
 165     end=-1;
 166     for(i=0; i<64; i++){
 167         int j;
 168         j = st->permutated[i];
 169         if(j>end) end=j;
 170         st->raster_end[i]= end;
 171     }
 172 }
 173
 174 /* XXX: those functions should be suppressed ASAP when all IDCTs are
 175  converted */
 176 // *FIXME* this is ugly hack using local static
 177 static void (*ff_put_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
 178 static void (*ff_add_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
 179 static void ff_jref_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
 180 {
 181     j_rev_dct (block);
 182     ff_put_pixels_clamped(block, dest, line_size);
 183 }
 184 static void ff_jref_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
 185 {
 186     j_rev_dct (block);
 187     ff_add_pixels_clamped(block, dest, line_size);
 188 }
 189
 190 /* init common dct for both encoder and decoder */
 191 int DCT_common_init(MpegEncContext *s)
 192 {
 193     int i;
 194
 195     ff_put_pixels_clamped = s->dsp.put_pixels_clamped;
 196     ff_add_pixels_clamped = s->dsp.add_pixels_clamped;
 197
 198     s->dct_unquantize_h263 = dct_unquantize_h263_c;
 199     s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
 200     s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
 201     s->dct_quantize= dct_quantize_c;
 202
 203     if(s->avctx->dct_algo==FF_DCT_FASTINT)
 204         s->fdct = fdct_ifast;
 205     else
 206         s->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
 207
 208     if(s->avctx->idct_algo==FF_IDCT_INT){
 209         s->idct_put= ff_jref_idct_put;
 210         s->idct_add= ff_jref_idct_add;
 211         s->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
 212     }else{ //accurate/default
 213         s->idct_put= simple_idct_put;
 214         s->idct_add= simple_idct_add;
 215         s->idct_permutation_type= FF_NO_IDCT_PERM;
 216     }
 217
 218 #ifdef HAVE_MMX
 219     MPV_common_init_mmx(s);
 220 #endif
 221 #ifdef ARCH_ALPHA
 222     MPV_common_init_axp(s);
 223 #endif
 224 #ifdef HAVE_MLIB
 225     MPV_common_init_mlib(s);
 226 #endif
 227 #ifdef HAVE_MMI
 228     MPV_common_init_mmi(s);
 229 #endif
 230 #ifdef ARCH_ARMV4L
 231     MPV_common_init_armv4l(s);
 232 #endif
 233 #ifdef ARCH_POWERPC
 234     MPV_common_init_ppc(s);
 235 #endif
 236
 237     s->fast_dct_quantize= s->dct_quantize;
 238
 239     if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
 240         s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
 241     }
 242
 243     switch(s->idct_permutation_type){
 244     case FF_NO_IDCT_PERM:
 245         for(i=0; i<64; i++)
 246             s->idct_permutation[i]= i;
 247         break;
 248     case FF_LIBMPEG2_IDCT_PERM:
 249         for(i=0; i<64; i++)
 250             s->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
 251         break;
 252     case FF_SIMPLE_IDCT_PERM:
 253         for(i=0; i<64; i++)
 254             s->idct_permutation[i]= simple_mmx_permutation[i];
 255         break;
 256     case FF_TRANSPOSE_IDCT_PERM:
 257         for(i=0; i<64; i++)
 258             s->idct_permutation[i]= ((i&7)<<3) | (i>>3);
 259         break;
 260     default:
 261         fprintf(stderr, "Internal error, IDCT permutation not set\n");
 262         return -1;
 263     }
 264
 265
 266     /* load & permutate scantables
 267        note: only wmv uses differnt ones
 268     */
 269     ff_init_scantable(s, &s->inter_scantable  , ff_zigzag_direct);
 270     ff_init_scantable(s, &s->intra_scantable  , ff_zigzag_direct);
 271     ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
 272     ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
 273
 274     return 0;
 275 }
 276
 277 /**
 278  * allocates a Picture
 279  * The pixels are allocated/set by calling get_buffer() if shared=0
 280  */
 281 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
 282
 283     if(shared){
 284         assert(pic->data[0]);
 285         assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
 286         pic->type= FF_BUFFER_TYPE_SHARED;
 287     }else{
 288         int r;
 289
 290         assert(!pic->data[0]);
 291
 292         r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
 293
 294         if(r<0 || !pic->age || !pic->type || !pic->data[0]){
 295             fprintf(stderr, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
 296             return -1;
 297         }
 298
 299         if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
 300             fprintf(stderr, "get_buffer() failed (stride changed)\n");
 301             return -1;
 302         }
 303
 304         if(pic->linesize[1] != pic->linesize[2]){
 305             fprintf(stderr, "get_buffer() failed (uv stride missmatch)\n");
 306             return -1;
 307         }
 308
 309         s->linesize  = pic->linesize[0];
 310         s->uvlinesize= pic->linesize[1];
 311     }
 312
 313     if(pic->qscale_table==NULL){
 314         if (s->encoding) {
 315             CHECKED_ALLOCZ(pic->mb_var   , s->mb_num * sizeof(INT16))
 316             CHECKED_ALLOCZ(pic->mc_mb_var, s->mb_num * sizeof(INT16))
 317             CHECKED_ALLOCZ(pic->mb_mean  , s->mb_num * sizeof(INT8))
 318             CHECKED_ALLOCZ(pic->mb_cmp_score, s->mb_num * sizeof(int32_t))
 319         }
 320
 321         CHECKED_ALLOCZ(pic->mbskip_table , s->mb_num * sizeof(UINT8)+1) //the +1 is for the slice end check
 322         CHECKED_ALLOCZ(pic->qscale_table , s->mb_num * sizeof(UINT8))
 323         pic->qstride= s->mb_width;
 324     }
 325
 326     //it might be nicer if the application would keep track of these but it would require a API change
 327     memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
 328     s->prev_pict_types[0]= s->pict_type;
 329     if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
 330         pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
 331
 332     return 0;
 333 fail: //for the CHECKED_ALLOCZ macro
 334     return -1;
 335 }
 336
 337 /**
 338  * deallocates a picture
 339  */
 340 static void free_picture(MpegEncContext *s, Picture *pic){
 341     int i;
 342
 343     if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
 344         s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
 345     }
 346
 347     av_freep(&pic->mb_var);
 348     av_freep(&pic->mc_mb_var);
 349     av_freep(&pic->mb_mean);
 350     av_freep(&pic->mb_cmp_score);
 351     av_freep(&pic->mbskip_table);
 352     av_freep(&pic->qscale_table);
 353
 354     if(pic->type == FF_BUFFER_TYPE_INTERNAL){
 355         for(i=0; i<4; i++){
 356             av_freep(&pic->base[i]);
 357             pic->data[i]= NULL;
 358         }
 359         av_freep(&pic->opaque);
 360         pic->type= 0;
 361     }else if(pic->type == FF_BUFFER_TYPE_SHARED){
 362         for(i=0; i<4; i++){
 363             pic->base[i]=
 364             pic->data[i]= NULL;
 365         }
 366         pic->type= 0;
 367     }
 368 }
 369
 370 /* init common structure for both encoder and decoder */
 371 int MPV_common_init(MpegEncContext *s)
 372 {
 373     int y_size, c_size, yc_size, i;
 374
 375     dsputil_init(&s->dsp, s->avctx->dsp_mask);
 376     DCT_common_init(s);
 377
 378     s->flags= s->avctx->flags;
 379
 380     s->mb_width  = (s->width  + 15) / 16;
 381     s->mb_height = (s->height + 15) / 16;
 382
 383     /* set default edge pos, will be overriden in decode_header if needed */
 384     s->h_edge_pos= s->mb_width*16;
 385     s->v_edge_pos= s->mb_height*16;
 386
 387     s->mb_num = s->mb_width * s->mb_height;
 388
 389     y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
 390     c_size = (s->mb_width + 2) * (s->mb_height + 2);
 391     yc_size = y_size + 2 * c_size;
 392
 393     /* convert fourcc to upper case */
 394     s->avctx->fourcc=   toupper( s->avctx->fourcc     &0xFF)
 395                      + (toupper((s->avctx->fourcc>>8 )&0xFF)<<8 )
 396                      + (toupper((s->avctx->fourcc>>16)&0xFF)<<16)
 397                      + (toupper((s->avctx->fourcc>>24)&0xFF)<<24);
 398
 399     CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
 400     s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
 401
 402     s->avctx->coded_frame= (AVFrame*)&s->current_picture;
 403
 404     if (s->encoding) {
 405         int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
 406
 407         /* Allocate MV tables */
 408         CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(INT16))
 409         CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(INT16))
 410         CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(INT16))
 411         CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
 412         CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
 413         CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(INT16))
 414
 415         //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
 416         CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t))
 417
 418         CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
 419         CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
 420
 421         if(s->codec_id==CODEC_ID_MPEG4){
 422             CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
 423             CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
 424         }
 425
 426         if(s->msmpeg4_version){
 427             CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
 428         }
 429         CHECKED_ALLOCZ(s->avctx->stats_out, 256);
 430     }
 431
 432     CHECKED_ALLOCZ(s->error_status_table, s->mb_num*sizeof(UINT8))
 433
 434     if (s->out_format == FMT_H263 || s->encoding) {
 435         int size;
 436         /* Allocate MB type table */
 437         CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(UINT8))
 438
 439         /* MV prediction */
 440         size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
 441         CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
 442     }
 443
 444     if(s->codec_id==CODEC_ID_MPEG4){
 445         /* interlaced direct mode decoding tables */
 446         CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
 447         CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
 448     }
 449     /* 4mv b frame decoding table */
 450     //note this is needed for h263 without b frames too (segfault on damaged streams otherwise)
 451     CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
 452     if (s->out_format == FMT_H263) {
 453         /* ac values */
 454         CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(INT16) * 16);
 455         s->ac_val[1] = s->ac_val[0] + y_size;
 456         s->ac_val[2] = s->ac_val[1] + c_size;
 457
 458         /* cbp values */
 459         CHECKED_ALLOCZ(s->coded_block, y_size);
 460
 461         /* divx501 bitstream reorder buffer */
 462         CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
 463
 464         /* cbp, ac_pred, pred_dir */
 465         CHECKED_ALLOCZ(s->cbp_table  , s->mb_num * sizeof(UINT8))
 466         CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
 467     }
 468
 469     if (s->h263_pred || s->h263_plus || !s->encoding) {
 470         /* dc values */
 471         //MN: we need these for error resilience of intra-frames
 472         CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(INT16));
 473         s->dc_val[1] = s->dc_val[0] + y_size;
 474         s->dc_val[2] = s->dc_val[1] + c_size;
 475         for(i=0;i<yc_size;i++)
 476             s->dc_val[0][i] = 1024;
 477     }
 478
 479     /* which mb is a intra block */
 480     CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
 481     memset(s->mbintra_table, 1, s->mb_num);
 482
 483     /* default structure is frame */
 484     s->picture_structure = PICT_FRAME;
 485
 486     /* init macroblock skip table */
 487     CHECKED_ALLOCZ(s->mbskip_table, s->mb_num+1);
 488     //Note the +1 is for a quicker mpeg4 slice_end detection
 489     CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
 490
 491     s->block= s->blocks[0];
 492
 493     s->parse_context.state= -1;
 494
 495     s->context_initialized = 1;
 496     return 0;
 497  fail:
 498     MPV_common_end(s);
 499     return -1;
 500 }
 501
 502
 503 //extern int sads;
 504
 505 /* init common structure for both encoder and decoder */
 506 void MPV_common_end(MpegEncContext *s)
 507 {
 508     int i;
 509
 510     av_freep(&s->mb_type);
 511     av_freep(&s->p_mv_table);
 512     av_freep(&s->b_forw_mv_table);
 513     av_freep(&s->b_back_mv_table);
 514     av_freep(&s->b_bidir_forw_mv_table);
 515     av_freep(&s->b_bidir_back_mv_table);
 516     av_freep(&s->b_direct_mv_table);
 517     av_freep(&s->motion_val);
 518     av_freep(&s->dc_val[0]);
 519     av_freep(&s->ac_val[0]);
 520     av_freep(&s->coded_block);
 521     av_freep(&s->mbintra_table);
 522     av_freep(&s->cbp_table);
 523     av_freep(&s->pred_dir_table);
 524     av_freep(&s->me.scratchpad);
 525     av_freep(&s->me.map);
 526     av_freep(&s->me.score_map);
 527
 528     av_freep(&s->mbskip_table);
 529     av_freep(&s->prev_pict_types);
 530     av_freep(&s->bitstream_buffer);
 531     av_freep(&s->tex_pb_buffer);
 532     av_freep(&s->pb2_buffer);
 533     av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
 534     av_freep(&s->co_located_type_table);
 535     av_freep(&s->field_mv_table);
 536     av_freep(&s->field_select_table);
 537     av_freep(&s->avctx->stats_out);
 538     av_freep(&s->ac_stats);
 539     av_freep(&s->error_status_table);
 540
 541     for(i=0; i<MAX_PICTURE_COUNT; i++){
 542         free_picture(s, &s->picture[i]);
 543     }
 544     s->context_initialized = 0;
 545 }
 546
 547 /* init video encoder */
 548 int MPV_encode_init(AVCodecContext *avctx)
 549 {
 550     MpegEncContext *s = avctx->priv_data;
 551     int i;
 552
 553     avctx->pix_fmt = PIX_FMT_YUV420P;
 554
 555     s->bit_rate = avctx->bit_rate;
 556     s->bit_rate_tolerance = avctx->bit_rate_tolerance;
 557     s->frame_rate = avctx->frame_rate;
 558     s->width = avctx->width;
 559     s->height = avctx->height;
 560     if(avctx->gop_size > 600){
 561         fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
 562         avctx->gop_size=600;
 563     }
 564     s->gop_size = avctx->gop_size;
 565     s->rtp_mode = avctx->rtp_mode;
 566     s->rtp_payload_size = avctx->rtp_payload_size;
 567     if (avctx->rtp_callback)
 568         s->rtp_callback = avctx->rtp_callback;
 569     s->qmin= avctx->qmin;
 570     s->qmax= avctx->qmax;
 571     s->max_qdiff= avctx->max_qdiff;
 572     s->qcompress= avctx->qcompress;
 573     s->qblur= avctx->qblur;
 574     s->avctx = avctx;
 575     s->flags= avctx->flags;
 576     s->max_b_frames= avctx->max_b_frames;
 577     s->b_frame_strategy= avctx->b_frame_strategy;
 578     s->codec_id= avctx->codec->id;
 579     s->luma_elim_threshold  = avctx->luma_elim_threshold;
 580     s->chroma_elim_threshold= avctx->chroma_elim_threshold;
 581     s->strict_std_compliance= avctx->strict_std_compliance;
 582     s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
 583     s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
 584     s->mpeg_quant= avctx->mpeg_quant;
 585
 586     if (s->gop_size <= 1) {
 587         s->intra_only = 1;
 588         s->gop_size = 12;
 589     } else {
 590         s->intra_only = 0;
 591     }
 592
 593     s->me_method = avctx->me_method;
 594
 595     /* Fixed QSCALE */
 596     s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
 597
 598     s->adaptive_quant= (   s->avctx->lumi_masking
 599                         || s->avctx->dark_masking
 600                         || s->avctx->temporal_cplx_masking
 601                         || s->avctx->spatial_cplx_masking
 602                         || s->avctx->p_masking)
 603                        && !s->fixed_qscale;
 604
 605     s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
 606
 607     switch(avctx->codec->id) {
 608     case CODEC_ID_MPEG1VIDEO:
 609         s->out_format = FMT_MPEG1;
 610         avctx->delay=0; //FIXME not sure, should check the spec
 611         break;
 612     case CODEC_ID_MJPEG:
 613         s->out_format = FMT_MJPEG;
 614         s->intra_only = 1; /* force intra only for jpeg */
 615         s->mjpeg_write_tables = 1; /* write all tables */
 616         s->mjpeg_data_only_frames = 0; /* write all the needed headers */
 617         s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
 618         s->mjpeg_vsample[1] = 1; /* the only currently supported values */
 619         s->mjpeg_vsample[2] = 1;
 620         s->mjpeg_hsample[0] = 2;
 621         s->mjpeg_hsample[1] = 1;
 622         s->mjpeg_hsample[2] = 1;
 623         if (mjpeg_init(s) < 0)
 624             return -1;
 625         avctx->delay=0;
 626         s->low_delay=1;
 627         break;
 628     case CODEC_ID_H263:
 629         if (h263_get_picture_format(s->width, s->height) == 7) {
 630             printf("Input picture size isn't suitable for h263 codec! try h263+\n");
 631             return -1;
 632         }
 633         s->out_format = FMT_H263;
 634         avctx->delay=0;
 635         s->low_delay=1;
 636         break;
 637     case CODEC_ID_H263P:
 638         s->out_format = FMT_H263;
 639         s->h263_plus = 1;
 640         s->unrestricted_mv = 1;
 641         s->h263_aic = 1;
 642
 643         /* These are just to be sure */
 644         s->umvplus = 0;
 645         s->umvplus_dec = 0;
 646         avctx->delay=0;
 647         s->low_delay=1;
 648         break;
 649     case CODEC_ID_RV10:
 650         s->out_format = FMT_H263;
 651         s->h263_rv10 = 1;
 652         avctx->delay=0;
 653         s->low_delay=1;
 654         break;
 655     case CODEC_ID_MPEG4:
 656         s->out_format = FMT_H263;
 657         s->h263_pred = 1;
 658         s->unrestricted_mv = 1;
 659         s->low_delay= s->max_b_frames ? 0 : 1;
 660         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
 661         break;
 662     case CODEC_ID_MSMPEG4V1:
 663         s->out_format = FMT_H263;
 664         s->h263_msmpeg4 = 1;
 665         s->h263_pred = 1;
 666         s->unrestricted_mv = 1;
 667         s->msmpeg4_version= 1;
 668         avctx->delay=0;
 669         s->low_delay=1;
 670         break;
 671     case CODEC_ID_MSMPEG4V2:
 672         s->out_format = FMT_H263;
 673         s->h263_msmpeg4 = 1;
 674         s->h263_pred = 1;
 675         s->unrestricted_mv = 1;
 676         s->msmpeg4_version= 2;
 677         avctx->delay=0;
 678         s->low_delay=1;
 679         break;
 680     case CODEC_ID_MSMPEG4V3:
 681         s->out_format = FMT_H263;
 682         s->h263_msmpeg4 = 1;
 683         s->h263_pred = 1;
 684         s->unrestricted_mv = 1;
 685         s->msmpeg4_version= 3;
 686         avctx->delay=0;
 687         s->low_delay=1;
 688         break;
 689     case CODEC_ID_WMV1:
 690         s->out_format = FMT_H263;
 691         s->h263_msmpeg4 = 1;
 692         s->h263_pred = 1;
 693         s->unrestricted_mv = 1;
 694         s->msmpeg4_version= 4;
 695         avctx->delay=0;
 696         s->low_delay=1;
 697         break;
 698     case CODEC_ID_WMV2:
 699         s->out_format = FMT_H263;
 700         s->h263_msmpeg4 = 1;
 701         s->h263_pred = 1;
 702         s->unrestricted_mv = 1;
 703         s->msmpeg4_version= 5;
 704         avctx->delay=0;
 705         s->low_delay=1;
 706         break;
 707     default:
 708         return -1;
 709     }
 710
 711     { /* set up some save defaults, some codecs might override them later */
 712         static int done=0;
 713         if(!done){
 714             int i;
 715             done=1;
 716
 717             default_mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
 718             memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
 719             memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
 720
 721             for(i=-16; i<16; i++){
 722                 default_fcode_tab[i + MAX_MV]= 1;
 723             }
 724         }
 725     }
 726     s->me.mv_penalty= default_mv_penalty;
 727     s->fcode_tab= default_fcode_tab;
 728     s->y_dc_scale_table=
 729     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 730
 731     /* dont use mv_penalty table for crap MV as it would be confused */
 732     //FIXME remove after fixing / removing old ME
 733     if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
 734
 735     s->encoding = 1;
 736
 737     /* init */
 738     if (MPV_common_init(s) < 0)
 739         return -1;
 740
 741     ff_init_me(s);
 742
 743 #ifdef CONFIG_ENCODERS
 744     if (s->out_format == FMT_H263)
 745         h263_encode_init(s);
 746     else if (s->out_format == FMT_MPEG1)
 747         ff_mpeg1_encode_init(s);
 748     if(s->msmpeg4_version)
 749         ff_msmpeg4_encode_init(s);
 750 #endif
 751
 752     /* init default q matrix */
 753     for(i=0;i<64;i++) {
 754         int j= s->idct_permutation[i];
 755         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
 756             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
 757             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
 758         }else if(s->out_format == FMT_H263){
 759             s->intra_matrix[j] =
 760             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
 761         }else{ /* mpeg1 */
 762             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
 763             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
 764         }
 765     }
 766
 767     /* precompute matrix */
 768     /* for mjpeg, we do include qscale in the matrix */
 769     if (s->out_format != FMT_MJPEG) {
 770         convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias,
 771                        s->intra_matrix, s->intra_quant_bias, 1, 31);
 772         convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias,
 773                        s->inter_matrix, s->inter_quant_bias, 1, 31);
 774     }
 775
 776     if(ff_rate_control_init(s) < 0)
 777         return -1;
 778
 779     s->picture_number = 0;
 780     s->picture_in_gop_number = 0;
 781     s->fake_picture_number = 0;
 782     /* motion detector init */
 783     s->f_code = 1;
 784     s->b_code = 1;
 785
 786     return 0;
 787 }
 788
 789 int MPV_encode_end(AVCodecContext *avctx)
 790 {
 791     MpegEncContext *s = avctx->priv_data;
 792
 793 #ifdef STATS
 794     print_stats();
 795 #endif
 796
 797     ff_rate_control_uninit(s);
 798
 799     MPV_common_end(s);
 800     if (s->out_format == FMT_MJPEG)
 801         mjpeg_close(s);
 802
 803     return 0;
 804 }
 805
 806 /* draw the edges of width 'w' of an image of size width, height */
 807 //FIXME check that this is ok for mpeg4 interlaced
 808 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
 809 {
 810     UINT8 *ptr, *last_line;
 811     int i;
 812
 813     last_line = buf + (height - 1) * wrap;
 814     for(i=0;i<w;i++) {
 815         /* top and bottom */
 816         memcpy(buf - (i + 1) * wrap, buf, width);
 817         memcpy(last_line + (i + 1) * wrap, last_line, width);
 818     }
 819     /* left and right */
 820     ptr = buf;
 821     for(i=0;i<height;i++) {
 822         memset(ptr - w, ptr[0], w);
 823         memset(ptr + width, ptr[width-1], w);
 824         ptr += wrap;
 825     }
 826     /* corners */
 827     for(i=0;i<w;i++) {
 828         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
 829         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
 830         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
 831         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
 832     }
 833 }
 834
 835 static int find_unused_picture(MpegEncContext *s, int shared){
 836     int i;
 837
 838     if(shared){
 839         for(i=0; i<MAX_PICTURE_COUNT; i++){
 840             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
 841         }
 842     }else{
 843         for(i=0; i<MAX_PICTURE_COUNT; i++){
 844             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break;
 845         }
 846         for(i=0; i<MAX_PICTURE_COUNT; i++){
 847             if(s->picture[i].data[0]==NULL) break;
 848         }
 849     }
 850
 851     assert(i<MAX_PICTURE_COUNT);
 852     return i;
 853 }
 854
 855 /* generic function for encode/decode called before a frame is coded/decoded */
 856 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
 857 {
 858     int i;
 859     AVFrame *pic;
 860
 861     s->mb_skiped = 0;
 862
 863     /* mark&release old frames */
 864     if (s->pict_type != B_TYPE && s->last_picture.data[0]) {
 865         for(i=0; i<MAX_PICTURE_COUNT; i++){
 866 //printf("%8X %d %d %X %X\n", s->picture[i].data[0], s->picture[i].type, i, s->next_picture.data[0], s->last_picture.data[0]);
 867             if(s->picture[i].data[0] == s->last_picture.data[0]){
 868 //                s->picture[i].reference=0;
 869                 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
 870                 break;
 871             }
 872         }
 873         assert(i<MAX_PICTURE_COUNT);
 874
 875         /* release forgotten pictures */
 876         /* if(mpeg124/h263) */
 877         if(!s->encoding){
 878             for(i=0; i<MAX_PICTURE_COUNT; i++){
 879                 if(s->picture[i].data[0] && s->picture[i].data[0] != s->next_picture.data[0] && s->picture[i].reference){
 880                     fprintf(stderr, "releasing zombie picture\n");
 881                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
 882                 }
 883             }
 884         }
 885     }
 886 alloc:
 887     if(!s->encoding){
 888         i= find_unused_picture(s, 0);
 889
 890         pic= (AVFrame*)&s->picture[i];
 891         pic->reference= s->pict_type != B_TYPE;
 892         pic->coded_picture_number= s->current_picture.coded_picture_number+1;
 893
 894         alloc_picture(s, (Picture*)pic, 0);
 895
 896         s->current_picture= s->picture[i];
 897     }
 898
 899     if (s->pict_type != B_TYPE) {
 900         s->last_picture= s->next_picture;
 901         s->next_picture= s->current_picture;
 902     }
 903
 904     if(s->pict_type != I_TYPE && s->last_picture.data[0]==NULL){
 905         fprintf(stderr, "warning: first frame is no keyframe\n");
 906         assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
 907         goto alloc;
 908     }
 909
 910     s->hurry_up= s->avctx->hurry_up;
 911     s->error_resilience= avctx->error_resilience;
 912
 913     /* set dequantizer, we cant do it during init as it might change for mpeg4
 914        and we cant do it in the header decode as init isnt called for mpeg4 there yet */
 915     if(s->out_format == FMT_H263){
 916         if(s->mpeg_quant)
 917             s->dct_unquantize = s->dct_unquantize_mpeg2;
 918         else
 919             s->dct_unquantize = s->dct_unquantize_h263;
 920     }else
 921         s->dct_unquantize = s->dct_unquantize_mpeg1;
 922
 923     return 0;
 924 }
 925
 926 /* generic function for encode/decode called after a frame has been coded/decoded */
 927 void MPV_frame_end(MpegEncContext *s)
 928 {
 929     int i;
 930     /* draw edge for correct motion prediction if outside */
 931     if(s->codec_id!=CODEC_ID_SVQ1){
 932         if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
 933             draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
 934             draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
 935             draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
 936         }
 937     }
 938     emms_c();
 939
 940     s->last_pict_type    = s->pict_type;
 941     if(s->pict_type!=B_TYPE){
 942         s->last_non_b_pict_type= s->pict_type;
 943     }
 944
 945     s->current_picture.quality= s->qscale; //FIXME get average of qscale_table
 946     s->current_picture.pict_type= s->pict_type;
 947     s->current_picture.key_frame= s->pict_type == I_TYPE;
 948
 949     /* copy back current_picture variables */
 950     for(i=0; i<MAX_PICTURE_COUNT; i++){
 951         if(s->picture[i].data[0] == s->current_picture.data[0]){
 952             s->picture[i]= s->current_picture;
 953             break;
 954         }
 955     }
 956     assert(i<MAX_PICTURE_COUNT);
 957
 958     /* release non refernce frames */
 959     for(i=0; i<MAX_PICTURE_COUNT; i++){
 960         if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/)
 961             s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
 962     }
 963     if(s->avctx->debug&FF_DEBUG_SKIP){
 964         int x,y;
 965         for(y=0; y<s->mb_height; y++){
 966             for(x=0; x<s->mb_width; x++){
 967                 int count= s->mbskip_table[x + y*s->mb_width];
 968                 if(count>9) count=9;
 969                 printf(" %1d", count);
 970             }
 971             printf("\n");
 972         }
 973         printf("pict type: %d\n", s->pict_type);
 974     }
 975 }
 976
 977 static int get_sae(uint8_t *src, int ref, int stride){
 978     int x,y;
 979     int acc=0;
 980
 981     for(y=0; y<16; y++){
 982         for(x=0; x<16; x++){
 983             acc+= ABS(src[x+y*stride] - ref);
 984         }
 985     }
 986
 987     return acc;
 988 }
 989
 990 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
 991     int x, y, w, h;
 992     int acc=0;
 993
 994     w= s->width &~15;
 995     h= s->height&~15;
 996
 997     for(y=0; y<h; y+=16){
 998         for(x=0; x<w; x+=16){
 999             int offset= x + y*stride;
1000             int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1001             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1002             int sae = get_sae(src + offset, mean, stride);
1003
1004             acc+= sae + 500 < sad;
1005         }
1006     }
1007     return acc;
1008 }
1009
1010
1011 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1012     AVFrame *pic;
1013     int i;
1014     const int encoding_delay= s->max_b_frames;
1015     int direct=1;
1016
1017     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1018     if(pic_arg->linesize[0] != s->linesize) direct=0;
1019     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1020     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1021
1022 //    printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1023
1024     if(direct){
1025         i= find_unused_picture(s, 1);
1026
1027         pic= (AVFrame*)&s->picture[i];
1028         pic->reference= 1;
1029
1030         for(i=0; i<4; i++){
1031             pic->data[i]= pic_arg->data[i];
1032             pic->linesize[i]= pic_arg->linesize[i];
1033         }
1034         alloc_picture(s, (Picture*)pic, 1);
1035     }else{
1036         i= find_unused_picture(s, 0);
1037
1038         pic= (AVFrame*)&s->picture[i];
1039         pic->reference= 1;
1040
1041         alloc_picture(s, (Picture*)pic, 0);
1042
1043         if(   pic->data[0] == pic_arg->data[0]
1044            && pic->data[1] == pic_arg->data[1]
1045            && pic->data[2] == pic_arg->data[2]){
1046        // empty
1047         }else{
1048             int h_chroma_shift, v_chroma_shift;
1049
1050             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1051
1052             for(i=0; i<3; i++){
1053                 int src_stride= pic_arg->linesize[i];
1054                 int dst_stride= i ? s->uvlinesize : s->linesize;
1055                 int h_shift= i ? h_chroma_shift : 0;
1056                 int v_shift= i ? v_chroma_shift : 0;
1057                 int w= s->width >>h_shift;
1058                 int h= s->height>>v_shift;
1059                 uint8_t *src= pic_arg->data[i];
1060                 uint8_t *dst= pic->data[i];
1061
1062                 if(src_stride==dst_stride)
1063                     memcpy(dst, src, src_stride*h);
1064                 else{
1065                     while(h--){
1066                         memcpy(dst, src, w);
1067                         dst += dst_stride;
1068                         src += src_stride;
1069                     }
1070                 }
1071             }
1072         }
1073     }
1074     pic->quality= pic_arg->quality;
1075     pic->pict_type= pic_arg->pict_type;
1076     pic->pts = pic_arg->pts;
1077
1078     if(s->input_picture[encoding_delay])
1079         pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1080
1081     /* shift buffer entries */
1082     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1083         s->input_picture[i-1]= s->input_picture[i];
1084
1085     s->input_picture[encoding_delay]= (Picture*)pic;
1086
1087     return 0;
1088 }
1089
1090 static void select_input_picture(MpegEncContext *s){
1091     int i;
1092     const int encoding_delay= s->max_b_frames;
1093     int coded_pic_num=0;
1094
1095     if(s->reordered_input_picture[0])
1096         coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1097
1098     for(i=1; i<MAX_PICTURE_COUNT; i++)
1099         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1100     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1101
1102     /* set next picture types & ordering */
1103     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1104         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture.data[0]==NULL || s->intra_only){
1105             s->reordered_input_picture[0]= s->input_picture[0];
1106             s->reordered_input_picture[0]->pict_type= I_TYPE;
1107             s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1108         }else{
1109             int b_frames;
1110
1111             if(s->flags&CODEC_FLAG_PASS2){
1112                 for(i=0; i<s->max_b_frames+1; i++){
1113                     int pict_num= s->input_picture[0]->display_picture_number + i;
1114                     int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1115                     s->input_picture[i]->pict_type= pict_type;
1116
1117                     if(i + 1 >= s->rc_context.num_entries) break;
1118                 }
1119             }
1120
1121             if(s->input_picture[0]->pict_type){
1122                 /* user selected pict_type */
1123                 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1124                     if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1125                 }
1126
1127                 if(b_frames > s->max_b_frames){
1128                     fprintf(stderr, "warning, too many bframes in a row\n");
1129                     b_frames = s->max_b_frames;
1130                 }
1131             }else if(s->b_frame_strategy==0){
1132                 b_frames= s->max_b_frames;
1133             }else if(s->b_frame_strategy==1){
1134                 for(i=1; i<s->max_b_frames+1; i++){
1135                     if(s->input_picture[i]->b_frame_score==0){
1136                         s->input_picture[i]->b_frame_score=
1137                             get_intra_count(s, s->input_picture[i  ]->data[0],
1138                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
1139                     }
1140                 }
1141                 for(i=0; i<s->max_b_frames; i++){
1142                     if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1143                 }
1144
1145                 b_frames= FFMAX(0, i-1);
1146
1147                 /* reset scores */
1148                 for(i=0; i<b_frames+1; i++){
1149                     s->input_picture[i]->b_frame_score=0;
1150                 }
1151             }else{
1152                 fprintf(stderr, "illegal b frame strategy\n");
1153                 b_frames=0;
1154             }
1155
1156             emms_c();
1157 //static int b_count=0;
1158 //b_count+= b_frames;
1159 //printf("b_frames: %d\n", b_count);
1160
1161             s->reordered_input_picture[0]= s->input_picture[b_frames];
1162             if(   s->picture_in_gop_number + b_frames >= s->gop_size
1163                || s->reordered_input_picture[0]->pict_type== I_TYPE)
1164                 s->reordered_input_picture[0]->pict_type= I_TYPE;
1165             else
1166                 s->reordered_input_picture[0]->pict_type= P_TYPE;
1167             s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1168             for(i=0; i<b_frames; i++){
1169                 coded_pic_num++;
1170                 s->reordered_input_picture[i+1]= s->input_picture[i];
1171                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1172                 s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1173             }
1174         }
1175     }
1176
1177     if(s->reordered_input_picture[0]){
1178        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE;
1179
1180         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1181             int i= find_unused_picture(s, 0);
1182             Picture *pic= &s->picture[i];
1183
1184             s->new_picture= *s->reordered_input_picture[0];
1185
1186             /* mark us unused / free shared pic */
1187             for(i=0; i<4; i++)
1188                 s->reordered_input_picture[0]->data[i]= NULL;
1189             s->reordered_input_picture[0]->type= 0;
1190
1191             pic->pict_type = s->reordered_input_picture[0]->pict_type;
1192             pic->quality   = s->reordered_input_picture[0]->quality;
1193             pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1194             pic->reference = s->reordered_input_picture[0]->reference;
1195
1196             alloc_picture(s, pic, 0);
1197
1198             s->current_picture= *pic;
1199         }else{
1200             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
1201                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1202
1203             s->new_picture= *s->reordered_input_picture[0];
1204
1205             for(i=0; i<4; i++){
1206                 s->reordered_input_picture[0]->data[i]-=16; //FIXME dirty
1207             }
1208             s->current_picture= *s->reordered_input_picture[0];
1209         }
1210
1211         s->picture_number= s->new_picture.display_picture_number;
1212 //printf("dpn:%d\n", s->picture_number);
1213     }else{
1214        memset(&s->new_picture, 0, sizeof(Picture));
1215     }
1216 }
1217
1218 int MPV_encode_picture(AVCodecContext *avctx,
1219                        unsigned char *buf, int buf_size, void *data)
1220 {
1221     MpegEncContext *s = avctx->priv_data;
1222     AVFrame *pic_arg = data;
1223     int i;
1224
1225     init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1226
1227     s->picture_in_gop_number++;
1228
1229     load_input_picture(s, pic_arg);
1230
1231     select_input_picture(s);
1232
1233     /* output? */
1234     if(s->new_picture.data[0]){
1235
1236         s->pict_type= s->new_picture.pict_type;
1237         if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1238             s->qscale= (int)(s->new_picture.quality+0.5);
1239             assert(s->qscale);
1240         }
1241 //emms_c();
1242 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1243         MPV_frame_start(s, avctx);
1244
1245         encode_picture(s, s->picture_number);
1246
1247         avctx->real_pict_num  = s->picture_number;
1248         avctx->header_bits = s->header_bits;
1249         avctx->mv_bits     = s->mv_bits;
1250         avctx->misc_bits   = s->misc_bits;
1251         avctx->i_tex_bits  = s->i_tex_bits;
1252         avctx->p_tex_bits  = s->p_tex_bits;
1253         avctx->i_count     = s->i_count;
1254         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1255         avctx->skip_count  = s->skip_count;
1256
1257         MPV_frame_end(s);
1258
1259         if (s->out_format == FMT_MJPEG)
1260             mjpeg_picture_trailer(s);
1261
1262         if(s->flags&CODEC_FLAG_PASS1)
1263             ff_write_pass1_stats(s);
1264     }
1265
1266     s->input_picture_number++;
1267
1268     flush_put_bits(&s->pb);
1269     s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1270
1271     s->total_bits += s->frame_bits;
1272     avctx->frame_bits  = s->frame_bits;
1273
1274     for(i=0; i<4; i++){
1275         avctx->error[i] += s->current_picture.error[i];
1276     }
1277
1278     return pbBufPtr(&s->pb) - s->pb.buf;
1279 }
1280
1281 static inline void gmc1_motion(MpegEncContext *s,
1282                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1283                                int dest_offset,
1284                                UINT8 **ref_picture, int src_offset)
1285 {
1286     UINT8 *ptr;
1287     int offset, src_x, src_y, linesize, uvlinesize;
1288     int motion_x, motion_y;
1289     int emu=0;
1290
1291     motion_x= s->sprite_offset[0][0];
1292     motion_y= s->sprite_offset[0][1];
1293     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1294     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1295     motion_x<<=(3-s->sprite_warping_accuracy);
1296     motion_y<<=(3-s->sprite_warping_accuracy);
1297     src_x = clip(src_x, -16, s->width);
1298     if (src_x == s->width)
1299         motion_x =0;
1300     src_y = clip(src_y, -16, s->height);
1301     if (src_y == s->height)
1302         motion_y =0;
1303
1304     linesize = s->linesize;
1305     uvlinesize = s->uvlinesize;
1306
1307     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1308
1309     dest_y+=dest_offset;
1310     if(s->flags&CODEC_FLAG_EMU_EDGE){
1311         if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1312                               || src_y + 17 >= s->v_edge_pos){
1313             ff_emulated_edge_mc(s, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1314             ptr= s->edge_emu_buffer;
1315         }
1316     }
1317
1318     if((motion_x|motion_y)&7){
1319         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1320         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1321     }else{
1322         int dxy;
1323
1324         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1325         if (s->no_rounding){
1326             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1327         }else{
1328             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
1329         }
1330     }
1331
1332     if(s->flags&CODEC_FLAG_GRAY) return;
1333
1334     motion_x= s->sprite_offset[1][0];
1335     motion_y= s->sprite_offset[1][1];
1336     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1337     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1338     motion_x<<=(3-s->sprite_warping_accuracy);
1339     motion_y<<=(3-s->sprite_warping_accuracy);
1340     src_x = clip(src_x, -8, s->width>>1);
1341     if (src_x == s->width>>1)
1342         motion_x =0;
1343     src_y = clip(src_y, -8, s->height>>1);
1344     if (src_y == s->height>>1)
1345         motion_y =0;
1346
1347     offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1348     ptr = ref_picture[1] + offset;
1349     if(s->flags&CODEC_FLAG_EMU_EDGE){
1350         if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1351                               || src_y + 9 >= s->v_edge_pos>>1){
1352             ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1353             ptr= s->edge_emu_buffer;
1354             emu=1;
1355         }
1356     }
1357     s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1358
1359     ptr = ref_picture[2] + offset;
1360     if(emu){
1361         ff_emulated_edge_mc(s, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1362         ptr= s->edge_emu_buffer;
1363     }
1364     s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1365
1366     return;
1367 }
1368
1369 static inline void gmc_motion(MpegEncContext *s,
1370                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1371                                int dest_offset,
1372                                UINT8 **ref_picture, int src_offset)
1373 {
1374     UINT8 *ptr;
1375     int linesize, uvlinesize;
1376     const int a= s->sprite_warping_accuracy;
1377     int ox, oy;
1378
1379     linesize = s->linesize;
1380     uvlinesize = s->uvlinesize;
1381
1382     ptr = ref_picture[0] + src_offset;
1383
1384     dest_y+=dest_offset;
1385
1386     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1387     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1388
1389     s->dsp.gmc(dest_y, ptr, linesize, 16,
1390            ox,
1391            oy,
1392            s->sprite_delta[0][0], s->sprite_delta[0][1],
1393            s->sprite_delta[1][0], s->sprite_delta[1][1],
1394            a+1, (1<<(2*a+1)) - s->no_rounding,
1395            s->h_edge_pos, s->v_edge_pos);
1396     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1397            ox + s->sprite_delta[0][0]*8,
1398            oy + s->sprite_delta[1][0]*8,
1399            s->sprite_delta[0][0], s->sprite_delta[0][1],
1400            s->sprite_delta[1][0], s->sprite_delta[1][1],
1401            a+1, (1<<(2*a+1)) - s->no_rounding,
1402            s->h_edge_pos, s->v_edge_pos);
1403
1404     if(s->flags&CODEC_FLAG_GRAY) return;
1405
1406
1407     dest_cb+=dest_offset>>1;
1408     dest_cr+=dest_offset>>1;
1409
1410     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1411     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1412
1413     ptr = ref_picture[1] + (src_offset>>1);
1414     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1415            ox,
1416            oy,
1417            s->sprite_delta[0][0], s->sprite_delta[0][1],
1418            s->sprite_delta[1][0], s->sprite_delta[1][1],
1419            a+1, (1<<(2*a+1)) - s->no_rounding,
1420            s->h_edge_pos>>1, s->v_edge_pos>>1);
1421
1422     ptr = ref_picture[2] + (src_offset>>1);
1423     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1424            ox,
1425            oy,
1426            s->sprite_delta[0][0], s->sprite_delta[0][1],
1427            s->sprite_delta[1][0], s->sprite_delta[1][1],
1428            a+1, (1<<(2*a+1)) - s->no_rounding,
1429            s->h_edge_pos>>1, s->v_edge_pos>>1);
1430 }
1431
1432
1433 void ff_emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h,
1434                                     int src_x, int src_y, int w, int h){
1435     int x, y;
1436     int start_y, start_x, end_y, end_x;
1437     UINT8 *buf= s->edge_emu_buffer;
1438
1439     if(src_y>= h){
1440         src+= (h-1-src_y)*linesize;
1441         src_y=h-1;
1442     }else if(src_y<=-block_h){
1443         src+= (1-block_h-src_y)*linesize;
1444         src_y=1-block_h;
1445     }
1446     if(src_x>= w){
1447         src+= (w-1-src_x);
1448         src_x=w-1;
1449     }else if(src_x<=-block_w){
1450         src+= (1-block_w-src_x);
1451         src_x=1-block_w;
1452     }
1453
1454     start_y= FFMAX(0, -src_y);
1455     start_x= FFMAX(0, -src_x);
1456     end_y= FFMIN(block_h, h-src_y);
1457     end_x= FFMIN(block_w, w-src_x);
1458
1459     // copy existing part
1460     for(y=start_y; y<end_y; y++){
1461         for(x=start_x; x<end_x; x++){
1462             buf[x + y*linesize]= src[x + y*linesize];
1463         }
1464     }
1465
1466     //top
1467     for(y=0; y<start_y; y++){
1468         for(x=start_x; x<end_x; x++){
1469             buf[x + y*linesize]= buf[x + start_y*linesize];
1470         }
1471     }
1472
1473     //bottom
1474     for(y=end_y; y<block_h; y++){
1475         for(x=start_x; x<end_x; x++){
1476             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1477         }
1478     }
1479
1480     for(y=0; y<block_h; y++){
1481        //left
1482         for(x=0; x<start_x; x++){
1483             buf[x + y*linesize]= buf[start_x + y*linesize];
1484         }
1485
1486        //right
1487         for(x=end_x; x<block_w; x++){
1488             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1489         }
1490     }
1491 }
1492
1493
1494 /* apply one mpeg motion vector to the three components */
1495 static inline void mpeg_motion(MpegEncContext *s,
1496                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1497                                int dest_offset,
1498                                UINT8 **ref_picture, int src_offset,
1499                                int field_based, op_pixels_func (*pix_op)[4],
1500                                int motion_x, int motion_y, int h)
1501 {
1502     UINT8 *ptr;
1503     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1504     int emu=0;
1505 #if 0
1506 if(s->quarter_sample)
1507 {
1508     motion_x>>=1;
1509     motion_y>>=1;
1510 }
1511 #endif
1512     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1513     src_x = s->mb_x * 16 + (motion_x >> 1);
1514     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1515
1516     /* WARNING: do no forget half pels */
1517     height = s->height >> field_based;
1518     v_edge_pos = s->v_edge_pos >> field_based;
1519     src_x = clip(src_x, -16, s->width);
1520     if (src_x == s->width)
1521         dxy &= ~1;
1522     src_y = clip(src_y, -16, height);
1523     if (src_y == height)
1524         dxy &= ~2;
1525     linesize   = s->linesize << field_based;
1526     uvlinesize = s->uvlinesize << field_based;
1527     ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1528     dest_y += dest_offset;
1529
1530     if(s->flags&CODEC_FLAG_EMU_EDGE){
1531         if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1532                               || src_y + (motion_y&1) + h  > v_edge_pos){
1533             ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,
1534                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1535             ptr= s->edge_emu_buffer + src_offset;
1536             emu=1;
1537         }
1538     }
1539     pix_op[0][dxy](dest_y, ptr, linesize, h);
1540
1541     if(s->flags&CODEC_FLAG_GRAY) return;
1542
1543     if (s->out_format == FMT_H263) {
1544         dxy = 0;
1545         if ((motion_x & 3) != 0)
1546             dxy |= 1;
1547         if ((motion_y & 3) != 0)
1548             dxy |= 2;
1549         mx = motion_x >> 2;
1550         my = motion_y >> 2;
1551     } else {
1552         mx = motion_x / 2;
1553         my = motion_y / 2;
1554         dxy = ((my & 1) << 1) | (mx & 1);
1555         mx >>= 1;
1556         my >>= 1;
1557     }
1558
1559     src_x = s->mb_x * 8 + mx;
1560     src_y = s->mb_y * (8 >> field_based) + my;
1561     src_x = clip(src_x, -8, s->width >> 1);
1562     if (src_x == (s->width >> 1))
1563         dxy &= ~1;
1564     src_y = clip(src_y, -8, height >> 1);
1565     if (src_y == (height >> 1))
1566         dxy &= ~2;
1567     offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1568     ptr = ref_picture[1] + offset;
1569     if(emu){
1570         ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
1571                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1572         ptr= s->edge_emu_buffer + (src_offset >> 1);
1573     }
1574     pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1575
1576     ptr = ref_picture[2] + offset;
1577     if(emu){
1578         ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
1579                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1580         ptr= s->edge_emu_buffer + (src_offset >> 1);
1581     }
1582     pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1583 }
1584
1585 static inline void qpel_motion(MpegEncContext *s,
1586                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1587                                int dest_offset,
1588                                UINT8 **ref_picture, int src_offset,
1589                                int field_based, op_pixels_func (*pix_op)[4],
1590                                qpel_mc_func (*qpix_op)[16],
1591                                int motion_x, int motion_y, int h)
1592 {
1593     UINT8 *ptr;
1594     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1595     int emu=0;
1596
1597     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1598     src_x = s->mb_x * 16 + (motion_x >> 2);
1599     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1600
1601     height = s->height >> field_based;
1602     v_edge_pos = s->v_edge_pos >> field_based;
1603     src_x = clip(src_x, -16, s->width);
1604     if (src_x == s->width)
1605         dxy &= ~3;
1606     src_y = clip(src_y, -16, height);
1607     if (src_y == height)
1608         dxy &= ~12;
1609     linesize = s->linesize << field_based;
1610     uvlinesize = s->uvlinesize << field_based;
1611     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1612     dest_y += dest_offset;
1613 //printf("%d %d %d\n", src_x, src_y, dxy);
1614
1615     if(s->flags&CODEC_FLAG_EMU_EDGE){
1616         if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1617                               || src_y + (motion_y&3) + h  > v_edge_pos){
1618             ff_emulated_edge_mc(s, ptr - src_offset, s->linesize, 17, 17+field_based,
1619                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1620             ptr= s->edge_emu_buffer + src_offset;
1621             emu=1;
1622         }
1623     }
1624     if(!field_based)
1625         qpix_op[0][dxy](dest_y, ptr, linesize);
1626     else{
1627         //damn interlaced mode
1628         //FIXME boundary mirroring is not exactly correct here
1629         qpix_op[1][dxy](dest_y  , ptr  , linesize);
1630         qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1631     }
1632
1633     if(s->flags&CODEC_FLAG_GRAY) return;
1634
1635     if(field_based){
1636         mx= motion_x/2;
1637         my= motion_y>>1;
1638     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1639         mx= (motion_x>>1)|(motion_x&1);
1640         my= (motion_y>>1)|(motion_y&1);
1641     }else{
1642         mx= motion_x/2;
1643         my= motion_y/2;
1644     }
1645     mx= (mx>>1)|(mx&1);
1646     my= (my>>1)|(my&1);
1647     dxy= (mx&1) | ((my&1)<<1);
1648     mx>>=1;
1649     my>>=1;
1650
1651     src_x = s->mb_x * 8 + mx;
1652     src_y = s->mb_y * (8 >> field_based) + my;
1653     src_x = clip(src_x, -8, s->width >> 1);
1654     if (src_x == (s->width >> 1))
1655         dxy &= ~1;
1656     src_y = clip(src_y, -8, height >> 1);
1657     if (src_y == (height >> 1))
1658         dxy &= ~2;
1659
1660     offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1661     ptr = ref_picture[1] + offset;
1662     if(emu){
1663         ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
1664                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1665         ptr= s->edge_emu_buffer + (src_offset >> 1);
1666     }
1667     pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1668
1669     ptr = ref_picture[2] + offset;
1670     if(emu){
1671         ff_emulated_edge_mc(s, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
1672                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1673         ptr= s->edge_emu_buffer + (src_offset >> 1);
1674     }
1675     pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
1676 }
1677
1678 inline int ff_h263_round_chroma(int x){
1679     if (x >= 0)
1680         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1681     else {
1682         x = -x;
1683         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
1684     }
1685 }
1686
1687 static inline void MPV_motion(MpegEncContext *s,
1688                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1689                               int dir, UINT8 **ref_picture,
1690                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1691 {
1692     int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1693     int mb_x, mb_y, i;
1694     UINT8 *ptr, *dest;
1695     int emu=0;
1696
1697     mb_x = s->mb_x;
1698     mb_y = s->mb_y;
1699
1700     switch(s->mv_type) {
1701     case MV_TYPE_16X16:
1702         if(s->mcsel){
1703             if(s->real_sprite_warping_points==1){
1704                 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1705                             ref_picture, 0);
1706             }else{
1707                 gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
1708                             ref_picture, 0);
1709             }
1710         }else if(s->quarter_sample){
1711             qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1712                         ref_picture, 0,
1713                         0, pix_op, qpix_op,
1714                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
1715         }else if(s->mspel){
1716             ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
1717                         ref_picture, pix_op,
1718                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
1719         }else{
1720             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1721                         ref_picture, 0,
1722                         0, pix_op,
1723                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
1724         }
1725         break;
1726     case MV_TYPE_8X8:
1727         mx = 0;
1728         my = 0;
1729         if(s->quarter_sample){
1730             for(i=0;i<4;i++) {
1731                 motion_x = s->mv[dir][i][0];
1732                 motion_y = s->mv[dir][i][1];
1733
1734                 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1735                 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1736                 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1737
1738                 /* WARNING: do no forget half pels */
1739                 src_x = clip(src_x, -16, s->width);
1740                 if (src_x == s->width)
1741                     dxy &= ~3;
1742                 src_y = clip(src_y, -16, s->height);
1743                 if (src_y == s->height)
1744                     dxy &= ~12;
1745
1746                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1747                 if(s->flags&CODEC_FLAG_EMU_EDGE){
1748                     if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1749                                           || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1750                         ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1751                         ptr= s->edge_emu_buffer;
1752                     }
1753                 }
1754                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1755                 qpix_op[1][dxy](dest, ptr, s->linesize);
1756
1757                 mx += s->mv[dir][i][0]/2;
1758                 my += s->mv[dir][i][1]/2;
1759             }
1760         }else{
1761             for(i=0;i<4;i++) {
1762                 motion_x = s->mv[dir][i][0];
1763                 motion_y = s->mv[dir][i][1];
1764
1765                 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1766                 src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1767                 src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1768
1769                 /* WARNING: do no forget half pels */
1770                 src_x = clip(src_x, -16, s->width);
1771                 if (src_x == s->width)
1772                     dxy &= ~1;
1773                 src_y = clip(src_y, -16, s->height);
1774                 if (src_y == s->height)
1775                     dxy &= ~2;
1776
1777                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1778                 if(s->flags&CODEC_FLAG_EMU_EDGE){
1779                     if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1780                                           || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1781                         ff_emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1782                         ptr= s->edge_emu_buffer;
1783                     }
1784                 }
1785                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1786                 pix_op[1][dxy](dest, ptr, s->linesize, 8);
1787
1788                 mx += s->mv[dir][i][0];
1789                 my += s->mv[dir][i][1];
1790             }
1791         }
1792
1793         if(s->flags&CODEC_FLAG_GRAY) break;
1794         /* In case of 8X8, we construct a single chroma motion vector
1795            with a special rounding */
1796         mx= ff_h263_round_chroma(mx);
1797         my= ff_h263_round_chroma(my);
1798         dxy = ((my & 1) << 1) | (mx & 1);
1799         mx >>= 1;
1800         my >>= 1;
1801
1802         src_x = mb_x * 8 + mx;
1803         src_y = mb_y * 8 + my;
1804         src_x = clip(src_x, -8, s->width/2);
1805         if (src_x == s->width/2)
1806             dxy &= ~1;
1807         src_y = clip(src_y, -8, s->height/2);
1808         if (src_y == s->height/2)
1809             dxy &= ~2;
1810
1811         offset = (src_y * (s->uvlinesize)) + src_x;
1812         ptr = ref_picture[1] + offset;
1813         if(s->flags&CODEC_FLAG_EMU_EDGE){
1814                 if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1815                                       || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1816                     ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1817                     ptr= s->edge_emu_buffer;
1818                     emu=1;
1819                 }
1820             }
1821         pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1822
1823         ptr = ref_picture[2] + offset;
1824         if(emu){
1825             ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1826             ptr= s->edge_emu_buffer;
1827         }
1828         pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
1829         break;
1830     case MV_TYPE_FIELD:
1831         if (s->picture_structure == PICT_FRAME) {
1832             if(s->quarter_sample){
1833                 /* top field */
1834                 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1835                             ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1836                             1, pix_op, qpix_op,
1837                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
1838                 /* bottom field */
1839                 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1840                             ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1841                             1, pix_op, qpix_op,
1842                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
1843             }else{
1844                 /* top field */
1845                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1846                             ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1847                             1, pix_op,
1848                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
1849                 /* bottom field */
1850                 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1851                             ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1852                             1, pix_op,
1853                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
1854             }
1855         } else {
1856
1857
1858         }
1859         break;
1860     }
1861 }
1862
1863
1864 /* put block[] to dest[] */
1865 static inline void put_dct(MpegEncContext *s,
1866                            DCTELEM *block, int i, UINT8 *dest, int line_size)
1867 {
1868     s->dct_unquantize(s, block, i, s->qscale);
1869     s->idct_put (dest, line_size, block);
1870 }
1871
1872 /* add block[] to dest[] */
1873 static inline void add_dct(MpegEncContext *s,
1874                            DCTELEM *block, int i, UINT8 *dest, int line_size)
1875 {
1876     if (s->block_last_index[i] >= 0) {
1877         s->idct_add (dest, line_size, block);
1878     }
1879 }
1880
1881 static inline void add_dequant_dct(MpegEncContext *s,
1882                            DCTELEM *block, int i, UINT8 *dest, int line_size)
1883 {
1884     if (s->block_last_index[i] >= 0) {
1885         s->dct_unquantize(s, block, i, s->qscale);
1886
1887         s->idct_add (dest, line_size, block);
1888     }
1889 }
1890
1891 /**
1892  * cleans dc, ac, coded_block for the current non intra MB
1893  */
1894 void ff_clean_intra_table_entries(MpegEncContext *s)
1895 {
1896     int wrap = s->block_wrap[0];
1897     int xy = s->block_index[0];
1898
1899     s->dc_val[0][xy           ] =
1900     s->dc_val[0][xy + 1       ] =
1901     s->dc_val[0][xy     + wrap] =
1902     s->dc_val[0][xy + 1 + wrap] = 1024;
1903     /* ac pred */
1904     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(INT16));
1905     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
1906     if (s->msmpeg4_version>=3) {
1907         s->coded_block[xy           ] =
1908         s->coded_block[xy + 1       ] =
1909         s->coded_block[xy     + wrap] =
1910         s->coded_block[xy + 1 + wrap] = 0;
1911     }
1912     /* chroma */
1913     wrap = s->block_wrap[4];
1914     xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
1915     s->dc_val[1][xy] =
1916     s->dc_val[2][xy] = 1024;
1917     /* ac pred */
1918     memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
1919     memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
1920
1921     s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1922 }
1923
1924 /* generic function called after a macroblock has been parsed by the
1925    decoder or after it has been encoded by the encoder.
1926
1927    Important variables used:
1928    s->mb_intra : true if intra macroblock
1929    s->mv_dir   : motion vector direction
1930    s->mv_type  : motion vector type
1931    s->mv       : motion vector
1932    s->interlaced_dct : true if interlaced dct used (mpeg2)
1933  */
1934 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1935 {
1936     int mb_x, mb_y;
1937     const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
1938
1939     mb_x = s->mb_x;
1940     mb_y = s->mb_y;
1941
1942     s->current_picture.qscale_table[mb_xy]= s->qscale;
1943
1944     /* update DC predictors for P macroblocks */
1945     if (!s->mb_intra) {
1946         if (s->h263_pred || s->h263_aic) {
1947             if(s->mbintra_table[mb_xy])
1948                 ff_clean_intra_table_entries(s);
1949         } else {
1950             s->last_dc[0] =
1951             s->last_dc[1] =
1952             s->last_dc[2] = 128 << s->intra_dc_precision;
1953         }
1954     }
1955     else if (s->h263_pred || s->h263_aic)
1956         s->mbintra_table[mb_xy]=1;
1957
1958     /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
1959     if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
1960         //FIXME a lot of thet is only needed for !low_delay
1961         const int wrap = s->block_wrap[0];
1962         const int xy = s->block_index[0];
1963         const int mb_index= s->mb_x + s->mb_y*s->mb_width;
1964         if(s->mv_type == MV_TYPE_8X8){
1965             s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
1966         } else {
1967             int motion_x, motion_y;
1968             if (s->mb_intra) {
1969                 motion_x = 0;
1970                 motion_y = 0;
1971                 if(s->co_located_type_table)
1972                     s->co_located_type_table[mb_index]= 0;
1973             } else if (s->mv_type == MV_TYPE_16X16) {
1974                 motion_x = s->mv[0][0][0];
1975                 motion_y = s->mv[0][0][1];
1976                 if(s->co_located_type_table)
1977                     s->co_located_type_table[mb_index]= 0;
1978             } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1979                 int i;
1980                 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1981                 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1982                 motion_x = (motion_x>>1) | (motion_x&1);
1983                 for(i=0; i<2; i++){
1984                     s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
1985                     s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
1986                     s->field_select_table[mb_index][i]= s->field_select[0][i];
1987                 }
1988                 s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
1989             }
1990             /* no update if 8X8 because it has been done during parsing */
1991             s->motion_val[xy][0] = motion_x;
1992             s->motion_val[xy][1] = motion_y;
1993             s->motion_val[xy + 1][0] = motion_x;
1994             s->motion_val[xy + 1][1] = motion_y;
1995             s->motion_val[xy + wrap][0] = motion_x;
1996             s->motion_val[xy + wrap][1] = motion_y;
1997             s->motion_val[xy + 1 + wrap][0] = motion_x;
1998             s->motion_val[xy + 1 + wrap][1] = motion_y;
1999         }
2000     }
2001
2002     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2003         UINT8 *dest_y, *dest_cb, *dest_cr;
2004         int dct_linesize, dct_offset;
2005         op_pixels_func (*op_pix)[4];
2006         qpel_mc_func (*op_qpix)[16];
2007
2008         /* avoid copy if macroblock skipped in last frame too */
2009         if (s->pict_type != B_TYPE) {
2010             s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2011         }
2012
2013         /* skip only during decoding as we might trash the buffers during encoding a bit */
2014         if(!s->encoding){
2015             UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
2016             const int age= s->current_picture.age;
2017
2018             assert(age);
2019
2020             if (s->mb_skiped) {
2021                 s->mb_skiped= 0;
2022                 assert(s->pict_type!=I_TYPE);
2023
2024                 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2025                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2026
2027                 /* if previous was skipped too, then nothing to do !  */
2028                 if (*mbskip_ptr >= age && s->current_picture.reference){
2029                     return;
2030                 }
2031             } else if(!s->current_picture.reference){
2032                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2033                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2034             } else{
2035                 *mbskip_ptr = 0; /* not skipped */
2036             }
2037         }else
2038             s->mb_skiped= 0;
2039
2040         if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band){
2041             dest_y  = s->current_picture.data[0] + mb_x * 16;
2042             dest_cb = s->current_picture.data[1] + mb_x * 8;
2043             dest_cr = s->current_picture.data[2] + mb_x * 8;
2044         }else{
2045             dest_y  = s->current_picture.data[0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
2046             dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
2047             dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
2048         }
2049
2050         if (s->interlaced_dct) {
2051             dct_linesize = s->linesize * 2;
2052             dct_offset = s->linesize;
2053         } else {
2054             dct_linesize = s->linesize;
2055             dct_offset = s->linesize * 8;
2056         }
2057
2058         if (!s->mb_intra) {
2059             /* motion handling */
2060             /* decoding or more than one mb_type (MC was allready done otherwise) */
2061             if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
2062                 if ((!s->no_rounding) || s->pict_type==B_TYPE){
2063                     op_pix = s->dsp.put_pixels_tab;
2064                     op_qpix= s->dsp.put_qpel_pixels_tab;
2065                 }else{
2066                     op_pix = s->dsp.put_no_rnd_pixels_tab;
2067                     op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2068                 }
2069
2070                 if (s->mv_dir & MV_DIR_FORWARD) {
2071                     MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2072                     op_pix = s->dsp.avg_pixels_tab;
2073                     op_qpix= s->dsp.avg_qpel_pixels_tab;
2074                 }
2075                 if (s->mv_dir & MV_DIR_BACKWARD) {
2076                     MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2077                 }
2078             }
2079
2080             /* skip dequant / idct if we are really late ;) */
2081             if(s->hurry_up>1) return;
2082
2083             /* add dct residue */
2084             if(s->encoding || !(   s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO
2085                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2086                 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2087                 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2088                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2089                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2090
2091                 if(!(s->flags&CODEC_FLAG_GRAY)){
2092                     add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2093                     add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
2094                 }
2095             } else if(s->codec_id != CODEC_ID_WMV2){
2096                 add_dct(s, block[0], 0, dest_y, dct_linesize);
2097                 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2098                 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2099                 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2100
2101                 if(!(s->flags&CODEC_FLAG_GRAY)){
2102                     add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2103                     add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
2104                 }
2105             } else{
2106                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2107             }
2108         } else {
2109             /* dct only in intra block */
2110             if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2111                 put_dct(s, block[0], 0, dest_y, dct_linesize);
2112                 put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2113                 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2114                 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2115
2116                 if(!(s->flags&CODEC_FLAG_GRAY)){
2117                     put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2118                     put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
2119                 }
2120             }else{
2121                 s->idct_put(dest_y                 , dct_linesize, block[0]);
2122                 s->idct_put(dest_y              + 8, dct_linesize, block[1]);
2123                 s->idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
2124                 s->idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2125
2126                 if(!(s->flags&CODEC_FLAG_GRAY)){
2127                     s->idct_put(dest_cb, s->uvlinesize, block[4]);
2128                     s->idct_put(dest_cr, s->uvlinesize, block[5]);
2129                 }
2130             }
2131         }
2132     }
2133 }
2134
2135 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2136 {
2137     static const char tab[64]=
2138         {3,2,2,1,1,1,1,1,
2139          1,1,1,1,1,1,1,1,
2140          1,1,1,1,1,1,1,1,
2141          0,0,0,0,0,0,0,0,
2142          0,0,0,0,0,0,0,0,
2143          0,0,0,0,0,0,0,0,
2144          0,0,0,0,0,0,0,0,
2145          0,0,0,0,0,0,0,0};
2146     int score=0;
2147     int run=0;
2148     int i;
2149     DCTELEM *block= s->block[n];
2150     const int last_index= s->block_last_index[n];
2151     int skip_dc;
2152
2153     if(threshold<0){
2154         skip_dc=0;
2155         threshold= -threshold;
2156     }else
2157         skip_dc=1;
2158
2159     /* are all which we could set to zero are allready zero? */
2160     if(last_index<=skip_dc - 1) return;
2161
2162     for(i=0; i<=last_index; i++){
2163         const int j = s->intra_scantable.permutated[i];
2164         const int level = ABS(block[j]);
2165         if(level==1){
2166             if(skip_dc && i==0) continue;
2167             score+= tab[run];
2168             run=0;
2169         }else if(level>1){
2170             return;
2171         }else{
2172             run++;
2173         }
2174     }
2175     if(score >= threshold) return;
2176     for(i=skip_dc; i<=last_index; i++){
2177         const int j = s->intra_scantable.permutated[i];
2178         block[j]=0;
2179     }
2180     if(block[0]) s->block_last_index[n]= 0;
2181     else         s->block_last_index[n]= -1;
2182 }
2183
2184 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2185 {
2186     int i;
2187     const int maxlevel= s->max_qcoeff;
2188     const int minlevel= s->min_qcoeff;
2189
2190     if(s->mb_intra){
2191         i=1; //skip clipping of intra dc
2192     }else
2193         i=0;
2194
2195     for(;i<=last_index; i++){
2196         const int j= s->intra_scantable.permutated[i];
2197         int level = block[j];
2198
2199         if     (level>maxlevel) level=maxlevel;
2200         else if(level<minlevel) level=minlevel;
2201         block[j]= level;
2202     }
2203 }
2204
2205 static inline void requantize_coeffs(MpegEncContext *s, DCTELEM block[64], int oldq, int newq, int n)
2206 {
2207     int i;
2208
2209     if(s->mb_intra){
2210         i=1; //skip clipping of intra dc
2211          //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
2212     }else
2213         i=0;
2214
2215     for(;i<=s->block_last_index[n]; i++){
2216         const int j = s->intra_scantable.permutated[i];
2217         int level = block[j];
2218
2219         block[j]= ROUNDED_DIV(level*oldq, newq);
2220     }
2221
2222     for(i=s->block_last_index[n]; i>=0; i--){
2223         const int j = s->intra_scantable.permutated[i];
2224         if(block[j]) break;
2225     }
2226     s->block_last_index[n]= i;
2227 }
2228
2229 static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
2230 {
2231     int i,n, newq;
2232     const int maxlevel= s->max_qcoeff;
2233     const int minlevel= s->min_qcoeff;
2234     int largest=0, smallest=0;
2235
2236     assert(s->adaptive_quant);
2237
2238     for(n=0; n<6; n++){
2239         if(s->mb_intra){
2240             i=1; //skip clipping of intra dc
2241              //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
2242         }else
2243             i=0;
2244
2245         for(;i<=s->block_last_index[n]; i++){
2246             const int j = s->intra_scantable.permutated[i];
2247             int level = block[n][j];
2248             if(largest  < level) largest = level;
2249             if(smallest > level) smallest= level;
2250         }
2251     }
2252
2253     for(newq=s->qscale+1; newq<32; newq++){
2254         if(   ROUNDED_DIV(smallest*s->qscale, newq) >= minlevel
2255            && ROUNDED_DIV(largest *s->qscale, newq) <= maxlevel)
2256             break;
2257     }
2258
2259     if(s->out_format==FMT_H263){
2260         /* h263 like formats cannot change qscale by more than 2 easiely */
2261         if(s->avctx->qmin + 2 < newq)
2262             newq= s->avctx->qmin + 2;
2263     }
2264
2265     for(n=0; n<6; n++){
2266         requantize_coeffs(s, block[n], s->qscale, newq, n);
2267         clip_coeffs(s, block[n], s->block_last_index[n]);
2268     }
2269
2270     s->dquant+= newq - s->qscale;
2271     s->qscale= newq;
2272 }
2273 #if 0
2274 static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
2275     int score=0;
2276     int x,y;
2277
2278     for(y=0; y<7; y++){
2279         for(x=0; x<16; x+=4){
2280             score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride])
2281                    +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2282         }
2283         s+= stride;
2284     }
2285
2286     return score;
2287 }
2288
2289 static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
2290     int score=0;
2291     int x,y;
2292
2293     for(y=0; y<7; y++){
2294         for(x=0; x<16; x++){
2295             score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2296         }
2297         s1+= stride;
2298         s2+= stride;
2299     }
2300
2301     return score;
2302 }
2303 #else
2304 #define SQ(a) ((a)*(a))
2305
2306 static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
2307     int score=0;
2308     int x,y;
2309
2310     for(y=0; y<7; y++){
2311         for(x=0; x<16; x+=4){
2312             score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride])
2313                    +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2314         }
2315         s+= stride;
2316     }
2317
2318     return score;
2319 }
2320
2321 static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
2322     int score=0;
2323     int x,y;
2324
2325     for(y=0; y<7; y++){
2326         for(x=0; x<16; x++){
2327             score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2328         }
2329         s1+= stride;
2330         s2+= stride;
2331     }
2332
2333     return score;
2334 }
2335
2336 #endif
2337
2338 void ff_draw_horiz_band(MpegEncContext *s){
2339     if (    s->avctx->draw_horiz_band
2340         && (s->last_picture.data[0] || s->low_delay) ) {
2341         UINT8 *src_ptr[3];
2342         int y, h, offset;
2343         y = s->mb_y * 16;
2344         h = s->height - y;
2345         if (h > 16)
2346             h = 16;
2347
2348         if(s->pict_type==B_TYPE)
2349             offset = 0;
2350         else
2351             offset = y * s->linesize;
2352
2353         if(s->pict_type==B_TYPE || s->low_delay){
2354             src_ptr[0] = s->current_picture.data[0] + offset;
2355             src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2356             src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2357         } else {
2358             src_ptr[0] = s->last_picture.data[0] + offset;
2359             src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2360             src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2361         }
2362         emms_c();
2363
2364         s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2365                                y, s->width, h);
2366     }
2367 }
2368
2369 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2370 {
2371     const int mb_x= s->mb_x;
2372     const int mb_y= s->mb_y;
2373     int i;
2374     int skip_dct[6];
2375     int dct_offset   = s->linesize*8; //default for progressive frames
2376
2377     for(i=0; i<6; i++) skip_dct[i]=0;
2378
2379     if(s->adaptive_quant){
2380         s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
2381
2382         if(s->out_format==FMT_H263){
2383             if     (s->dquant> 2) s->dquant= 2;
2384             else if(s->dquant<-2) s->dquant=-2;
2385         }
2386
2387         if(s->codec_id==CODEC_ID_MPEG4){
2388             if(!s->mb_intra){
2389                 assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2390
2391                 if(s->mv_dir&MV_DIRECT)
2392                     s->dquant=0;
2393             }
2394         }
2395         s->qscale+= s->dquant;
2396         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2397         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2398     }
2399
2400     if (s->mb_intra) {
2401         UINT8 *ptr;
2402         int wrap_y;
2403         int emu=0;
2404
2405         wrap_y = s->linesize;
2406         ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2407
2408         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2409             ff_emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2410             ptr= s->edge_emu_buffer;
2411             emu=1;
2412         }
2413
2414         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2415             int progressive_score, interlaced_score;
2416
2417             progressive_score= pix_vcmp16x8(ptr, wrap_y  ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2418             interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y  , wrap_y*2);
2419
2420             if(progressive_score > interlaced_score + 100){
2421                 s->interlaced_dct=1;
2422
2423                 dct_offset= wrap_y;
2424                 wrap_y<<=1;
2425             }else
2426                 s->interlaced_dct=0;
2427         }
2428
2429         s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
2430         s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
2431         s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
2432         s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2433
2434         if(s->flags&CODEC_FLAG_GRAY){
2435             skip_dct[4]= 1;
2436             skip_dct[5]= 1;
2437         }else{
2438             int wrap_c = s->uvlinesize;
2439             ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2440             if(emu){
2441                 ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2442                 ptr= s->edge_emu_buffer;
2443             }
2444             s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2445
2446             ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2447             if(emu){
2448                 ff_emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2449                 ptr= s->edge_emu_buffer;
2450             }
2451             s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2452         }
2453     }else{
2454         op_pixels_func (*op_pix)[4];
2455         qpel_mc_func (*op_qpix)[16];
2456         UINT8 *dest_y, *dest_cb, *dest_cr;
2457         UINT8 *ptr_y, *ptr_cb, *ptr_cr;
2458         int wrap_y, wrap_c;
2459         int emu=0;
2460
2461         dest_y  = s->current_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
2462         dest_cb = s->current_picture.data[1] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2463         dest_cr = s->current_picture.data[2] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
2464         wrap_y = s->linesize;
2465         wrap_c = s->uvlinesize;
2466         ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2467         ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2468         ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2469
2470         if ((!s->no_rounding) || s->pict_type==B_TYPE){
2471             op_pix = s->dsp.put_pixels_tab;
2472             op_qpix= s->dsp.put_qpel_pixels_tab;
2473         }else{
2474             op_pix = s->dsp.put_no_rnd_pixels_tab;
2475             op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2476         }
2477
2478         if (s->mv_dir & MV_DIR_FORWARD) {
2479             MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2480             op_pix = s->dsp.avg_pixels_tab;
2481             op_qpix= s->dsp.avg_qpel_pixels_tab;
2482         }
2483         if (s->mv_dir & MV_DIR_BACKWARD) {
2484             MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2485         }
2486
2487         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2488             ff_emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2489             ptr_y= s->edge_emu_buffer;
2490             emu=1;
2491         }
2492
2493         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2494             int progressive_score, interlaced_score;
2495
2496             progressive_score= pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y  )
2497                              + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y  );
2498             interlaced_score = pix_diff_vcmp16x8(ptr_y           , dest_y           , wrap_y*2)
2499                              + pix_diff_vcmp16x8(ptr_y + wrap_y  , dest_y + wrap_y  , wrap_y*2);
2500
2501             if(progressive_score > interlaced_score + 600){
2502                 s->interlaced_dct=1;
2503
2504                 dct_offset= wrap_y;
2505                 wrap_y<<=1;
2506             }else
2507                 s->interlaced_dct=0;
2508         }
2509
2510         s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
2511         s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
2512         s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
2513         s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2514
2515         if(s->flags&CODEC_FLAG_GRAY){
2516             skip_dct[4]= 1;
2517             skip_dct[5]= 1;
2518         }else{
2519             if(emu){
2520                 ff_emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2521                 ptr_cb= s->edge_emu_buffer;
2522             }
2523             s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2524             if(emu){
2525                 ff_emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2526                 ptr_cr= s->edge_emu_buffer;
2527             }
2528             s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2529         }
2530         /* pre quantization */
2531         if(s->current_picture.mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
2532             //FIXME optimize
2533             if(s->dsp.pix_abs8x8(ptr_y               , dest_y               , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2534             if(s->dsp.pix_abs8x8(ptr_y            + 8, dest_y            + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2535             if(s->dsp.pix_abs8x8(ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2536             if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2537             if(s->dsp.pix_abs8x8(ptr_cb              , dest_cb              , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2538             if(s->dsp.pix_abs8x8(ptr_cr              , dest_cr              , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2539 #if 0
2540 {
2541  static int stat[7];
2542  int num=0;
2543  for(i=0; i<6; i++)
2544   if(skip_dct[i]) num++;
2545  stat[num]++;
2546
2547  if(s->mb_x==0 && s->mb_y==0){
2548   for(i=0; i<7; i++){
2549    printf("%6d %1d\n", stat[i], i);
2550   }
2551  }
2552 }
2553 #endif
2554         }
2555
2556     }
2557
2558 #if 0
2559             {
2560                 float adap_parm;
2561
2562                 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
2563                             ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2564
2565                 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d",
2566                         (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P',
2567                         s->qscale, adap_parm, s->qscale*adap_parm,
2568                         s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
2569             }
2570 #endif
2571     /* DCT & quantize */
2572     if(s->out_format==FMT_MJPEG){
2573         for(i=0;i<6;i++) {
2574             int overflow;
2575             s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2576             if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2577         }
2578     }else{
2579         for(i=0;i<6;i++) {
2580             if(!skip_dct[i]){
2581                 int overflow;
2582                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2583             // FIXME we could decide to change to quantizer instead of clipping
2584             // JS: I don't think that would be a good idea it could lower quality instead
2585             //     of improve it. Just INTRADC clipping deserves changes in quantizer
2586                 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2587             }else
2588                 s->block_last_index[i]= -1;
2589         }
2590         if(s->luma_elim_threshold && !s->mb_intra)
2591             for(i=0; i<4; i++)
2592                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2593         if(s->chroma_elim_threshold && !s->mb_intra)
2594             for(i=4; i<6; i++)
2595                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2596     }
2597
2598     if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2599         s->block_last_index[4]=
2600         s->block_last_index[5]= 0;
2601         s->block[4][0]=
2602         s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
2603     }
2604
2605 #ifdef CONFIG_ENCODERS
2606     /* huffman encode */
2607     switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2608     case CODEC_ID_MPEG1VIDEO:
2609         mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2610     case CODEC_ID_MPEG4:
2611         mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2612     case CODEC_ID_MSMPEG4V2:
2613     case CODEC_ID_MSMPEG4V3:
2614     case CODEC_ID_WMV1:
2615         msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2616     case CODEC_ID_WMV2:
2617          ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
2618     case CODEC_ID_MJPEG:
2619         mjpeg_encode_mb(s, s->block); break;
2620     case CODEC_ID_H263:
2621     case CODEC_ID_H263P:
2622     case CODEC_ID_RV10:
2623         h263_encode_mb(s, s->block, motion_x, motion_y); break;
2624     default:
2625         assert(0);
2626     }
2627 #endif
2628 }
2629
2630 void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
2631 {
2632     int bytes= length>>4;
2633     int bits= length&15;
2634     int i;
2635
2636     if(length==0) return;
2637
2638     for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2639     put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2640 }
2641
2642 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2643     int i;
2644
2645     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2646
2647     /* mpeg1 */
2648     d->mb_incr= s->mb_incr;
2649     for(i=0; i<3; i++)
2650         d->last_dc[i]= s->last_dc[i];
2651
2652     /* statistics */
2653     d->mv_bits= s->mv_bits;
2654     d->i_tex_bits= s->i_tex_bits;
2655     d->p_tex_bits= s->p_tex_bits;
2656     d->i_count= s->i_count;
2657     d->f_count= s->f_count;
2658     d->b_count= s->b_count;
2659     d->skip_count= s->skip_count;
2660     d->misc_bits= s->misc_bits;
2661     d->last_bits= 0;
2662
2663     d->mb_skiped= s->mb_skiped;
2664     d->qscale= s->qscale;
2665 }
2666
2667 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2668     int i;
2669
2670     memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2671     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2672
2673     /* mpeg1 */
2674     d->mb_incr= s->mb_incr;
2675     for(i=0; i<3; i++)
2676         d->last_dc[i]= s->last_dc[i];
2677
2678     /* statistics */
2679     d->mv_bits= s->mv_bits;
2680     d->i_tex_bits= s->i_tex_bits;
2681     d->p_tex_bits= s->p_tex_bits;
2682     d->i_count= s->i_count;
2683     d->f_count= s->f_count;
2684     d->b_count= s->b_count;
2685     d->skip_count= s->skip_count;
2686     d->misc_bits= s->misc_bits;
2687
2688     d->mb_intra= s->mb_intra;
2689     d->mb_skiped= s->mb_skiped;
2690     d->mv_type= s->mv_type;
2691     d->mv_dir= s->mv_dir;
2692     d->pb= s->pb;
2693     if(s->data_partitioning){
2694         d->pb2= s->pb2;
2695         d->tex_pb= s->tex_pb;
2696     }
2697     d->block= s->block;
2698     for(i=0; i<6; i++)
2699         d->block_last_index[i]= s->block_last_index[i];
2700     d->interlaced_dct= s->interlaced_dct;
2701     d->qscale= s->qscale;
2702 }
2703
2704 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2705                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2706                            int *dmin, int *next_block, int motion_x, int motion_y)
2707 {
2708     int bits_count;
2709
2710     copy_context_before_encode(s, backup, type);
2711
2712     s->block= s->blocks[*next_block];
2713     s->pb= pb[*next_block];
2714     if(s->data_partitioning){
2715         s->pb2   = pb2   [*next_block];
2716         s->tex_pb= tex_pb[*next_block];
2717     }
2718
2719     encode_mb(s, motion_x, motion_y);
2720
2721     bits_count= get_bit_count(&s->pb);
2722     if(s->data_partitioning){
2723         bits_count+= get_bit_count(&s->pb2);
2724         bits_count+= get_bit_count(&s->tex_pb);
2725     }
2726
2727     if(bits_count<*dmin){
2728         *dmin= bits_count;
2729         *next_block^=1;
2730
2731         copy_context_after_encode(best, s, type);
2732     }
2733 }
2734
2735 static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2736     uint32_t *sq = squareTbl + 256;
2737     int acc=0;
2738     int x,y;
2739
2740     if(w==16 && h==16)
2741         return s->dsp.sse[0](NULL, src1, src2, stride);
2742     else if(w==8 && h==8)
2743         return s->dsp.sse[1](NULL, src1, src2, stride);
2744
2745     for(y=0; y<h; y++){
2746         for(x=0; x<w; x++){
2747             acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2748         }
2749     }
2750
2751     assert(acc>=0);
2752
2753     return acc;
2754 }
2755
2756 static void encode_picture(MpegEncContext *s, int picture_number)
2757 {
2758     int mb_x, mb_y, pdif = 0;
2759     int i;
2760     int bits;
2761     MpegEncContext best_s, backup_s;
2762     UINT8 bit_buf[2][3000];
2763     UINT8 bit_buf2[2][3000];
2764     UINT8 bit_buf_tex[2][3000];
2765     PutBitContext pb[2], pb2[2], tex_pb[2];
2766
2767     for(i=0; i<2; i++){
2768         init_put_bits(&pb    [i], bit_buf    [i], 3000, NULL, NULL);
2769         init_put_bits(&pb2   [i], bit_buf2   [i], 3000, NULL, NULL);
2770         init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2771     }
2772
2773     s->picture_number = picture_number;
2774
2775     s->block_wrap[0]=
2776     s->block_wrap[1]=
2777     s->block_wrap[2]=
2778     s->block_wrap[3]= s->mb_width*2 + 2;
2779     s->block_wrap[4]=
2780     s->block_wrap[5]= s->mb_width + 2;
2781
2782     /* Reset the average MB variance */
2783     s->current_picture.mb_var_sum = 0;
2784     s->current_picture.mc_mb_var_sum = 0;
2785
2786     /* we need to initialize some time vars before we can encode b-frames */
2787     if (s->h263_pred && !s->h263_msmpeg4)
2788         ff_set_mpeg4_time(s, s->picture_number);
2789
2790     s->scene_change_score=0;
2791
2792     s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2793
2794     if(s->msmpeg4_version){
2795         if(s->pict_type==I_TYPE)
2796             s->no_rounding=1;
2797         else if(s->flipflop_rounding)
2798             s->no_rounding ^= 1;
2799     }else if(s->out_format == FMT_H263){
2800         if(s->pict_type==I_TYPE)
2801             s->no_rounding=0;
2802         else if(s->pict_type!=B_TYPE)
2803             s->no_rounding ^= 1;
2804     }
2805     /* Estimate motion for every MB */
2806     s->mb_intra=0; //for the rate distoration & bit compare functions
2807     if(s->pict_type != I_TYPE){
2808         if(s->pict_type != B_TYPE){
2809             if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
2810                 s->me.pre_pass=1;
2811                 s->me.dia_size= s->avctx->pre_dia_size;
2812
2813                 for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
2814                     for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
2815                         s->mb_x = mb_x;
2816                         s->mb_y = mb_y;
2817                         ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
2818                     }
2819                 }
2820                 s->me.pre_pass=0;
2821             }
2822         }
2823
2824         s->me.dia_size= s->avctx->dia_size;
2825         for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2826             s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2827             s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2828             s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2829             s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2830             for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2831                 s->mb_x = mb_x;
2832                 s->mb_y = mb_y;
2833                 s->block_index[0]+=2;
2834                 s->block_index[1]+=2;
2835                 s->block_index[2]+=2;
2836                 s->block_index[3]+=2;
2837
2838                 /* compute motion vector & mb_type and store in context */
2839                 if(s->pict_type==B_TYPE)
2840                     ff_estimate_b_frame_motion(s, mb_x, mb_y);
2841                 else
2842                     ff_estimate_p_frame_motion(s, mb_x, mb_y);
2843             }
2844         }
2845     }else /* if(s->pict_type == I_TYPE) */{
2846         /* I-Frame */
2847         //FIXME do we need to zero them?
2848         memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2849         memset(s->p_mv_table   , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
2850         memset(s->mb_type      , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2851
2852         if(!s->fixed_qscale){
2853             /* finding spatial complexity for I-frame rate control */
2854             for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2855                 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2856                     int xx = mb_x * 16;
2857                     int yy = mb_y * 16;
2858                     uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
2859                     int varc;
2860                     int sum = s->dsp.pix_sum(pix, s->linesize);
2861
2862                     varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
2863
2864                     s->current_picture.mb_var [s->mb_width * mb_y + mb_x] = varc;
2865                     s->current_picture.mb_mean[s->mb_width * mb_y + mb_x] = (sum+128)>>8;
2866                     s->current_picture.mb_var_sum    += varc;
2867                 }
2868             }
2869         }
2870     }
2871     emms_c();
2872
2873     if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2874         s->pict_type= I_TYPE;
2875         memset(s->mb_type   , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2876 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
2877     }
2878
2879     if(s->pict_type==P_TYPE || s->pict_type==S_TYPE)
2880         s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2881         ff_fix_long_p_mvs(s);
2882     if(s->pict_type==B_TYPE){
2883         s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2884         s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2885
2886         ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2887         ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2888         ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2889         ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2890     }
2891
2892     if (s->fixed_qscale)
2893         s->frame_qscale = s->current_picture.quality;
2894     else
2895         s->frame_qscale = ff_rate_estimate_qscale(s);
2896
2897     if(s->adaptive_quant){
2898         switch(s->codec_id){
2899         case CODEC_ID_MPEG4:
2900             ff_clean_mpeg4_qscales(s);
2901             break;
2902         case CODEC_ID_H263:
2903         case CODEC_ID_H263P:
2904             ff_clean_h263_qscales(s);
2905             break;
2906         }
2907
2908         s->qscale= s->current_picture.qscale_table[0];
2909     }else
2910         s->qscale= (int)(s->frame_qscale + 0.5);
2911
2912     if (s->out_format == FMT_MJPEG) {
2913         /* for mjpeg, we do include qscale in the matrix */
2914         s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2915         for(i=1;i<64;i++){
2916             int j= s->idct_permutation[i];
2917
2918             s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2919         }
2920         convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
2921                        s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
2922     }
2923
2924     //FIXME var duplication
2925     s->current_picture.key_frame= s->pict_type == I_TYPE;
2926     s->current_picture.pict_type= s->pict_type;
2927
2928     if(s->current_picture.key_frame)
2929         s->picture_in_gop_number=0;
2930
2931     s->last_bits= get_bit_count(&s->pb);
2932     switch(s->out_format) {
2933     case FMT_MJPEG:
2934         mjpeg_picture_header(s);
2935         break;
2936     case FMT_H263:
2937         if (s->codec_id == CODEC_ID_WMV2)
2938             ff_wmv2_encode_picture_header(s, picture_number);
2939         else if (s->h263_msmpeg4)
2940             msmpeg4_encode_picture_header(s, picture_number);
2941         else if (s->h263_pred)
2942             mpeg4_encode_picture_header(s, picture_number);
2943         else if (s->h263_rv10)
2944             rv10_encode_picture_header(s, picture_number);
2945         else
2946             h263_encode_picture_header(s, picture_number);
2947         break;
2948     case FMT_MPEG1:
2949         mpeg1_encode_picture_header(s, picture_number);
2950         break;
2951     }
2952     bits= get_bit_count(&s->pb);
2953     s->header_bits= bits - s->last_bits;
2954     s->last_bits= bits;
2955     s->mv_bits=0;
2956     s->misc_bits=0;
2957     s->i_tex_bits=0;
2958     s->p_tex_bits=0;
2959     s->i_count=0;
2960     s->f_count=0;
2961     s->b_count=0;
2962     s->skip_count=0;
2963
2964     for(i=0; i<3; i++){
2965         /* init last dc values */
2966         /* note: quant matrix value (8) is implied here */
2967         s->last_dc[i] = 128;
2968
2969         s->current_picture.error[i] = 0;
2970     }
2971     s->mb_incr = 1;
2972     s->last_mv[0][0][0] = 0;
2973     s->last_mv[0][0][1] = 0;
2974
2975     if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
2976         s->gob_index = ff_h263_get_gob_height(s);
2977
2978     if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
2979         ff_mpeg4_init_partitions(s);
2980
2981     s->resync_mb_x=0;
2982     s->resync_mb_y=0;
2983     s->first_slice_line = 1;
2984     s->ptr_lastgob = s->pb.buf;
2985     s->ptr_last_mb_line = s->pb.buf;
2986     for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2987         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2988         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2989
2990         s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2991         s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2992         s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2993         s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2994         s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
2995         s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
2996         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2997             int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
2998             const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
2999 //            int d;
3000             int dmin=10000000;
3001
3002             s->mb_x = mb_x;
3003             s->mb_y = mb_y;
3004             s->block_index[0]+=2;
3005             s->block_index[1]+=2;
3006             s->block_index[2]+=2;
3007             s->block_index[3]+=2;
3008             s->block_index[4]++;
3009             s->block_index[5]++;
3010
3011             /* write gob / video packet header  */
3012             if(s->rtp_mode){
3013                 int current_packet_size, is_gob_start;
3014
3015                 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3016                 is_gob_start=0;
3017
3018                 if(s->codec_id==CODEC_ID_MPEG4){
3019                     if(current_packet_size + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size
3020                        && s->mb_y + s->mb_x>0){
3021
3022                         if(s->partitioned_frame){
3023                             ff_mpeg4_merge_partitions(s);
3024                             ff_mpeg4_init_partitions(s);
3025                         }
3026                         ff_mpeg4_encode_video_packet_header(s);
3027
3028                         if(s->flags&CODEC_FLAG_PASS1){
3029                             int bits= get_bit_count(&s->pb);
3030                             s->misc_bits+= bits - s->last_bits;
3031                             s->last_bits= bits;
3032                         }
3033                         ff_mpeg4_clean_buffers(s);
3034                         is_gob_start=1;
3035                     }
3036                 }else{
3037                     if(current_packet_size + s->mb_line_avgsize*s->gob_index >= s->rtp_payload_size
3038                        && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3039
3040                         h263_encode_gob_header(s, mb_y);
3041                         is_gob_start=1;
3042                     }
3043                 }
3044
3045                 if(is_gob_start){
3046                     s->ptr_lastgob = pbBufPtr(&s->pb);
3047                     s->first_slice_line=1;
3048                     s->resync_mb_x=mb_x;
3049                     s->resync_mb_y=mb_y;
3050                 }
3051             }
3052
3053             if(  (s->resync_mb_x   == s->mb_x)
3054                && s->resync_mb_y+1 == s->mb_y){
3055                 s->first_slice_line=0;
3056             }
3057
3058             if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3059                 int next_block=0;
3060                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3061
3062                 copy_context_before_encode(&backup_s, s, -1);
3063                 backup_s.pb= s->pb;
3064                 best_s.data_partitioning= s->data_partitioning;
3065                 best_s.partitioned_frame= s->partitioned_frame;
3066                 if(s->data_partitioning){
3067                     backup_s.pb2= s->pb2;
3068                     backup_s.tex_pb= s->tex_pb;
3069                 }
3070
3071                 if(mb_type&MB_TYPE_INTER){
3072                     s->mv_dir = MV_DIR_FORWARD;
3073                     s->mv_type = MV_TYPE_16X16;
3074                     s->mb_intra= 0;
3075                     s->mv[0][0][0] = s->p_mv_table[xy][0];
3076                     s->mv[0][0][1] = s->p_mv_table[xy][1];
3077                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,
3078                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3079                 }
3080                 if(mb_type&MB_TYPE_INTER4V){
3081                     s->mv_dir = MV_DIR_FORWARD;
3082                     s->mv_type = MV_TYPE_8X8;
3083                     s->mb_intra= 0;
3084                     for(i=0; i<4; i++){
3085                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3086                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3087                     }
3088                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,
3089                                  &dmin, &next_block, 0, 0);
3090                 }
3091                 if(mb_type&MB_TYPE_FORWARD){
3092                     s->mv_dir = MV_DIR_FORWARD;
3093                     s->mv_type = MV_TYPE_16X16;
3094                     s->mb_intra= 0;
3095                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3096                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3097                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,
3098                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3099                 }
3100                 if(mb_type&MB_TYPE_BACKWARD){
3101                     s->mv_dir = MV_DIR_BACKWARD;
3102                     s->mv_type = MV_TYPE_16X16;
3103                     s->mb_intra= 0;
3104                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3105                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3106                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3107                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3108                 }
3109                 if(mb_type&MB_TYPE_BIDIR){
3110                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3111                     s->mv_type = MV_TYPE_16X16;
3112                     s->mb_intra= 0;
3113                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3114                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3115                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3116                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3117                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,
3118                                  &dmin, &next_block, 0, 0);
3119                 }
3120                 if(mb_type&MB_TYPE_DIRECT){
3121                     int mx= s->b_direct_mv_table[xy][0];
3122                     int my= s->b_direct_mv_table[xy][1];
3123
3124                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3125                     s->mb_intra= 0;
3126                     ff_mpeg4_set_direct_mv(s, mx, my);
3127                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
3128                                  &dmin, &next_block, mx, my);
3129                 }
3130                 if(mb_type&MB_TYPE_INTRA){
3131                     s->mv_dir = MV_DIR_FORWARD;
3132                     s->mv_type = MV_TYPE_16X16;
3133                     s->mb_intra= 1;
3134                     s->mv[0][0][0] = 0;
3135                     s->mv[0][0][1] = 0;
3136                     encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
3137                                  &dmin, &next_block, 0, 0);
3138                     /* force cleaning of ac/dc pred stuff if needed ... */
3139                     if(s->h263_pred || s->h263_aic)
3140                         s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
3141                 }
3142                 copy_context_after_encode(s, &best_s, -1);
3143
3144                 pb_bits_count= get_bit_count(&s->pb);
3145                 flush_put_bits(&s->pb);
3146                 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3147                 s->pb= backup_s.pb;
3148
3149                 if(s->data_partitioning){
3150                     pb2_bits_count= get_bit_count(&s->pb2);
3151                     flush_put_bits(&s->pb2);
3152                     ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3153                     s->pb2= backup_s.pb2;
3154
3155                     tex_pb_bits_count= get_bit_count(&s->tex_pb);
3156                     flush_put_bits(&s->tex_pb);
3157                     ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3158                     s->tex_pb= backup_s.tex_pb;
3159                 }
3160                 s->last_bits= get_bit_count(&s->pb);
3161             } else {
3162                 int motion_x, motion_y;
3163                 int intra_score;
3164                 int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_width];
3165
3166               if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
3167                 /* get luma score */
3168                 if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3169                     intra_score= (s->current_picture.mb_var[mb_x + mb_y*s->mb_width]<<8) - 500; //FIXME dont scale it down so we dont have to fix it
3170                 }else{
3171                     uint8_t *dest_y;
3172
3173                     int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_width]; //FIXME
3174                     mean*= 0x01010101;
3175
3176                     dest_y  = s->new_picture.data[0] + (mb_y * 16 * s->linesize    ) + mb_x * 16;
3177
3178                     for(i=0; i<16; i++){
3179                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3180                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3181                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3182                         *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3183                     }
3184
3185                     s->mb_intra=1;
3186                     intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3187
3188 /*                    printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8,
3189                         s->current_picture.mb_var[mb_x + mb_y*s->mb_width],
3190                         s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_width]);*/
3191                 }
3192
3193                 /* get chroma score */
3194                 if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3195                     int i;
3196
3197                     s->mb_intra=1;
3198                     for(i=1; i<3; i++){
3199                         uint8_t *dest_c;
3200                         int mean;
3201
3202                         if(s->out_format == FMT_H263){
3203                             mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3204                         }else{
3205                             mean= (s->last_dc[i] + 4)>>3;
3206                         }
3207                         dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
3208
3209                         mean*= 0x01010101;
3210                         for(i=0; i<8; i++){
3211                             *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3212                             *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3213                         }
3214
3215                         intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3216                     }
3217                 }
3218
3219                 /* bias */
3220                 switch(s->avctx->mb_cmp&0xFF){
3221                 default:
3222                 case FF_CMP_SAD:
3223                     intra_score+= 32*s->qscale;
3224                     break;
3225                 case FF_CMP_SSE:
3226                     intra_score+= 24*s->qscale*s->qscale;
3227                     break;
3228                 case FF_CMP_SATD:
3229                     intra_score+= 96*s->qscale;
3230                     break;
3231                 case FF_CMP_DCT:
3232                     intra_score+= 48*s->qscale;
3233                     break;
3234                 case FF_CMP_BIT:
3235                     intra_score+= 16;
3236                     break;
3237                 case FF_CMP_PSNR:
3238                 case FF_CMP_RD:
3239                     intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3240                     break;
3241                 }
3242
3243                 if(intra_score < inter_score)
3244                     mb_type= MB_TYPE_INTRA;
3245               }
3246
3247                 s->mv_type=MV_TYPE_16X16;
3248                 // only one MB-Type possible
3249
3250                 switch(mb_type){
3251                 case MB_TYPE_INTRA:
3252                     s->mv_dir = MV_DIR_FORWARD;
3253                     s->mb_intra= 1;
3254                     motion_x= s->mv[0][0][0] = 0;
3255                     motion_y= s->mv[0][0][1] = 0;
3256                     break;
3257                 case MB_TYPE_INTER:
3258                     s->mv_dir = MV_DIR_FORWARD;
3259                     s->mb_intra= 0;
3260                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3261                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3262                     break;
3263                 case MB_TYPE_INTER4V:
3264                     s->mv_dir = MV_DIR_FORWARD;
3265                     s->mv_type = MV_TYPE_8X8;
3266                     s->mb_intra= 0;
3267                     for(i=0; i<4; i++){
3268                         s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3269                         s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3270                     }
3271                     motion_x= motion_y= 0;
3272                     break;
3273                 case MB_TYPE_DIRECT:
3274                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3275                     s->mb_intra= 0;
3276                     motion_x=s->b_direct_mv_table[xy][0];
3277                     motion_y=s->b_direct_mv_table[xy][1];
3278                     ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3279                     break;
3280                 case MB_TYPE_BIDIR:
3281                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3282                     s->mb_intra= 0;
3283                     motion_x=0;
3284                     motion_y=0;
3285                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3286                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3287                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3288                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3289                     break;
3290                 case MB_TYPE_BACKWARD:
3291                     s->mv_dir = MV_DIR_BACKWARD;
3292                     s->mb_intra= 0;
3293                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3294                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3295                     break;
3296                 case MB_TYPE_FORWARD:
3297                     s->mv_dir = MV_DIR_FORWARD;
3298                     s->mb_intra= 0;
3299                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3300                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3301 //                    printf(" %d %d ", motion_x, motion_y);
3302                     break;
3303                 default:
3304                     motion_x=motion_y=0; //gcc warning fix
3305                     printf("illegal MB type\n");
3306                 }
3307                 encode_mb(s, motion_x, motion_y);
3308             }
3309             /* clean the MV table in IPS frames for direct mode in B frames */
3310             if(s->mb_intra /* && I,P,S_TYPE */){
3311                 s->p_mv_table[xy][0]=0;
3312                 s->p_mv_table[xy][1]=0;
3313             }
3314
3315             MPV_decode_mb(s, s->block);
3316
3317             if(s->flags&CODEC_FLAG_PSNR){
3318                 int w= 16;
3319                 int h= 16;
3320
3321                 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3322                 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3323
3324                 s->current_picture.error[0] += sse(
3325                     s,
3326                     s->new_picture    .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3327                     s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3328                     w, h, s->linesize);
3329                 s->current_picture.error[1] += sse(
3330                     s,
3331                     s->new_picture    .data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3332                     s->current_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3333                     w>>1, h>>1, s->uvlinesize);
3334                 s->current_picture.error[2] += sse(
3335                     s,
3336                     s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3337                     s->current_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
3338                     w>>1, h>>1, s->uvlinesize);
3339             }
3340 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
3341         }
3342
3343
3344         /* Obtain average mb_row size for RTP */
3345         if (s->rtp_mode) {
3346             if (mb_y==0)
3347                 s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
3348             else {
3349                 s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
3350             }
3351             s->ptr_last_mb_line = pbBufPtr(&s->pb);
3352         }
3353     }
3354     emms_c();
3355
3356     if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3357         ff_mpeg4_merge_partitions(s);
3358
3359     if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3360         msmpeg4_encode_ext_header(s);
3361
3362     if(s->codec_id==CODEC_ID_MPEG4)
3363         ff_mpeg4_stuffing(&s->pb);
3364
3365     //if (s->gob_number)
3366     //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3367
3368     /* Send the last GOB if RTP */
3369     if (s->rtp_mode) {
3370         flush_put_bits(&s->pb);
3371         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3372         /* Call the RTP callback to send the last GOB */
3373         if (s->rtp_callback)
3374             s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3375         s->ptr_lastgob = pbBufPtr(&s->pb);
3376         //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3377     }
3378 }
3379
3380 static int dct_quantize_trellis_c(MpegEncContext *s,
3381                         DCTELEM *block, int n,
3382                         int qscale, int *overflow){
3383     const int *qmat;
3384     const UINT8 *scantable= s->intra_scantable.scantable;
3385     int max=0;
3386     unsigned int threshold1, threshold2;
3387     int bias=0;
3388     int run_tab[65];
3389     int level_tab[65];
3390     int score_tab[65];
3391     int last_run=0;
3392     int last_level=0;
3393     int last_score= 0;
3394     int last_i= 0;
3395     int coeff[3][64];
3396     int coeff_count[64];
3397     int lambda, qmul, qadd, start_i, last_non_zero, i;
3398     const int esc_length= s->ac_esc_length;
3399     uint8_t * length;
3400     uint8_t * last_length;
3401     int score_limit=0;
3402     int left_limit= 0;
3403
3404     s->fdct (block);
3405
3406     qmul= qscale*16;
3407     qadd= ((qscale-1)|1)*8;
3408
3409     if (s->mb_intra) {
3410         int q;
3411         if (!s->h263_aic) {
3412             if (n < 4)
3413                 q = s->y_dc_scale;
3414             else
3415                 q = s->c_dc_scale;
3416             q = q << 3;
3417         } else{
3418             /* For AIC we skip quant/dequant of INTRADC */
3419             q = 1 << 3;
3420             qadd=0;
3421         }
3422
3423         /* note: block[0] is assumed to be positive */
3424         block[0] = (block[0] + (q >> 1)) / q;
3425         start_i = 1;
3426         last_non_zero = 0;
3427         qmat = s->q_intra_matrix[qscale];
3428         if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3429             bias= 1<<(QMAT_SHIFT-1);
3430         length     = s->intra_ac_vlc_length;
3431         last_length= s->intra_ac_vlc_last_length;
3432     } else {
3433         start_i = 0;
3434         last_non_zero = -1;
3435         qmat = s->q_inter_matrix[qscale];
3436         length     = s->inter_ac_vlc_length;
3437         last_length= s->inter_ac_vlc_last_length;
3438     }
3439
3440     threshold1= (1<<QMAT_SHIFT) - bias - 1;
3441     threshold2= (threshold1<<1);
3442
3443     for(i=start_i; i<64; i++) {
3444         const int j = scantable[i];
3445         const int k= i-start_i;
3446         int level = block[j];
3447         level = level * qmat[j];
3448
3449 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3450 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3451         if(((unsigned)(level+threshold1))>threshold2){
3452             if(level>0){
3453                 level= (bias + level)>>QMAT_SHIFT;
3454                 coeff[0][k]= level;
3455                 coeff[1][k]= level-1;
3456 //                coeff[2][k]= level-2;
3457             }else{
3458                 level= (bias - level)>>QMAT_SHIFT;
3459                 coeff[0][k]= -level;
3460                 coeff[1][k]= -level+1;
3461 //                coeff[2][k]= -level+2;
3462             }
3463             coeff_count[k]= FFMIN(level, 2);
3464             max |=level;
3465             last_non_zero = i;
3466         }else{
3467             coeff[0][k]= (level>>31)|1;
3468             coeff_count[k]= 1;
3469         }
3470     }
3471
3472     *overflow= s->max_qcoeff < max; //overflow might have happend
3473
3474     if(last_non_zero < start_i){
3475         memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3476         return last_non_zero;
3477     }
3478
3479     lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
3480
3481     score_tab[0]= 0;
3482     for(i=0; i<=last_non_zero - start_i; i++){
3483         int level_index, run, j;
3484         const int dct_coeff= block[ scantable[i + start_i] ];
3485         const int zero_distoration= dct_coeff*dct_coeff;
3486         int best_score=256*256*256*120;
3487
3488         last_score += zero_distoration;
3489         for(level_index=0; level_index < coeff_count[i]; level_index++){
3490             int distoration;
3491             int level= coeff[level_index][i];
3492             int unquant_coeff;
3493
3494             assert(level);
3495
3496             if(s->out_format == FMT_H263){
3497                 if(level>0){
3498                     unquant_coeff= level*qmul + qadd;
3499                 }else{
3500                     unquant_coeff= level*qmul - qadd;
3501                 }
3502             }else{ //MPEG1
3503                 j= s->idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
3504                 if(s->mb_intra){
3505                     if (level < 0) {
3506                         unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
3507                         unquant_coeff = -((unquant_coeff - 1) | 1);
3508                     } else {
3509                         unquant_coeff = (int)(  level  * qscale * s->intra_matrix[j]) >> 3;
3510                         unquant_coeff =   (unquant_coeff - 1) | 1;
3511                     }
3512                 }else{
3513                     if (level < 0) {
3514                         unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3515                         unquant_coeff = -((unquant_coeff - 1) | 1);
3516                     } else {
3517                         unquant_coeff = (((  level  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3518                         unquant_coeff =   (unquant_coeff - 1) | 1;
3519                     }
3520                 }
3521                 unquant_coeff<<= 3;
3522             }
3523
3524             distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
3525             level+=64;
3526             if((level&(~127)) == 0){
3527                 for(run=0; run<=i - left_limit; run++){
3528                     int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3529                     score += score_tab[i-run];
3530
3531                     if(score < best_score){
3532                         best_score=
3533                         score_tab[i+1]= score;
3534                         run_tab[i+1]= run;
3535                         level_tab[i+1]= level-64;
3536                     }
3537                 }
3538
3539                 if(s->out_format == FMT_H263){
3540                     for(run=0; run<=i - left_limit; run++){
3541                         int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3542                         score += score_tab[i-run];
3543                         if(score < last_score){
3544                             last_score= score;
3545                             last_run= run;
3546                             last_level= level-64;
3547                             last_i= i+1;
3548                         }
3549                     }
3550                 }
3551             }else{
3552                 distoration += esc_length*lambda;
3553                 for(run=0; run<=i - left_limit; run++){
3554                     int score= distoration + score_tab[i-run];
3555
3556                     if(score < best_score){
3557                         best_score=
3558                         score_tab[i+1]= score;
3559                         run_tab[i+1]= run;
3560                         level_tab[i+1]= level-64;
3561                     }
3562                 }
3563
3564                 if(s->out_format == FMT_H263){
3565                     for(run=0; run<=i - left_limit; run++){
3566                         int score= distoration + score_tab[i-run];
3567                         if(score < last_score){
3568                             last_score= score;
3569                             last_run= run;
3570                             last_level= level-64;
3571                             last_i= i+1;
3572                         }
3573                     }
3574                 }
3575             }
3576         }
3577
3578         for(j=left_limit; j<=i; j++){
3579             score_tab[j] += zero_distoration;
3580         }
3581         score_limit+= zero_distoration;
3582         if(score_tab[i+1] < score_limit)
3583             score_limit= score_tab[i+1];
3584
3585         //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3586         while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
3587     }
3588
3589         //FIXME add some cbp penalty
3590
3591     if(s->out_format != FMT_H263){
3592         last_score= 256*256*256*120;
3593         for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
3594             int score= score_tab[i];
3595             if(i) score += lambda*2; //FIXME exacter?
3596
3597             if(score < last_score){
3598                 last_score= score;
3599                 last_i= i;
3600                 last_level= level_tab[i];
3601                 last_run= run_tab[i];
3602             }
3603         }
3604     }
3605
3606     last_non_zero= last_i - 1 + start_i;
3607     memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3608
3609     if(last_non_zero < start_i)
3610         return last_non_zero;
3611
3612     i= last_i;
3613     assert(last_level);
3614 //FIXME use permutated scantable
3615     block[ s->idct_permutation[ scantable[last_non_zero] ] ]= last_level;
3616     i -= last_run + 1;
3617
3618     for(;i>0 ; i -= run_tab[i] + 1){
3619         const int j= s->idct_permutation[ scantable[i - 1 + start_i] ];
3620
3621         block[j]= level_tab[i];
3622         assert(block[j]);
3623     }
3624
3625     return last_non_zero;
3626 }
3627
3628 static int dct_quantize_c(MpegEncContext *s,
3629                         DCTELEM *block, int n,
3630                         int qscale, int *overflow)
3631 {
3632     int i, j, level, last_non_zero, q;
3633     const int *qmat;
3634     const UINT8 *scantable= s->intra_scantable.scantable;
3635     int bias;
3636     int max=0;
3637     unsigned int threshold1, threshold2;
3638
3639     s->fdct (block);
3640
3641     if (s->mb_intra) {
3642         if (!s->h263_aic) {
3643             if (n < 4)
3644                 q = s->y_dc_scale;
3645             else
3646                 q = s->c_dc_scale;
3647             q = q << 3;
3648         } else
3649             /* For AIC we skip quant/dequant of INTRADC */
3650             q = 1 << 3;
3651
3652         /* note: block[0] is assumed to be positive */
3653         block[0] = (block[0] + (q >> 1)) / q;
3654         i = 1;
3655         last_non_zero = 0;
3656         qmat = s->q_intra_matrix[qscale];
3657         bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3658     } else {
3659         i = 0;
3660         last_non_zero = -1;
3661         qmat = s->q_inter_matrix[qscale];
3662         bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
3663     }
3664     threshold1= (1<<QMAT_SHIFT) - bias - 1;
3665     threshold2= (threshold1<<1);
3666
3667     for(;i<64;i++) {
3668         j = scantable[i];
3669         level = block[j];
3670         level = level * qmat[j];
3671
3672 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3673 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3674         if(((unsigned)(level+threshold1))>threshold2){
3675             if(level>0){
3676                 level= (bias + level)>>QMAT_SHIFT;
3677                 block[j]= level;
3678             }else{
3679                 level= (bias - level)>>QMAT_SHIFT;
3680                 block[j]= -level;
3681             }
3682             max |=level;
3683             last_non_zero = i;
3684         }else{
3685             block[j]=0;
3686         }
3687     }
3688     *overflow= s->max_qcoeff < max; //overflow might have happend
3689
3690     /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
3691     if (s->idct_permutation_type != FF_NO_IDCT_PERM)
3692         ff_block_permute(block, s->idct_permutation, scantable, last_non_zero);
3693
3694     return last_non_zero;
3695 }
3696
3697 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
3698                                    DCTELEM *block, int n, int qscale)
3699 {
3700     int i, level, nCoeffs;
3701     const UINT16 *quant_matrix;
3702
3703     nCoeffs= s->block_last_index[n];
3704
3705     if (s->mb_intra) {
3706         if (n < 4)
3707             block[0] = block[0] * s->y_dc_scale;
3708         else
3709             block[0] = block[0] * s->c_dc_scale;
3710         /* XXX: only mpeg1 */
3711         quant_matrix = s->intra_matrix;
3712         for(i=1;i<=nCoeffs;i++) {
3713             int j= s->intra_scantable.permutated[i];
3714             level = block[j];
3715             if (level) {
3716                 if (level < 0) {
3717                     level = -level;
3718                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
3719                     level = (level - 1) | 1;
3720                     level = -level;
3721                 } else {
3722                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
3723                     level = (level - 1) | 1;
3724                 }
3725 #ifdef PARANOID
3726                 if (level < -2048 || level > 2047)
3727                     fprintf(stderr, "unquant error %d %d\n", i, level);
3728 #endif
3729                 block[j] = level;
3730             }
3731         }
3732     } else {
3733         i = 0;
3734         quant_matrix = s->inter_matrix;
3735         for(;i<=nCoeffs;i++) {
3736             int j= s->intra_scantable.permutated[i];
3737             level = block[j];
3738             if (level) {
3739                 if (level < 0) {
3740                     level = -level;
3741                     level = (((level << 1) + 1) * qscale *
3742                              ((int) (quant_matrix[j]))) >> 4;
3743                     level = (level - 1) | 1;
3744                     level = -level;
3745                 } else {
3746                     level = (((level << 1) + 1) * qscale *
3747                              ((int) (quant_matrix[j]))) >> 4;
3748                     level = (level - 1) | 1;
3749                 }
3750 #ifdef PARANOID
3751                 if (level < -2048 || level > 2047)
3752                     fprintf(stderr, "unquant error %d %d\n", i, level);
3753 #endif
3754                 block[j] = level;
3755             }
3756         }
3757     }
3758 }
3759
3760 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
3761                                    DCTELEM *block, int n, int qscale)
3762 {
3763     int i, level, nCoeffs;
3764     const UINT16 *quant_matrix;
3765
3766     if(s->alternate_scan) nCoeffs= 63;
3767     else nCoeffs= s->block_last_index[n];
3768
3769     if (s->mb_intra) {
3770         if (n < 4)
3771             block[0] = block[0] * s->y_dc_scale;
3772         else
3773             block[0] = block[0] * s->c_dc_scale;
3774         quant_matrix = s->intra_matrix;
3775         for(i=1;i<=nCoeffs;i++) {
3776             int j= s->intra_scantable.permutated[i];
3777             level = block[j];
3778             if (level) {
3779                 if (level < 0) {
3780                     level = -level;
3781                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
3782                     level = -level;
3783                 } else {
3784                     level = (int)(level * qscale * quant_matrix[j]) >> 3;
3785                 }
3786 #ifdef PARANOID
3787                 if (level < -2048 || level > 2047)
3788                     fprintf(stderr, "unquant error %d %d\n", i, level);
3789 #endif
3790                 block[j] = level;
3791             }
3792         }
3793     } else {
3794         int sum=-1;
3795         i = 0;
3796         quant_matrix = s->inter_matrix;
3797         for(;i<=nCoeffs;i++) {
3798             int j= s->intra_scantable.permutated[i];
3799             level = block[j];
3800             if (level) {
3801                 if (level < 0) {
3802                     level = -level;
3803                     level = (((level << 1) + 1) * qscale *
3804                              ((int) (quant_matrix[j]))) >> 4;
3805                     level = -level;
3806                 } else {
3807                     level = (((level << 1) + 1) * qscale *
3808                              ((int) (quant_matrix[j]))) >> 4;
3809                 }
3810 #ifdef PARANOID
3811                 if (level < -2048 || level > 2047)
3812                     fprintf(stderr, "unquant error %d %d\n", i, level);
3813 #endif
3814                 block[j] = level;
3815                 sum+=level;
3816             }
3817         }
3818         block[63]^=sum&1;
3819     }
3820 }
3821
3822
3823 static void dct_unquantize_h263_c(MpegEncContext *s,
3824                                   DCTELEM *block, int n, int qscale)
3825 {
3826     int i, level, qmul, qadd;
3827     int nCoeffs;
3828
3829     assert(s->block_last_index[n]>=0);
3830
3831     qadd = (qscale - 1) | 1;
3832     qmul = qscale << 1;
3833
3834     if (s->mb_intra) {
3835         if (!s->h263_aic) {
3836             if (n < 4)
3837                 block[0] = block[0] * s->y_dc_scale;
3838             else
3839                 block[0] = block[0] * s->c_dc_scale;
3840         }else
3841             qadd = 0;
3842         i = 1;
3843         nCoeffs= 63; //does not allways use zigzag table
3844     } else {
3845         i = 0;
3846         nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
3847     }
3848
3849     for(;i<=nCoeffs;i++) {
3850         level = block[i];
3851         if (level) {
3852             if (level < 0) {
3853                 level = level * qmul - qadd;
3854             } else {
3855                 level = level * qmul + qadd;
3856             }
3857 #ifdef PARANOID
3858                 if (level < -2048 || level > 2047)
3859                     fprintf(stderr, "unquant error %d %d\n", i, level);
3860 #endif
3861             block[i] = level;
3862         }
3863     }
3864 }
3865
3866 char ff_get_pict_type_char(int pict_type){
3867     switch(pict_type){
3868     case I_TYPE: return 'I';
3869     case P_TYPE: return 'P';
3870     case B_TYPE: return 'B';
3871     case S_TYPE: return 'S';
3872     default:     return '?';
3873     }
3874 }
3875
3876 AVCodec mpeg1video_encoder = {
3877     "mpeg1video",
3878     CODEC_TYPE_VIDEO,
3879     CODEC_ID_MPEG1VIDEO,
3880     sizeof(MpegEncContext),
3881     MPV_encode_init,
3882     MPV_encode_picture,
3883     MPV_encode_end,
3884 };
3885
3886 AVCodec h263_encoder = {
3887     "h263",
3888     CODEC_TYPE_VIDEO,
3889     CODEC_ID_H263,
3890     sizeof(MpegEncContext),
3891     MPV_encode_init,
3892     MPV_encode_picture,
3893     MPV_encode_end,
3894 };
3895
3896 AVCodec h263p_encoder = {
3897     "h263p",
3898     CODEC_TYPE_VIDEO,
3899     CODEC_ID_H263P,
3900     sizeof(MpegEncContext),
3901     MPV_encode_init,
3902     MPV_encode_picture,
3903     MPV_encode_end,
3904 };
3905
3906 AVCodec rv10_encoder = {
3907     "rv10",
3908     CODEC_TYPE_VIDEO,
3909     CODEC_ID_RV10,
3910     sizeof(MpegEncContext),
3911     MPV_encode_init,
3912     MPV_encode_picture,
3913     MPV_encode_end,
3914 };
3915
3916 AVCodec mjpeg_encoder = {
3917     "mjpeg",
3918     CODEC_TYPE_VIDEO,
3919     CODEC_ID_MJPEG,
3920     sizeof(MpegEncContext),
3921     MPV_encode_init,
3922     MPV_encode_picture,
3923     MPV_encode_end,
3924 };
3925
3926 AVCodec mpeg4_encoder = {
3927     "mpeg4",
3928     CODEC_TYPE_VIDEO,
3929     CODEC_ID_MPEG4,
3930     sizeof(MpegEncContext),
3931     MPV_encode_init,
3932     MPV_encode_picture,
3933     MPV_encode_end,
3934 };
3935
3936 AVCodec msmpeg4v1_encoder = {
3937     "msmpeg4v1",
3938     CODEC_TYPE_VIDEO,
3939     CODEC_ID_MSMPEG4V1,
3940     sizeof(MpegEncContext),
3941     MPV_encode_init,
3942     MPV_encode_picture,
3943     MPV_encode_end,
3944 };
3945
3946 AVCodec msmpeg4v2_encoder = {
3947     "msmpeg4v2",
3948     CODEC_TYPE_VIDEO,
3949     CODEC_ID_MSMPEG4V2,
3950     sizeof(MpegEncContext),
3951     MPV_encode_init,
3952     MPV_encode_picture,
3953     MPV_encode_end,
3954 };
3955
3956 AVCodec msmpeg4v3_encoder = {
3957     "msmpeg4",
3958     CODEC_TYPE_VIDEO,
3959     CODEC_ID_MSMPEG4V3,
3960     sizeof(MpegEncContext),
3961     MPV_encode_init,
3962     MPV_encode_picture,
3963     MPV_encode_end,
3964 };
3965
3966 AVCodec wmv1_encoder = {
3967     "wmv1",
3968     CODEC_TYPE_VIDEO,
3969     CODEC_ID_WMV1,
3970     sizeof(MpegEncContext),
3971     MPV_encode_init,
3972     MPV_encode_picture,
3973     MPV_encode_end,
3974 };
3975