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