git.sesse.net Git - ffmpeg/blob - libavcodec/ituh263enc.c

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