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