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

   1 /*
   2  * ITU H263 bitstream encoder
   3  * Copyright (c) 2000,2001 Fabrice Bellard
   4  * H263+ support.
   5  * Copyright (c) 2001 Juan J. Sierralta P
   6  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file
  27  * h263 bitstream encoder.
  28  */
  29
  30 #include <limits.h>
  31
  32 #include "libavutil/attributes.h"
  33 #include "avcodec.h"
  34 #include "mpegvideo.h"
  35 #include "h263.h"
  36 #include "mathops.h"
  37 #include "unary.h"
  38 #include "flv.h"
  39 #include "mpeg4video.h"
  40 #include "internal.h"
  41
  42 /**
  43  * Table of number of bits a motion vector component needs.
  44  */
  45 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
  46
  47 /**
  48  * Minimal fcode that a motion vector component would need.
  49  */
  50 static uint8_t fcode_tab[MAX_MV*2+1];
  51
  52 /**
  53  * Minimal fcode that a motion vector component would need in umv.
  54  * All entries in this table are 1.
  55  */
  56 static uint8_t umv_fcode_tab[MAX_MV*2+1];
  57
  58 //unified encoding tables for run length encoding of coefficients
  59 //unified in the sense that the specification specifies the encoding in several steps.
  60 static uint8_t  uni_h263_intra_aic_rl_len [64*64*2*2];
  61 static uint8_t  uni_h263_inter_rl_len [64*64*2*2];
  62 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
  63 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
  64 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
  65
  66 static const uint8_t wrong_run[102] = {
  67  1,  2,  3,  5,  4, 10,  9,  8,
  68 11, 15, 17, 16, 23, 22, 21, 20,
  69 19, 18, 25, 24, 27, 26, 11,  7,
  70  6,  1,  2, 13,  2,  2,  2,  2,
  71  6, 12,  3,  9,  1,  3,  4,  3,
  72  7,  4,  1,  1,  5,  5, 14,  6,
  73  1,  7,  1,  8,  1,  1,  1,  1,
  74 10,  1,  1,  5,  9, 17, 25, 24,
  75 29, 33, 32, 41,  2, 23, 28, 31,
  76  3, 22, 30,  4, 27, 40,  8, 26,
  77  6, 39,  7, 38, 16, 37, 15, 10,
  78 11, 12, 13, 14,  1, 21, 20, 18,
  79 19,  2,  1, 34, 35, 36
  80 };
  81
  82 /**
  83  * Return the 4 bit value that specifies the given aspect ratio.
  84  * This may be one of the standard aspect ratios or it specifies
  85  * that the aspect will be stored explicitly later.
  86  */
  87 av_const int ff_h263_aspect_to_info(AVRational aspect){
  88     int i;
  89
  90     if(aspect.num==0) aspect= (AVRational){1,1};
  91
  92     for(i=1; i<6; i++){
  93         if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
  94             return i;
  95         }
  96     }
  97
  98     return FF_ASPECT_EXTENDED;
  99 }
 100
 101 void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number)
 102 {
 103     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
 104     int best_clock_code=1;
 105     int best_divisor=60;
 106     int best_error= INT_MAX;
 107
 108     if(s->h263_plus){
 109         for(i=0; i<2; i++){
 110             int div, error;
 111             div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
 112             div= av_clip(div, 1, 127);
 113             error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
 114             if(error < best_error){
 115                 best_error= error;
 116                 best_divisor= div;
 117                 best_clock_code= i;
 118             }
 119         }
 120     }
 121     s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
 122     coded_frame_rate= 1800000;
 123     coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
 124
 125     avpriv_align_put_bits(&s->pb);
 126
 127     /* Update the pointer to last GOB */
 128     s->ptr_lastgob = put_bits_ptr(&s->pb);
 129     put_bits(&s->pb, 22, 0x20); /* PSC */
 130     temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
 131                          (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
 132     put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
 133
 134     put_bits(&s->pb, 1, 1);     /* marker */
 135     put_bits(&s->pb, 1, 0);     /* h263 id */
 136     put_bits(&s->pb, 1, 0);     /* split screen off */
 137     put_bits(&s->pb, 1, 0);     /* camera  off */
 138     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
 139
 140     format = ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format), s->width, s->height);
 141     if (!s->h263_plus) {
 142         /* H.263v1 */
 143         put_bits(&s->pb, 3, format);
 144         put_bits(&s->pb, 1, (s->pict_type == AV_PICTURE_TYPE_P));
 145         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
 146         of H.263v1 UMV implies to check the predicted MV after
 147         calculation of the current MB to see if we're on the limits */
 148         put_bits(&s->pb, 1, 0);         /* Unrestricted Motion Vector: off */
 149         put_bits(&s->pb, 1, 0);         /* SAC: off */
 150         put_bits(&s->pb, 1, s->obmc);   /* Advanced Prediction */
 151         put_bits(&s->pb, 1, 0);         /* only I/P frames, no PB frame */
 152         put_bits(&s->pb, 5, s->qscale);
 153         put_bits(&s->pb, 1, 0);         /* Continuous Presence Multipoint mode: off */
 154     } else {
 155         int ufep=1;
 156         /* H.263v2 */
 157         /* H.263 Plus PTYPE */
 158
 159         put_bits(&s->pb, 3, 7);
 160         put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
 161         if (format == 8)
 162             put_bits(&s->pb,3,6); /* Custom Source Format */
 163         else
 164             put_bits(&s->pb, 3, format);
 165
 166         put_bits(&s->pb,1, s->custom_pcf);
 167         put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
 168         put_bits(&s->pb,1,0); /* SAC: off */
 169         put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
 170         put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
 171         put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
 172         put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
 173         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
 174         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
 175         put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
 176         put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
 177         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 178         put_bits(&s->pb,3,0); /* Reserved */
 179
 180         put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P);
 181
 182         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
 183         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
 184         put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
 185         put_bits(&s->pb,2,0); /* Reserved */
 186         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 187
 188         /* This should be here if PLUSPTYPE */
 189         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
 190
 191         if (format == 8) {
 192             /* Custom Picture Format (CPFMT) */
 193             s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
 194
 195             put_bits(&s->pb,4,s->aspect_ratio_info);
 196             put_bits(&s->pb,9,(s->width >> 2) - 1);
 197             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 198             put_bits(&s->pb,9,(s->height >> 2));
 199             if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
 200                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
 201                 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
 202             }
 203         }
 204         if(s->custom_pcf){
 205             if(ufep){
 206                 put_bits(&s->pb, 1, best_clock_code);
 207                 put_bits(&s->pb, 7, best_divisor);
 208             }
 209             put_sbits(&s->pb, 2, temp_ref>>8);
 210         }
 211
 212         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
 213         if (s->umvplus)
 214 //            put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
 215 //FIXME check actual requested range
 216             put_bits(&s->pb,2,1); /* unlimited */
 217         if(s->h263_slice_structured)
 218             put_bits(&s->pb,2,0); /* no weird submodes */
 219
 220         put_bits(&s->pb, 5, s->qscale);
 221     }
 222
 223     put_bits(&s->pb, 1, 0);     /* no PEI */
 224
 225     if(s->h263_slice_structured){
 226         put_bits(&s->pb, 1, 1);
 227
 228         av_assert1(s->mb_x == 0 && s->mb_y == 0);
 229         ff_h263_encode_mba(s);
 230
 231         put_bits(&s->pb, 1, 1);
 232     }
 233
 234     if(s->h263_aic){
 235          s->y_dc_scale_table=
 236          s->c_dc_scale_table= ff_aic_dc_scale_table;
 237     }else{
 238         s->y_dc_scale_table=
 239         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 240     }
 241 }
 242
 243 /**
 244  * Encode a group of blocks header.
 245  */
 246 void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line)
 247 {
 248     put_bits(&s->pb, 17, 1); /* GBSC */
 249
 250     if(s->h263_slice_structured){
 251         put_bits(&s->pb, 1, 1);
 252
 253         ff_h263_encode_mba(s);
 254
 255         if(s->mb_num > 1583)
 256             put_bits(&s->pb, 1, 1);
 257         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 258         put_bits(&s->pb, 1, 1);
 259         put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
 260     }else{
 261         int gob_number= mb_line / s->gob_index;
 262
 263         put_bits(&s->pb, 5, gob_number); /* GN */
 264         put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
 265         put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 266     }
 267 }
 268
 269 /**
 270  * modify qscale so that encoding is actually possible in h263 (limit difference to -2..2)
 271  */
 272 void ff_clean_h263_qscales(MpegEncContext *s){
 273     int i;
 274     int8_t * const qscale_table = s->current_picture.qscale_table;
 275
 276     ff_init_qscale_tab(s);
 277
 278     for(i=1; i<s->mb_num; i++){
 279         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
 280             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
 281     }
 282     for(i=s->mb_num-2; i>=0; i--){
 283         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
 284             qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
 285     }
 286
 287     if(s->codec_id != AV_CODEC_ID_H263P){
 288         for(i=1; i<s->mb_num; i++){
 289             int mb_xy= s->mb_index2xy[i];
 290
 291             if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
 292                 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
 293             }
 294         }
 295     }
 296 }
 297
 298 static const int dquant_code[5]= {1,0,9,2,3};
 299
 300 /**
 301  * Encode an 8x8 block.
 302  * @param block the 8x8 block
 303  * @param n block index (0-3 are luma, 4-5 are chroma)
 304  */
 305 static void h263_encode_block(MpegEncContext * s, int16_t * block, int n)
 306 {
 307     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
 308     RLTable *rl;
 309
 310     rl = &ff_h263_rl_inter;
 311     if (s->mb_intra && !s->h263_aic) {
 312         /* DC coef */
 313         level = block[0];
 314         /* 255 cannot be represented, so we clamp */
 315         if (level > 254) {
 316             level = 254;
 317             block[0] = 254;
 318         }
 319         /* 0 cannot be represented also */
 320         else if (level < 1) {
 321             level = 1;
 322             block[0] = 1;
 323         }
 324         if (level == 128) //FIXME check rv10
 325             put_bits(&s->pb, 8, 0xff);
 326         else
 327             put_bits(&s->pb, 8, level);
 328         i = 1;
 329     } else {
 330         i = 0;
 331         if (s->h263_aic && s->mb_intra)
 332             rl = &ff_rl_intra_aic;
 333
 334         if(s->alt_inter_vlc && !s->mb_intra){
 335             int aic_vlc_bits=0;
 336             int inter_vlc_bits=0;
 337             int wrong_pos=-1;
 338             int aic_code;
 339
 340             last_index = s->block_last_index[n];
 341             last_non_zero = i - 1;
 342             for (; i <= last_index; i++) {
 343                 j = s->intra_scantable.permutated[i];
 344                 level = block[j];
 345                 if (level) {
 346                     run = i - last_non_zero - 1;
 347                     last = (i == last_index);
 348
 349                     if(level<0) level= -level;
 350
 351                     code = get_rl_index(rl, last, run, level);
 352                     aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
 353                     inter_vlc_bits += rl->table_vlc[code][1]+1;
 354                     aic_vlc_bits   += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
 355
 356                     if (code == rl->n) {
 357                         inter_vlc_bits += 1+6+8-1;
 358                     }
 359                     if (aic_code == ff_rl_intra_aic.n) {
 360                         aic_vlc_bits += 1+6+8-1;
 361                         wrong_pos += run + 1;
 362                     }else
 363                         wrong_pos += wrong_run[aic_code];
 364                     last_non_zero = i;
 365                 }
 366             }
 367             i = 0;
 368             if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
 369                 rl = &ff_rl_intra_aic;
 370         }
 371     }
 372
 373     /* AC coefs */
 374     last_index = s->block_last_index[n];
 375     last_non_zero = i - 1;
 376     for (; i <= last_index; i++) {
 377         j = s->intra_scantable.permutated[i];
 378         level = block[j];
 379         if (level) {
 380             run = i - last_non_zero - 1;
 381             last = (i == last_index);
 382             sign = 0;
 383             slevel = level;
 384             if (level < 0) {
 385                 sign = 1;
 386                 level = -level;
 387             }
 388             code = get_rl_index(rl, last, run, level);
 389             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 390             if (code == rl->n) {
 391               if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
 392                 put_bits(&s->pb, 1, last);
 393                 put_bits(&s->pb, 6, run);
 394
 395                 av_assert2(slevel != 0);
 396
 397                 if(level < 128)
 398                     put_sbits(&s->pb, 8, slevel);
 399                 else{
 400                     put_bits(&s->pb, 8, 128);
 401                     put_sbits(&s->pb, 5, slevel);
 402                     put_sbits(&s->pb, 6, slevel>>5);
 403                 }
 404               }else{
 405                     ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
 406               }
 407             } else {
 408                 put_bits(&s->pb, 1, sign);
 409             }
 410             last_non_zero = i;
 411         }
 412     }
 413 }
 414
 415 /* Encode MV differences on H.263+ with Unrestricted MV mode */
 416 static void h263p_encode_umotion(MpegEncContext * s, int val)
 417 {
 418     short sval = 0;
 419     short i = 0;
 420     short n_bits = 0;
 421     short temp_val;
 422     int code = 0;
 423     int tcode;
 424
 425     if ( val == 0)
 426         put_bits(&s->pb, 1, 1);
 427     else if (val == 1)
 428         put_bits(&s->pb, 3, 0);
 429     else if (val == -1)
 430         put_bits(&s->pb, 3, 2);
 431     else {
 432
 433         sval = ((val < 0) ? (short)(-val):(short)val);
 434         temp_val = sval;
 435
 436         while (temp_val != 0) {
 437             temp_val = temp_val >> 1;
 438             n_bits++;
 439         }
 440
 441         i = n_bits - 1;
 442         while (i > 0) {
 443             tcode = (sval & (1 << (i-1))) >> (i-1);
 444             tcode = (tcode << 1) | 1;
 445             code = (code << 2) | tcode;
 446             i--;
 447         }
 448         code = ((code << 1) | (val < 0)) << 1;
 449         put_bits(&s->pb, (2*n_bits)+1, code);
 450     }
 451 }
 452
 453 void ff_h263_encode_mb(MpegEncContext * s,
 454                        int16_t block[6][64],
 455                        int motion_x, int motion_y)
 456 {
 457     int cbpc, cbpy, i, cbp, pred_x, pred_y;
 458     int16_t pred_dc;
 459     int16_t rec_intradc[6];
 460     int16_t *dc_ptr[6];
 461     const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
 462
 463     if (!s->mb_intra) {
 464         /* compute cbp */
 465         cbp= get_p_cbp(s, block, motion_x, motion_y);
 466
 467         if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
 468             /* skip macroblock */
 469             put_bits(&s->pb, 1, 1);
 470             if(interleaved_stats){
 471                 s->misc_bits++;
 472                 s->last_bits++;
 473             }
 474             s->skip_count++;
 475
 476             return;
 477         }
 478         put_bits(&s->pb, 1, 0);         /* mb coded */
 479
 480         cbpc = cbp & 3;
 481         cbpy = cbp >> 2;
 482         if(s->alt_inter_vlc==0 || cbpc!=3)
 483             cbpy ^= 0xF;
 484         if(s->dquant) cbpc+= 8;
 485         if(s->mv_type==MV_TYPE_16X16){
 486             put_bits(&s->pb,
 487                     ff_h263_inter_MCBPC_bits[cbpc],
 488                     ff_h263_inter_MCBPC_code[cbpc]);
 489
 490             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
 491             if(s->dquant)
 492                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 493
 494             if(interleaved_stats){
 495                 s->misc_bits+= get_bits_diff(s);
 496             }
 497
 498             /* motion vectors: 16x16 mode */
 499             ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 500
 501             if (!s->umvplus) {
 502                 ff_h263_encode_motion_vector(s, motion_x - pred_x,
 503                                                 motion_y - pred_y, 1);
 504             }
 505             else {
 506                 h263p_encode_umotion(s, motion_x - pred_x);
 507                 h263p_encode_umotion(s, motion_y - pred_y);
 508                 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 509                     /* To prevent Start Code emulation */
 510                     put_bits(&s->pb,1,1);
 511             }
 512         }else{
 513             put_bits(&s->pb,
 514                     ff_h263_inter_MCBPC_bits[cbpc+16],
 515                     ff_h263_inter_MCBPC_code[cbpc+16]);
 516             put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
 517             if(s->dquant)
 518                 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
 519
 520             if(interleaved_stats){
 521                 s->misc_bits+= get_bits_diff(s);
 522             }
 523
 524             for(i=0; i<4; i++){
 525                 /* motion vectors: 8x8 mode*/
 526                 ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
 527
 528                 motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];
 529                 motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];
 530                 if (!s->umvplus) {
 531                     ff_h263_encode_motion_vector(s, motion_x - pred_x,
 532                                                     motion_y - pred_y, 1);
 533                 }
 534                 else {
 535                     h263p_encode_umotion(s, motion_x - pred_x);
 536                     h263p_encode_umotion(s, motion_y - pred_y);
 537                     if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 538                         /* To prevent Start Code emulation */
 539                         put_bits(&s->pb,1,1);
 540                 }
 541             }
 542         }
 543
 544         if(interleaved_stats){
 545             s->mv_bits+= get_bits_diff(s);
 546         }
 547     } else {
 548         av_assert2(s->mb_intra);
 549
 550         cbp = 0;
 551         if (s->h263_aic) {
 552             /* Predict DC */
 553             for(i=0; i<6; i++) {
 554                 int16_t level = block[i][0];
 555                 int scale;
 556
 557                 if(i<4) scale= s->y_dc_scale;
 558                 else    scale= s->c_dc_scale;
 559
 560                 pred_dc = ff_h263_pred_dc(s, i, &dc_ptr[i]);
 561                 level -= pred_dc;
 562                 /* Quant */
 563                 if (level >= 0)
 564                     level = (level + (scale>>1))/scale;
 565                 else
 566                     level = (level - (scale>>1))/scale;
 567
 568                 /* AIC can change CBP */
 569                 if (level == 0 && s->block_last_index[i] == 0)
 570                     s->block_last_index[i] = -1;
 571
 572                 if(!s->modified_quant){
 573                     if (level < -127)
 574                         level = -127;
 575                     else if (level > 127)
 576                         level = 127;
 577                 }
 578
 579                 block[i][0] = level;
 580                 /* Reconstruction */
 581                 rec_intradc[i] = scale*level + pred_dc;
 582                 /* Oddify */
 583                 rec_intradc[i] |= 1;
 584                 //if ((rec_intradc[i] % 2) == 0)
 585                 //    rec_intradc[i]++;
 586                 /* Clipping */
 587                 if (rec_intradc[i] < 0)
 588                     rec_intradc[i] = 0;
 589                 else if (rec_intradc[i] > 2047)
 590                     rec_intradc[i] = 2047;
 591
 592                 /* Update AC/DC tables */
 593                 *dc_ptr[i] = rec_intradc[i];
 594                 if (s->block_last_index[i] >= 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     av_assert0(MAX_LEVEL >= 64);
 730     av_assert0(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_init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
 777         ff_init_rl(&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 }