libavcodec/ituh263enc.c

   1 /*
   2  * ITU H263 bitstream encoder
   3  * Copyright (c) 2000,2001 Fabrice Bellard
   4  * H263+ support.
   5  * Copyright (c) 2001 Juan J. Sierralta P
   6  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   7  *
   8  * This file is part of Libav.
   9  *
  10  * Libav is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * Libav is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with Libav; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file
  27  * h263 bitstream encoder.
  28  */
  29
  30 //#define DEBUG
  31 #include <limits.h>
  32
  33 #include "dsputil.h"
  34 #include "avcodec.h"
  35 #include "mpegvideo.h"
  36 #include "h263.h"
  37 #include "mathops.h"
  38 #include "unary.h"
  39 #include "flv.h"
  40 #include "mpeg4video.h"
  41 #include "internal.h"
  42
  43 //#undef NDEBUG
  44 //#include <assert.h>
  45
  46 /**
  47  * Table of number of bits a motion vector component needs.
  48  */
  49 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
  50
  51 /**
  52  * Minimal fcode that a motion vector component would need.
  53  */
  54 static uint8_t fcode_tab[MAX_MV*2+1];
  55
  56 /**
  57  * Minimal fcode that a motion vector component would need in umv.
  58  * All entries in this table are 1.
  59  */
  60 static uint8_t umv_fcode_tab[MAX_MV*2+1];
  61
  62 //unified encoding tables for run length encoding of coefficients
  63 //unified in the sense that the specification specifies the encoding in several steps.
  64 static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
  65 static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
  66 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
  67 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
  68 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
  69
  70 static const uint8_t wrong_run[102] = {
  71  1,  2,  3,  5,  4, 10,  9,  8,
  72 11, 15, 17, 16, 23, 22, 21, 20,
  73 19, 18, 25, 24, 27, 26, 11,  7,
  74  6,  1,  2, 13,  2,  2,  2,  2,
  75  6, 12,  3,  9,  1,  3,  4,  3,
  76  7,  4,  1,  1,  5,  5, 14,  6,
  77  1,  7,  1,  8,  1,  1,  1,  1,
  78 10,  1,  1,  5,  9, 17, 25, 24,
  79 29, 33, 32, 41,  2, 23, 28, 31,
  80  3, 22, 30,  4, 27, 40,  8, 26,
  81  6, 39,  7, 38, 16, 37, 15, 10,
  82 11, 12, 13, 14,  1, 21, 20, 18,
  83 19,  2,  1, 34, 35, 36
  84 };
  85
  86 /**
  87  * Return the 4 bit value that specifies the given aspect ratio.
  88  * This may be one of the standard aspect ratios or it specifies
  89  * that the aspect will be stored explicitly later.
  90  */
  91 av_const int ff_h263_aspect_to_info(AVRational aspect){
  92     int i;
  93
  94     if(aspect.num==0) aspect= (AVRational){1,1};
  95
  96     for(i=1; i<6; i++){
  97         if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
  98             return i;
  99         }
 100     }
 101
 102     return FF_ASPECT_EXTENDED;
 103 }
 104
 105 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
 106 {
 107     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
 108     int best_clock_code=1;
 109     int best_divisor=60;
 110     int best_error= INT_MAX;
 111
 112     if(s->h263_plus){
 113         for(i=0; i<2; i++){
 114             int div, error;
 115             div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
 116             div= av_clip(div, 1, 127);
 117             error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
 118             if(error < best_error){
 119                 best_error= error;
 120                 best_divisor= div;
 121                 best_clock_code= i;
 122             }
 123         }
 124     }
 125     s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
 126     coded_frame_rate= 1800000;
 127     coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
 128
 129     align_put_bits(&s->pb);
 130
 131     /* Update the pointer to last GOB */
 132     s->ptr_lastgob = put_bits_ptr(&s->pb);
 133     put_bits(&s->pb, 22, 0x20); /* PSC */
 134     temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
 135                          (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
 136     put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
 137
 138     put_bits(&s->pb, 1, 1);     /* marker */
 139     put_bits(&s->pb, 1, 0);     /* h263 id */
 140     put_bits(&s->pb, 1, 0);     /* split screen off */
 141     put_bits(&s->pb, 1, 0);     /* camera  off */
 142     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
 143
 144     format = ff_match_2uint16(h263_format, FF_ARRAY_ELEMS(h263_format), s->width, s->height);
 145     if (!s->h263_plus) {
 146         /* H.263v1 */
 147         put_bits(&s->pb, 3, format);
 148         put_bits(&s->pb, 1, (s->pict_type == AV_PICTURE_TYPE_P));
 149         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
 150         of H.263v1 UMV implies to check the predicted MV after
 151         calculation of the current MB to see if we're on the limits */
 152         put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
 153         put_bits(&s->pb, 1, 0);         /* SAC: off */
 154         put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
 155         put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
 156         put_bits(&s->pb, 5, s->qscale);
 157         put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
 158     } else {
 159         int ufep=1;
 160         /* H.263v2 */
 161         /* H.263 Plus PTYPE */
 162
 163         put_bits(&s->pb, 3, 7);
 164         put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
 165         if (format == 8)
 166             put_bits(&s->pb,3,6); /* Custom Source Format */
 167         else
 168             put_bits(&s->pb, 3, format);
 169
 170         put_bits(&s->pb,1, s->custom_pcf);
 171         put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
 172         put_bits(&s->pb,1,0); /* SAC: off */
 173         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
 174         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
 175         put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
 176         put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
 177         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
 178         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
 179         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
 180         put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
 181         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 182         put_bits(&s->pb,3,0); /* Reserved */
 183
 184         put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P);
 185
 186         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
 187         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
 188         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
 189         put_bits(&s->pb,2,0); /* Reserved */
 190         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 191
 192         /* This should be here if PLUSPTYPE */
 193         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
 194
 195         if (format == 8) {
 196             /* Custom Picture Format (CPFMT) */
 197             s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
 198
 199             put_bits(&s->pb,4,s->aspect_ratio_info);
 200             put_bits(&s->pb,9,(s->width >> 2) - 1);
 201             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 202             put_bits(&s->pb,9,(s->height >> 2));
 203             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
 204                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
 205                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
 206             }
 207         }
 208         if(s->custom_pcf){
 209             if(ufep){
 210                 put_bits(&s->pb, 1, best_clock_code);
 211                 put_bits(&s->pb, 7, best_divisor);
 212             }
 213             put_sbits(&s->pb, 2, temp_ref>>8);
 214         }
 215
 216         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
 217         if (s->umvplus)
 218 //            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
 219 //FIXME check actual requested range
 220             put_bits(&s->pb,2,1); /* unlimited */
 221         if(s->h263_slice_structured)
 222             put_bits(&s->pb,2,0); /* no weird submodes */
 223
 224         put_bits(&s->pb, 5, s->qscale);
 225     }
 226
 227     put_bits(&s->pb, 1, 0);     /* no PEI */
 228
 229     if(s->h263_slice_structured){
 230         put_bits(&s->pb, 1, 1);
 231
 232         assert(s->mb_x == 0 && s->mb_y == 0);
 233         ff_h263_encode_mba(s);
 234
 235         put_bits(&s->pb, 1, 1);
 236     }
 237
 238     if(s->h263_aic){
 239          s->y_dc_scale_table=
 240          s->c_dc_scale_table= ff_aic_dc_scale_table;
 241     }else{
 242         s->y_dc_scale_table=
 243         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 244     }
 245 }
 246
 247 /**
 248  * Encode a group of blocks header.
 249  */
 250 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
 251 {
 252     put_bits(&s->pb, 17, 1); /* GBSC */
 253
 254     if(s->h263_slice_structured){
 255         put_bits(&s->pb, 1, 1);
 256
 257         ff_h263_encode_mba(s);
 258
 259         if(s->mb_num > 1583)
 260             put_bits(&s->pb, 1, 1);
 261         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 262         put_bits(&s->pb, 1, 1);
 263         put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
 264     }else{
 265         int gob_number= mb_line / s->gob_index;
 266
 267         put_bits(&s->pb, 5, gob_number); /* GN */
 268         put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
 269         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 270     }
 271 }
 272
 273 /**
 274  * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
 275  */
 276 void ff_clean_h263_qscales(MpegEncContext *s){
 277     int i;
 278     int8_t * const qscale_table = s->current_picture.f.qscale_table;
 279
 280     ff_init_qscale_tab(s);
 281
 282     for(i=1; i<s->mb_num; i++){
 283         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
 284             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
 285     }
 286     for(i=s->mb_num-2; i>=0; i--){
 287         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
 288             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
 289     }
 290
 291     if(s->codec_id != CODEC_ID_H263P){
 292         for(i=1; i<s->mb_num; i++){
 293             int mb_xy= s->mb_index2xy[i];
 294
 295             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
 296                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
 297             }
 298         }
 299     }
 300 }
 301
 302 static const int dquant_code[5]= {1,0,9,2,3};
 303
 304 /**
 305  * encodes a 8x8 block.
 306  * @param block the 8x8 block
 307  * @param n block index (0-3 are luma, 4-5 are chroma)
 308  */
 309 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 310 {
 311     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
 312     RLTable *rl;
 313
 314     rl = &ff_h263_rl_inter;
 315     if (s->mb_intra && !s->h263_aic) {
 316         /* DC coef */
 317         level = block[0];
 318         /* 255 cannot be represented, so we clamp */
 319         if (level > 254) {
 320             level = 254;
 321             block[0] = 254;
 322         }
 323         /* 0 cannot be represented also */
 324         else if (level < 1) {
 325             level = 1;
 326             block[0] = 1;
 327         }
 328         if (level == 128) //FIXME check rv10
 329             put_bits(&s->pb, 8, 0xff);
 330         else
 331             put_bits(&s->pb, 8, level);
 332         i = 1;
 333     } else {
 334         i = 0;
 335         if (s->h263_aic && s->mb_intra)
 336             rl = &rl_intra_aic;
 337
 338         if(s->alt_inter_vlc && !s->mb_intra){
 339             int aic_vlc_bits=0;
 340             int inter_vlc_bits=0;
 341             int wrong_pos=-1;
 342             int aic_code;
 343
 344             last_index = s->block_last_index[n];
 345             last_non_zero = i - 1;
 346             for (; i <= last_index; i++) {
 347                 j = s->intra_scantable.permutated[i];
 348                 level = block[j];
 349                 if (level) {
 350                     run = i - last_non_zero - 1;
 351                     last = (i == last_index);
 352
 353                     if(level<0) level= -level;
 354
 355                     code = get_rl_index(rl, last, run, level);
 356                     aic_code = get_rl_index(&rl_intra_aic, last, run, level);
 357                     inter_vlc_bits += rl->table_vlc[code][1]+1;
 358                     aic_vlc_bits   += rl_intra_aic.table_vlc[aic_code][1]+1;
 359
 360                     if (code == rl->n) {
 361                         inter_vlc_bits += 1+6+8-1;
 362                     }
 363                     if (aic_code == rl_intra_aic.n) {
 364                         aic_vlc_bits += 1+6+8-1;
 365                         wrong_pos += run + 1;
 366                     }else
 367                         wrong_pos += wrong_run[aic_code];
 368                     last_non_zero = i;
 369                 }
 370             }
 371             i = 0;
 372             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
 373                 rl = &rl_intra_aic;
 374         }
 375     }
 376
 377     /* AC coefs */
 378     last_index = s->block_last_index[n];
 379     last_non_zero = i - 1;
 380     for (; i <= last_index; i++) {
 381         j = s->intra_scantable.permutated[i];
 382         level = block[j];
 383         if (level) {
 384             run = i - last_non_zero - 1;
 385             last = (i == last_index);
 386             sign = 0;
 387             slevel = level;
 388             if (level < 0) {
 389                 sign = 1;
 390                 level = -level;
 391             }
 392             code = get_rl_index(rl, last, run, level);
 393             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 394             if (code == rl->n) {
 395               if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
 396                 put_bits(&s->pb, 1, last);
 397                 put_bits(&s->pb, 6, run);
 398
 399                 assert(slevel != 0);
 400
 401                 if(level < 128)
 402                     put_sbits(&s->pb, 8, slevel);
 403                 else{
 404                     put_bits(&s->pb, 8, 128);
 405                     put_sbits(&s->pb, 5, slevel);
 406                     put_sbits(&s->pb, 6, slevel>>5);
 407                 }
 408               }else{
 409                     ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
 410               }
 411             } else {
 412                 put_bits(&s->pb, 1, sign);
 413             }
 414             last_non_zero = i;
 415         }
 416     }
 417 }
 418
 419 /* Encode MV differences on H.263+ with Unrestricted MV mode */
 420 static void h263p_encode_umotion(MpegEncContext * s, int val)
 421 {
 422     short sval = 0;
 423     short i = 0;
 424     short n_bits = 0;
 425     short temp_val;
 426     int code = 0;
 427     int tcode;
 428
 429     if ( val == 0)
 430         put_bits(&s->pb, 1, 1);
 431     else if (val == 1)
 432         put_bits(&s->pb, 3, 0);
 433     else if (val == -1)
 434         put_bits(&s->pb, 3, 2);
 435     else {
 436
 437         sval = ((val < 0) ? (short)(-val):(short)val);
 438         temp_val = sval;
 439
 440         while (temp_val != 0) {
 441             temp_val = temp_val >> 1;
 442             n_bits++;
 443         }
 444
 445         i = n_bits - 1;
 446         while (i > 0) {
 447             tcode = (sval & (1 << (i-1))) >> (i-1);
 448             tcode = (tcode << 1) | 1;
 449             code = (code << 2) | tcode;
 450             i--;
 451         }
 452         code = ((code << 1) | (val < 0)) << 1;
 453         put_bits(&s->pb, (2*n_bits)+1, code);
 454     }
 455 }
 456
 457 void h263_encode_mb(MpegEncContext * s,
 458                     DCTELEM block[6][64],
 459                     int motion_x, int motion_y)
 460 {
 461     int cbpc, cbpy, i, cbp, pred_x, pred_y;
 462     int16_t pred_dc;
 463     int16_t rec_intradc[6];
 464     int16_t *dc_ptr[6];
 465     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
 466
 467     if (!s->mb_intra) {
 468         /* compute cbp */
 469         cbp= get_p_cbp(s, block, motion_x, motion_y);
 470
 471         if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
 472             /* skip macroblock */
 473             put_bits(&s->pb, 1, 1);
 474             if(interleaved_stats){
 475                 s->misc_bits++;
 476                 s->last_bits++;
 477             }
 478             s->skip_count++;
 479
 480             return;
 481         }
 482         put_bits(&s->pb, 1, 0);         /* mb coded */
 483
 484         cbpc = cbp & 3;
 485         cbpy = cbp >> 2;
 486         if(s->alt_inter_vlc==0 || cbpc!=3)
 487             cbpy ^= 0xF;
 488         if(s->dquant) cbpc+= 8;
 489         if(s->mv_type==MV_TYPE_16X16){
 490             put_bits(&s->pb,
 491                     ff_h263_inter_MCBPC_bits[cbpc],
 492                     ff_h263_inter_MCBPC_code[cbpc]);
 493
 494             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
 495             if(s->dquant)
 496                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 497
 498             if(interleaved_stats){
 499                 s->misc_bits+= get_bits_diff(s);
 500             }
 501
 502             /* motion vectors: 16x16 mode */
 503             h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 504
 505             if (!s->umvplus) {
 506                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
 507                                                 motion_y - pred_y, 1);
 508             }
 509             else {
 510                 h263p_encode_umotion(s, motion_x - pred_x);
 511                 h263p_encode_umotion(s, motion_y - pred_y);
 512                 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 513                     /* To prevent Start Code emulation */
 514                     put_bits(&s->pb,1,1);
 515             }
 516         }else{
 517             put_bits(&s->pb,
 518                     ff_h263_inter_MCBPC_bits[cbpc+16],
 519                     ff_h263_inter_MCBPC_code[cbpc+16]);
 520             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
 521             if(s->dquant)
 522                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 523
 524             if(interleaved_stats){
 525                 s->misc_bits+= get_bits_diff(s);
 526             }
 527
 528             for(i=0; i<4; i++){
 529                 /* motion vectors: 8x8 mode*/
 530                 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
 531
 532                 motion_x = s->current_picture.f.motion_val[0][s->block_index[i]][0];
 533                 motion_y = s->current_picture.f.motion_val[0][s->block_index[i]][1];
 534                 if (!s->umvplus) {
 535                     ff_h263_encode_motion_vector(s, motion_x - pred_x,
 536                                                     motion_y - pred_y, 1);
 537                 }
 538                 else {
 539                     h263p_encode_umotion(s, motion_x - pred_x);
 540                     h263p_encode_umotion(s, motion_y - pred_y);
 541                     if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 542                         /* To prevent Start Code emulation */
 543                         put_bits(&s->pb,1,1);
 544                 }
 545             }
 546         }
 547
 548         if(interleaved_stats){
 549             s->mv_bits+= get_bits_diff(s);
 550         }
 551     } else {
 552         assert(s->mb_intra);
 553
 554         cbp = 0;
 555         if (s->h263_aic) {
 556             /* Predict DC */
 557             for(i=0; i<6; i++) {
 558                 int16_t level = block[i][0];
 559                 int scale;
 560
 561                 if(i<4) scale= s->y_dc_scale;
 562                 else    scale= s->c_dc_scale;
 563
 564                 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
 565                 level -= pred_dc;
 566                 /* Quant */
 567                 if (level >= 0)
 568                     level = (level + (scale>>1))/scale;
 569                 else
 570                     level = (level - (scale>>1))/scale;
 571
 572                 /* AIC can change CBP */
 573                 if (level == 0 && s->block_last_index[i] == 0)
 574                     s->block_last_index[i] = -1;
 575
 576                 if(!s->modified_quant){
 577                     if (level < -127)
 578                         level = -127;
 579                     else if (level > 127)
 580                         level = 127;
 581                 }
 582
 583                 block[i][0] = level;
 584                 /* Reconstruction */
 585                 rec_intradc[i] = scale*level + pred_dc;
 586                 /* Oddify */
 587                 rec_intradc[i] |= 1;
 588                 //if ((rec_intradc[i] % 2) == 0)
 589                 //    rec_intradc[i]++;
 590                 /* Clipping */
 591                 if (rec_intradc[i] < 0)
 592                     rec_intradc[i] = 0;
 593                 else if (rec_intradc[i] > 2047)
 594                     rec_intradc[i] = 2047;
 595
 596                 /* Update AC/DC tables */
 597                 *dc_ptr[i] = rec_intradc[i];
 598                 if (s->block_last_index[i] >= 0)
 599                     cbp |= 1 << (5 - i);
 600             }
 601         }else{
 602             for(i=0; i<6; i++) {
 603                 /* compute cbp */
 604                 if (s->block_last_index[i] >= 1)
 605                     cbp |= 1 << (5 - i);
 606             }
 607         }
 608
 609         cbpc = cbp & 3;
 610         if (s->pict_type == AV_PICTURE_TYPE_I) {
 611             if(s->dquant) cbpc+=4;
 612             put_bits(&s->pb,
 613                 ff_h263_intra_MCBPC_bits[cbpc],
 614                 ff_h263_intra_MCBPC_code[cbpc]);
 615         } else {
 616             if(s->dquant) cbpc+=8;
 617             put_bits(&s->pb, 1, 0);     /* mb coded */
 618             put_bits(&s->pb,
 619                 ff_h263_inter_MCBPC_bits[cbpc + 4],
 620                 ff_h263_inter_MCBPC_code[cbpc + 4]);
 621         }
 622         if (s->h263_aic) {
 623             /* XXX: currently, we do not try to use ac prediction */
 624             put_bits(&s->pb, 1, 0);     /* no AC prediction */
 625         }
 626         cbpy = cbp >> 2;
 627         put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
 628         if(s->dquant)
 629             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 630
 631         if(interleaved_stats){
 632             s->misc_bits+= get_bits_diff(s);
 633         }
 634     }
 635
 636     for(i=0; i<6; i++) {
 637         /* encode each block */
 638         h263_encode_block(s, block[i], i);
 639
 640         /* Update INTRADC for decoding */
 641         if (s->h263_aic && s->mb_intra) {
 642             block[i][0] = rec_intradc[i];
 643
 644         }
 645     }
 646
 647     if(interleaved_stats){
 648         if (!s->mb_intra) {
 649             s->p_tex_bits+= get_bits_diff(s);
 650             s->f_count++;
 651         }else{
 652             s->i_tex_bits+= get_bits_diff(s);
 653             s->i_count++;
 654         }
 655     }
 656 }
 657
 658 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
 659 {
 660     int range, l, bit_size, sign, code, bits;
 661
 662     if (val == 0) {
 663         /* zero vector */
 664         code = 0;
 665         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
 666     } else {
 667         bit_size = f_code - 1;
 668         range = 1 << bit_size;
 669         /* modulo encoding */
 670         l= INT_BIT - 6 - bit_size;
 671         val = (val<<l)>>l;
 672         sign = val>>31;
 673         val= (val^sign)-sign;
 674         sign&=1;
 675
 676         val--;
 677         code = (val >> bit_size) + 1;
 678         bits = val & (range - 1);
 679
 680         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
 681         if (bit_size > 0) {
 682             put_bits(&s->pb, bit_size, bits);
 683         }
 684     }
 685 }
 686
 687 static void init_mv_penalty_and_fcode(MpegEncContext *s)
 688 {
 689     int f_code;
 690     int mv;
 691
 692     for(f_code=1; f_code<=MAX_FCODE; f_code++){
 693         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
 694             int len;
 695
 696             if(mv==0) len= mvtab[0][1];
 697             else{
 698                 int val, bit_size, code;
 699
 700                 bit_size = f_code - 1;
 701
 702                 val=mv;
 703                 if (val < 0)
 704                     val = -val;
 705                 val--;
 706                 code = (val >> bit_size) + 1;
 707                 if(code<33){
 708                     len= mvtab[code][1] + 1 + bit_size;
 709                 }else{
 710                     len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
 711                 }
 712             }
 713
 714             mv_penalty[f_code][mv+MAX_MV]= len;
 715         }
 716     }
 717
 718     for(f_code=MAX_FCODE; f_code>0; f_code--){
 719         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
 720             fcode_tab[mv+MAX_MV]= f_code;
 721         }
 722     }
 723
 724     for(mv=0; mv<MAX_MV*2+1; mv++){
 725         umv_fcode_tab[mv]= 1;
 726     }
 727 }
 728
 729 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
 730     int slevel, run, last;
 731
 732     assert(MAX_LEVEL >= 64);
 733     assert(MAX_RUN   >= 63);
 734
 735     for(slevel=-64; slevel<64; slevel++){
 736         if(slevel==0) continue;
 737         for(run=0; run<64; run++){
 738             for(last=0; last<=1; last++){
 739                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
 740                 int level= slevel < 0 ? -slevel : slevel;
 741                 int sign= slevel < 0 ? 1 : 0;
 742                 int bits, len, code;
 743
 744                 len_tab[index]= 100;
 745
 746                 /* ESC0 */
 747                 code= get_rl_index(rl, last, run, level);
 748                 bits= rl->table_vlc[code][0];
 749                 len=  rl->table_vlc[code][1];
 750                 bits=bits*2+sign; len++;
 751
 752                 if(code!=rl->n && len < len_tab[index]){
 753                     if(bits_tab) bits_tab[index]= bits;
 754                     len_tab [index]= len;
 755                 }
 756                 /* ESC */
 757                 bits= rl->table_vlc[rl->n][0];
 758                 len = rl->table_vlc[rl->n][1];
 759                 bits=bits*2+last; len++;
 760                 bits=bits*64+run; len+=6;
 761                 bits=bits*256+(level&0xff); len+=8;
 762
 763                 if(len < len_tab[index]){
 764                     if(bits_tab) bits_tab[index]= bits;
 765                     len_tab [index]= len;
 766                 }
 767             }
 768         }
 769     }
 770 }
 771
 772 void h263_encode_init(MpegEncContext *s)
 773 {
 774     static int done = 0;
 775
 776     if (!done) {
 777         done = 1;
 778
 779         init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
 780         init_rl(&rl_intra_aic, ff_h263_static_rl_table_store[1]);
 781
 782         init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
 783         init_uni_h263_rl_tab(&ff_h263_rl_inter    , NULL, uni_h263_inter_rl_len);
 784
 785         init_mv_penalty_and_fcode(s);
 786     }
 787     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
 788
 789     s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
 790     s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
 791     if(s->h263_aic){
 792         s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
 793         s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
 794     }
 795     s->ac_esc_length= 7+1+6+8;
 796
 797     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
 798     switch(s->codec_id){
 799     case CODEC_ID_MPEG4:
 800         s->fcode_tab= fcode_tab;
 801         break;
 802     case CODEC_ID_H263P:
 803         if(s->umvplus)
 804             s->fcode_tab= umv_fcode_tab;
 805         if(s->modified_quant){
 806             s->min_qcoeff= -2047;
 807             s->max_qcoeff=  2047;
 808         }else{
 809             s->min_qcoeff= -127;
 810             s->max_qcoeff=  127;
 811         }
 812         break;
 813         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
 814     case CODEC_ID_FLV1:
 815         if (s->h263_flv > 1) {
 816             s->min_qcoeff= -1023;
 817             s->max_qcoeff=  1023;
 818         } else {
 819             s->min_qcoeff= -127;
 820             s->max_qcoeff=  127;
 821         }
 822         s->y_dc_scale_table=
 823         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 824         break;
 825     default: //nothing needed - default table already set in mpegvideo.c
 826         s->min_qcoeff= -127;
 827         s->max_qcoeff=  127;
 828         s->y_dc_scale_table=
 829         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 830     }
 831 }
 832
 833 void ff_h263_encode_mba(MpegEncContext *s)
 834 {
 835     int i, mb_pos;
 836
 837     for(i=0; i<6; i++){
 838         if(s->mb_num-1 <= ff_mba_max[i]) break;
 839     }
 840     mb_pos= s->mb_x + s->mb_width*s->mb_y;
 841     put_bits(&s->pb, ff_mba_length[i], mb_pos);
 842 }