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 "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         assert(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     if(s->h263_aic){
 236          s->y_dc_scale_table=
 237          s->c_dc_scale_table= ff_aic_dc_scale_table;
 238     }else{
 239         s->y_dc_scale_table=
 240         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 241     }
 242 }
 243
 244 /**
 245  * Encode a group of blocks header.
 246  */
 247 void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line)
 248 {
 249     put_bits(&s->pb, 17, 1); /* GBSC */
 250
 251     if(s->h263_slice_structured){
 252         put_bits(&s->pb, 1, 1);
 253
 254         ff_h263_encode_mba(s);
 255
 256         if(s->mb_num > 1583)
 257             put_bits(&s->pb, 1, 1);
 258         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 259         put_bits(&s->pb, 1, 1);
 260         put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
 261     }else{
 262         int gob_number= mb_line / s->gob_index;
 263
 264         put_bits(&s->pb, 5, gob_number); /* GN */
 265         put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
 266         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 267     }
 268 }
 269
 270 /**
 271  * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
 272  */
 273 void ff_clean_h263_qscales(MpegEncContext *s){
 274     int i;
 275     int8_t * const qscale_table = s->current_picture.qscale_table;
 276
 277     ff_init_qscale_tab(s);
 278
 279     for(i=1; i<s->mb_num; i++){
 280         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
 281             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
 282     }
 283     for(i=s->mb_num-2; i>=0; i--){
 284         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
 285             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
 286     }
 287
 288     if(s->codec_id != AV_CODEC_ID_H263P){
 289         for(i=1; i<s->mb_num; i++){
 290             int mb_xy= s->mb_index2xy[i];
 291
 292             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
 293                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
 294             }
 295         }
 296     }
 297 }
 298
 299 static const int dquant_code[5]= {1,0,9,2,3};
 300
 301 /**
 302  * Encode an 8x8 block.
 303  * @param block the 8x8 block
 304  * @param n block index (0-3 are luma, 4-5 are chroma)
 305  */
 306 static void h263_encode_block(MpegEncContext * s, int16_t * block, int n)
 307 {
 308     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
 309     RLTable *rl;
 310
 311     rl = &ff_h263_rl_inter;
 312     if (s->mb_intra && !s->h263_aic) {
 313         /* DC coef */
 314         level = block[0];
 315         /* 255 cannot be represented, so we clamp */
 316         if (level > 254) {
 317             level = 254;
 318             block[0] = 254;
 319         }
 320         /* 0 cannot be represented also */
 321         else if (level < 1) {
 322             level = 1;
 323             block[0] = 1;
 324         }
 325         if (level == 128) //FIXME check rv10
 326             put_bits(&s->pb, 8, 0xff);
 327         else
 328             put_bits(&s->pb, 8, level);
 329         i = 1;
 330     } else {
 331         i = 0;
 332         if (s->h263_aic && s->mb_intra)
 333             rl = &ff_rl_intra_aic;
 334
 335         if(s->alt_inter_vlc && !s->mb_intra){
 336             int aic_vlc_bits=0;
 337             int inter_vlc_bits=0;
 338             int wrong_pos=-1;
 339             int aic_code;
 340
 341             last_index = s->block_last_index[n];
 342             last_non_zero = i - 1;
 343             for (; i <= last_index; i++) {
 344                 j = s->intra_scantable.permutated[i];
 345                 level = block[j];
 346                 if (level) {
 347                     run = i - last_non_zero - 1;
 348                     last = (i == last_index);
 349
 350                     if(level<0) level= -level;
 351
 352                     code = get_rl_index(rl, last, run, level);
 353                     aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
 354                     inter_vlc_bits += rl->table_vlc[code][1]+1;
 355                     aic_vlc_bits   += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
 356
 357                     if (code == rl->n) {
 358                         inter_vlc_bits += 1+6+8-1;
 359                     }
 360                     if (aic_code == ff_rl_intra_aic.n) {
 361                         aic_vlc_bits += 1+6+8-1;
 362                         wrong_pos += run + 1;
 363                     }else
 364                         wrong_pos += wrong_run[aic_code];
 365                     last_non_zero = i;
 366                 }
 367             }
 368             i = 0;
 369             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
 370                 rl = &ff_rl_intra_aic;
 371         }
 372     }
 373
 374     /* AC coefs */
 375     last_index = s->block_last_index[n];
 376     last_non_zero = i - 1;
 377     for (; i <= last_index; i++) {
 378         j = s->intra_scantable.permutated[i];
 379         level = block[j];
 380         if (level) {
 381             run = i - last_non_zero - 1;
 382             last = (i == last_index);
 383             sign = 0;
 384             slevel = level;
 385             if (level < 0) {
 386                 sign = 1;
 387                 level = -level;
 388             }
 389             code = get_rl_index(rl, last, run, level);
 390             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 391             if (code == rl->n) {
 392               if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
 393                 put_bits(&s->pb, 1, last);
 394                 put_bits(&s->pb, 6, run);
 395
 396                 assert(slevel != 0);
 397
 398                 if(level < 128)
 399                     put_sbits(&s->pb, 8, slevel);
 400                 else{
 401                     put_bits(&s->pb, 8, 128);
 402                     put_sbits(&s->pb, 5, slevel);
 403                     put_sbits(&s->pb, 6, slevel>>5);
 404                 }
 405               }else{
 406                     ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
 407               }
 408             } else {
 409                 put_bits(&s->pb, 1, sign);
 410             }
 411             last_non_zero = i;
 412         }
 413     }
 414 }
 415
 416 /* Encode MV differences on H.263+ with Unrestricted MV mode */
 417 static void h263p_encode_umotion(MpegEncContext * s, int val)
 418 {
 419     short sval = 0;
 420     short i = 0;
 421     short n_bits = 0;
 422     short temp_val;
 423     int code = 0;
 424     int tcode;
 425
 426     if ( val == 0)
 427         put_bits(&s->pb, 1, 1);
 428     else if (val == 1)
 429         put_bits(&s->pb, 3, 0);
 430     else if (val == -1)
 431         put_bits(&s->pb, 3, 2);
 432     else {
 433
 434         sval = ((val < 0) ? (short)(-val):(short)val);
 435         temp_val = sval;
 436
 437         while (temp_val != 0) {
 438             temp_val = temp_val >> 1;
 439             n_bits++;
 440         }
 441
 442         i = n_bits - 1;
 443         while (i > 0) {
 444             tcode = (sval & (1 << (i-1))) >> (i-1);
 445             tcode = (tcode << 1) | 1;
 446             code = (code << 2) | tcode;
 447             i--;
 448         }
 449         code = ((code << 1) | (val < 0)) << 1;
 450         put_bits(&s->pb, (2*n_bits)+1, code);
 451     }
 452 }
 453
 454 void ff_h263_encode_mb(MpegEncContext * s,
 455                        int16_t block[6][64],
 456                        int motion_x, int motion_y)
 457 {
 458     int cbpc, cbpy, i, cbp, pred_x, pred_y;
 459     int16_t pred_dc;
 460     int16_t rec_intradc[6];
 461     int16_t *dc_ptr[6];
 462     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
 463
 464     if (!s->mb_intra) {
 465         /* compute cbp */
 466         cbp= get_p_cbp(s, block, motion_x, motion_y);
 467
 468         if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
 469             /* skip macroblock */
 470             put_bits(&s->pb, 1, 1);
 471             if(interleaved_stats){
 472                 s->misc_bits++;
 473                 s->last_bits++;
 474             }
 475             s->skip_count++;
 476
 477             return;
 478         }
 479         put_bits(&s->pb, 1, 0);         /* mb coded */
 480
 481         cbpc = cbp & 3;
 482         cbpy = cbp >> 2;
 483         if(s->alt_inter_vlc==0 || cbpc!=3)
 484             cbpy ^= 0xF;
 485         if(s->dquant) cbpc+= 8;
 486         if(s->mv_type==MV_TYPE_16X16){
 487             put_bits(&s->pb,
 488                     ff_h263_inter_MCBPC_bits[cbpc],
 489                     ff_h263_inter_MCBPC_code[cbpc]);
 490
 491             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
 492             if(s->dquant)
 493                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 494
 495             if(interleaved_stats){
 496                 s->misc_bits+= get_bits_diff(s);
 497             }
 498
 499             /* motion vectors: 16x16 mode */
 500             ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 501
 502             if (!s->umvplus) {
 503                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
 504                                                 motion_y - pred_y, 1);
 505             }
 506             else {
 507                 h263p_encode_umotion(s, motion_x - pred_x);
 508                 h263p_encode_umotion(s, motion_y - pred_y);
 509                 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 510                     /* To prevent Start Code emulation */
 511                     put_bits(&s->pb,1,1);
 512             }
 513         }else{
 514             put_bits(&s->pb,
 515                     ff_h263_inter_MCBPC_bits[cbpc+16],
 516                     ff_h263_inter_MCBPC_code[cbpc+16]);
 517             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
 518             if(s->dquant)
 519                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 520
 521             if(interleaved_stats){
 522                 s->misc_bits+= get_bits_diff(s);
 523             }
 524
 525             for(i=0; i<4; i++){
 526                 /* motion vectors: 8x8 mode*/
 527                 ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
 528
 529                 motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];
 530                 motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];
 531                 if (!s->umvplus) {
 532                     ff_h263_encode_motion_vector(s, motion_x - pred_x,
 533                                                     motion_y - pred_y, 1);
 534                 }
 535                 else {
 536                     h263p_encode_umotion(s, motion_x - pred_x);
 537                     h263p_encode_umotion(s, motion_y - pred_y);
 538                     if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 539                         /* To prevent Start Code emulation */
 540                         put_bits(&s->pb,1,1);
 541                 }
 542             }
 543         }
 544
 545         if(interleaved_stats){
 546             s->mv_bits+= get_bits_diff(s);
 547         }
 548     } else {
 549         assert(s->mb_intra);
 550
 551         cbp = 0;
 552         if (s->h263_aic) {
 553             /* Predict DC */
 554             for(i=0; i<6; i++) {
 555                 int16_t level = block[i][0];
 556                 int scale;
 557
 558                 if(i<4) scale= s->y_dc_scale;
 559                 else    scale= s->c_dc_scale;
 560
 561                 pred_dc = ff_h263_pred_dc(s, i, &dc_ptr[i]);
 562                 level -= pred_dc;
 563                 /* Quant */
 564                 if (level >= 0)
 565                     level = (level + (scale>>1))/scale;
 566                 else
 567                     level = (level - (scale>>1))/scale;
 568
 569                 /* AIC can change CBP */
 570                 if (level == 0 && s->block_last_index[i] == 0)
 571                     s->block_last_index[i] = -1;
 572
 573                 if(!s->modified_quant){
 574                     if (level < -127)
 575                         level = -127;
 576                     else if (level > 127)
 577                         level = 127;
 578                 }
 579
 580                 block[i][0] = level;
 581                 /* Reconstruction */
 582                 rec_intradc[i] = scale*level + pred_dc;
 583                 /* Oddify */
 584                 rec_intradc[i] |= 1;
 585                 //if ((rec_intradc[i] % 2) == 0)
 586                 //    rec_intradc[i]++;
 587                 /* Clipping */
 588                 if (rec_intradc[i] < 0)
 589                     rec_intradc[i] = 0;
 590                 else if (rec_intradc[i] > 2047)
 591                     rec_intradc[i] = 2047;
 592
 593                 /* Update AC/DC tables */
 594                 *dc_ptr[i] = rec_intradc[i];
 595                 if (s->block_last_index[i] >= 0)
 596                     cbp |= 1 << (5 - i);
 597             }
 598         }else{
 599             for(i=0; i<6; i++) {
 600                 /* compute cbp */
 601                 if (s->block_last_index[i] >= 1)
 602                     cbp |= 1 << (5 - i);
 603             }
 604         }
 605
 606         cbpc = cbp & 3;
 607         if (s->pict_type == AV_PICTURE_TYPE_I) {
 608             if(s->dquant) cbpc+=4;
 609             put_bits(&s->pb,
 610                 ff_h263_intra_MCBPC_bits[cbpc],
 611                 ff_h263_intra_MCBPC_code[cbpc]);
 612         } else {
 613             if(s->dquant) cbpc+=8;
 614             put_bits(&s->pb, 1, 0);     /* mb coded */
 615             put_bits(&s->pb,
 616                 ff_h263_inter_MCBPC_bits[cbpc + 4],
 617                 ff_h263_inter_MCBPC_code[cbpc + 4]);
 618         }
 619         if (s->h263_aic) {
 620             /* XXX: currently, we do not try to use ac prediction */
 621             put_bits(&s->pb, 1, 0);     /* no AC prediction */
 622         }
 623         cbpy = cbp >> 2;
 624         put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
 625         if(s->dquant)
 626             put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 627
 628         if(interleaved_stats){
 629             s->misc_bits+= get_bits_diff(s);
 630         }
 631     }
 632
 633     for(i=0; i<6; i++) {
 634         /* encode each block */
 635         h263_encode_block(s, block[i], i);
 636
 637         /* Update INTRADC for decoding */
 638         if (s->h263_aic && s->mb_intra) {
 639             block[i][0] = rec_intradc[i];
 640
 641         }
 642     }
 643
 644     if(interleaved_stats){
 645         if (!s->mb_intra) {
 646             s->p_tex_bits+= get_bits_diff(s);
 647             s->f_count++;
 648         }else{
 649             s->i_tex_bits+= get_bits_diff(s);
 650             s->i_count++;
 651         }
 652     }
 653 }
 654
 655 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
 656 {
 657     int range, bit_size, sign, code, bits;
 658
 659     if (val == 0) {
 660         /* zero vector */
 661         code = 0;
 662         put_bits(&s->pb, ff_mvtab[code][1], ff_mvtab[code][0]);
 663     } else {
 664         bit_size = f_code - 1;
 665         range = 1 << bit_size;
 666         /* modulo encoding */
 667         val = sign_extend(val, 6 + bit_size);
 668         sign = val>>31;
 669         val= (val^sign)-sign;
 670         sign&=1;
 671
 672         val--;
 673         code = (val >> bit_size) + 1;
 674         bits = val & (range - 1);
 675
 676         put_bits(&s->pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
 677         if (bit_size > 0) {
 678             put_bits(&s->pb, bit_size, bits);
 679         }
 680     }
 681 }
 682
 683 static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s)
 684 {
 685     int f_code;
 686     int mv;
 687
 688     for(f_code=1; f_code<=MAX_FCODE; f_code++){
 689         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
 690             int len;
 691
 692             if(mv==0) len= ff_mvtab[0][1];
 693             else{
 694                 int val, bit_size, code;
 695
 696                 bit_size = f_code - 1;
 697
 698                 val=mv;
 699                 if (val < 0)
 700                     val = -val;
 701                 val--;
 702                 code = (val >> bit_size) + 1;
 703                 if(code<33){
 704                     len= ff_mvtab[code][1] + 1 + bit_size;
 705                 }else{
 706                     len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
 707                 }
 708             }
 709
 710             mv_penalty[f_code][mv+MAX_MV]= len;
 711         }
 712     }
 713
 714     for(f_code=MAX_FCODE; f_code>0; f_code--){
 715         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
 716             fcode_tab[mv+MAX_MV]= f_code;
 717         }
 718     }
 719
 720     for(mv=0; mv<MAX_MV*2+1; mv++){
 721         umv_fcode_tab[mv]= 1;
 722     }
 723 }
 724
 725 static av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab,
 726                                          uint8_t *len_tab)
 727 {
 728     int slevel, run, last;
 729
 730     assert(MAX_LEVEL >= 64);
 731     assert(MAX_RUN   >= 63);
 732
 733     for(slevel=-64; slevel<64; slevel++){
 734         if(slevel==0) continue;
 735         for(run=0; run<64; run++){
 736             for(last=0; last<=1; last++){
 737                 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
 738                 int level= slevel < 0 ? -slevel : slevel;
 739                 int sign= slevel < 0 ? 1 : 0;
 740                 int bits, len, code;
 741
 742                 len_tab[index]= 100;
 743
 744                 /* ESC0 */
 745                 code= get_rl_index(rl, last, run, level);
 746                 bits= rl->table_vlc[code][0];
 747                 len=  rl->table_vlc[code][1];
 748                 bits=bits*2+sign; len++;
 749
 750                 if(code!=rl->n && len < len_tab[index]){
 751                     if(bits_tab) bits_tab[index]= bits;
 752                     len_tab [index]= len;
 753                 }
 754                 /* ESC */
 755                 bits= rl->table_vlc[rl->n][0];
 756                 len = rl->table_vlc[rl->n][1];
 757                 bits=bits*2+last; len++;
 758                 bits=bits*64+run; len+=6;
 759                 bits=bits*256+(level&0xff); len+=8;
 760
 761                 if(len < len_tab[index]){
 762                     if(bits_tab) bits_tab[index]= bits;
 763                     len_tab [index]= len;
 764                 }
 765             }
 766         }
 767     }
 768 }
 769
 770 av_cold void ff_h263_encode_init(MpegEncContext *s)
 771 {
 772     static int done = 0;
 773
 774     if (!done) {
 775         done = 1;
 776
 777         ff_init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
 778         ff_init_rl(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]);
 779
 780         init_uni_h263_rl_tab(&ff_rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
 781         init_uni_h263_rl_tab(&ff_h263_rl_inter    , NULL, uni_h263_inter_rl_len);
 782
 783         init_mv_penalty_and_fcode(s);
 784     }
 785     s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
 786
 787     s->intra_ac_vlc_length     =s->inter_ac_vlc_length     = uni_h263_inter_rl_len;
 788     s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
 789     if(s->h263_aic){
 790         s->intra_ac_vlc_length     = uni_h263_intra_aic_rl_len;
 791         s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
 792     }
 793     s->ac_esc_length= 7+1+6+8;
 794
 795     // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
 796     switch(s->codec_id){
 797     case AV_CODEC_ID_MPEG4:
 798         s->fcode_tab= fcode_tab;
 799         break;
 800     case AV_CODEC_ID_H263P:
 801         if(s->umvplus)
 802             s->fcode_tab= umv_fcode_tab;
 803         if(s->modified_quant){
 804             s->min_qcoeff= -2047;
 805             s->max_qcoeff=  2047;
 806         }else{
 807             s->min_qcoeff= -127;
 808             s->max_qcoeff=  127;
 809         }
 810         break;
 811         //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
 812     case AV_CODEC_ID_FLV1:
 813         if (s->h263_flv > 1) {
 814             s->min_qcoeff= -1023;
 815             s->max_qcoeff=  1023;
 816         } else {
 817             s->min_qcoeff= -127;
 818             s->max_qcoeff=  127;
 819         }
 820         s->y_dc_scale_table=
 821         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 822         break;
 823     default: //nothing needed - default table already set in mpegvideo.c
 824         s->min_qcoeff= -127;
 825         s->max_qcoeff=  127;
 826         s->y_dc_scale_table=
 827         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 828     }
 829 }
 830
 831 void ff_h263_encode_mba(MpegEncContext *s)
 832 {
 833     int i, mb_pos;
 834
 835     for(i=0; i<6; i++){
 836         if(s->mb_num-1 <= ff_mba_max[i]) break;
 837     }
 838     mb_pos= s->mb_x + s->mb_width*s->mb_y;
 839     put_bits(&s->pb, ff_mba_length[i], mb_pos);
 840 }