libavcodec/msmpeg4enc.c

   1 /*
   2  * MSMPEG4 encoder backend
   3  * Copyright (c) 2001 Fabrice Bellard
   4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * msmpeg4v1 & v2 stuff by 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  * MSMPEG4 encoder backend
  28  */
  29
  30 #include <stdint.h>
  31 #include <string.h>
  32
  33 #include "libavutil/avutil.h"
  34 #include "libavutil/mem.h"
  35 #include "mpegvideo.h"
  36 #include "msmpeg4.h"
  37 #include "h263.h"
  38 #include "mpeg4video.h"
  39 #include "msmpeg4.h"
  40 #include "msmpeg4data.h"
  41 #include "put_bits.h"
  42 #include "rl.h"
  43 #include "vc1data.h"
  44
  45 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
  46
  47 /* build the table which associate a (x,y) motion vector to a vlc */
  48 static void init_mv_table(MVTable *tab)
  49 {
  50     int i, x, y;
  51
  52     tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
  53     /* mark all entries as not used */
  54     for(i=0;i<4096;i++)
  55         tab->table_mv_index[i] = tab->n;
  56
  57     for(i=0;i<tab->n;i++) {
  58         x = tab->table_mvx[i];
  59         y = tab->table_mvy[i];
  60         tab->table_mv_index[(x << 6) | y] = i;
  61     }
  62 }
  63
  64 void ff_msmpeg4_code012(PutBitContext *pb, int n)
  65 {
  66     if (n == 0) {
  67         put_bits(pb, 1, 0);
  68     } else {
  69         put_bits(pb, 1, 1);
  70         put_bits(pb, 1, (n >= 2));
  71     }
  72 }
  73
  74 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
  75     int size=0;
  76     int code;
  77     int run_diff= intra ? 0 : 1;
  78
  79     code = get_rl_index(rl, last, run, level);
  80     size+= rl->table_vlc[code][1];
  81     if (code == rl->n) {
  82         int level1, run1;
  83
  84         level1 = level - rl->max_level[last][run];
  85         if (level1 < 1)
  86             goto esc2;
  87         code = get_rl_index(rl, last, run, level1);
  88         if (code == rl->n) {
  89             esc2:
  90             size++;
  91             if (level > MAX_LEVEL)
  92                 goto esc3;
  93             run1 = run - rl->max_run[last][level] - run_diff;
  94             if (run1 < 0)
  95                 goto esc3;
  96             code = get_rl_index(rl, last, run1, level);
  97             if (code == rl->n) {
  98             esc3:
  99                 /* third escape */
 100                 size+=1+1+6+8;
 101             } else {
 102                 /* second escape */
 103                 size+= 1+1+ rl->table_vlc[code][1];
 104             }
 105         } else {
 106             /* first escape */
 107             size+= 1+1+ rl->table_vlc[code][1];
 108         }
 109     } else {
 110         size++;
 111     }
 112     return size;
 113 }
 114
 115 av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)
 116 {
 117     static int init_done=0;
 118     int i;
 119
 120     ff_msmpeg4_common_init(s);
 121     if(s->msmpeg4_version>=4){
 122         s->min_qcoeff= -255;
 123         s->max_qcoeff=  255;
 124     }
 125
 126     if (!init_done) {
 127         /* init various encoding tables */
 128         init_done = 1;
 129         init_mv_table(&ff_mv_tables[0]);
 130         init_mv_table(&ff_mv_tables[1]);
 131         for(i=0;i<NB_RL_TABLES;i++)
 132             ff_init_rl(&ff_rl_table[i], ff_static_rl_table_store[i]);
 133
 134         for(i=0; i<NB_RL_TABLES; i++){
 135             int level;
 136             for (level = 1; level <= MAX_LEVEL; level++) {
 137                 int run;
 138                 for(run=0; run<=MAX_RUN; run++){
 139                     int last;
 140                     for(last=0; last<2; last++){
 141                         rl_length[i][level][run][last]= get_size_of_code(s, &ff_rl_table[  i], last, run, level, 0);
 142                     }
 143                 }
 144             }
 145         }
 146     }
 147 }
 148
 149 static void find_best_tables(MpegEncContext * s)
 150 {
 151     int i;
 152     int best       =-1, best_size       =9999999;
 153     int chroma_best=-1, best_chroma_size=9999999;
 154
 155     for(i=0; i<3; i++){
 156         int level;
 157         int chroma_size=0;
 158         int size=0;
 159
 160         if(i>0){// ;)
 161             size++;
 162             chroma_size++;
 163         }
 164         for(level=0; level<=MAX_LEVEL; level++){
 165             int run;
 166             for(run=0; run<=MAX_RUN; run++){
 167                 int last;
 168                 const int last_size= size + chroma_size;
 169                 for(last=0; last<2; last++){
 170                     int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
 171                     int intra_luma_count  = s->ac_stats[1][0][level][run][last];
 172                     int intra_chroma_count= s->ac_stats[1][1][level][run][last];
 173
 174                     if(s->pict_type==AV_PICTURE_TYPE_I){
 175                         size       += intra_luma_count  *rl_length[i  ][level][run][last];
 176                         chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
 177                     }else{
 178                         size+=        intra_luma_count  *rl_length[i  ][level][run][last]
 179                                      +intra_chroma_count*rl_length[i+3][level][run][last]
 180                                      +inter_count       *rl_length[i+3][level][run][last];
 181                     }
 182                 }
 183                 if(last_size == size+chroma_size) break;
 184             }
 185         }
 186         if(size<best_size){
 187             best_size= size;
 188             best= i;
 189         }
 190         if(chroma_size<best_chroma_size){
 191             best_chroma_size= chroma_size;
 192             chroma_best= i;
 193         }
 194     }
 195
 196     if(s->pict_type==AV_PICTURE_TYPE_P) chroma_best= best;
 197
 198     memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
 199
 200     s->rl_table_index       =        best;
 201     s->rl_chroma_table_index= chroma_best;
 202
 203     if(s->pict_type != s->last_non_b_pict_type){
 204         s->rl_table_index= 2;
 205         if(s->pict_type==AV_PICTURE_TYPE_I)
 206             s->rl_chroma_table_index= 1;
 207         else
 208             s->rl_chroma_table_index= 2;
 209     }
 210
 211 }
 212
 213 /* write MSMPEG4 compatible frame header */
 214 void ff_msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
 215 {
 216     find_best_tables(s);
 217
 218     avpriv_align_put_bits(&s->pb);
 219     put_bits(&s->pb, 2, s->pict_type - 1);
 220
 221     put_bits(&s->pb, 5, s->qscale);
 222     if(s->msmpeg4_version<=2){
 223         s->rl_table_index = 2;
 224         s->rl_chroma_table_index = 2;
 225     }
 226
 227     s->dc_table_index = 1;
 228     s->mv_table_index = 1; /* only if P frame */
 229     s->use_skip_mb_code = 1; /* only if P frame */
 230     s->per_mb_rl_table = 0;
 231     if(s->msmpeg4_version==4)
 232         s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==AV_PICTURE_TYPE_P);
 233     av_dlog(s, "%d %d %d %d %d\n", s->pict_type, s->bit_rate,
 234             s->inter_intra_pred, s->width, s->height);
 235
 236     if (s->pict_type == AV_PICTURE_TYPE_I) {
 237         s->slice_height= s->mb_height/1;
 238         put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
 239
 240         if(s->msmpeg4_version==4){
 241             ff_msmpeg4_encode_ext_header(s);
 242             if(s->bit_rate>MBAC_BITRATE)
 243                 put_bits(&s->pb, 1, s->per_mb_rl_table);
 244         }
 245
 246         if(s->msmpeg4_version>2){
 247             if(!s->per_mb_rl_table){
 248                 ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
 249                 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
 250             }
 251
 252             put_bits(&s->pb, 1, s->dc_table_index);
 253         }
 254     } else {
 255         put_bits(&s->pb, 1, s->use_skip_mb_code);
 256
 257         if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
 258             put_bits(&s->pb, 1, s->per_mb_rl_table);
 259
 260         if(s->msmpeg4_version>2){
 261             if(!s->per_mb_rl_table)
 262                 ff_msmpeg4_code012(&s->pb, s->rl_table_index);
 263
 264             put_bits(&s->pb, 1, s->dc_table_index);
 265
 266             put_bits(&s->pb, 1, s->mv_table_index);
 267         }
 268     }
 269
 270     s->esc3_level_length= 0;
 271     s->esc3_run_length= 0;
 272 }
 273
 274 void ff_msmpeg4_encode_ext_header(MpegEncContext * s)
 275 {
 276         put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
 277
 278         put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
 279
 280         if(s->msmpeg4_version>=3)
 281             put_bits(&s->pb, 1, s->flipflop_rounding);
 282         else
 283             assert(s->flipflop_rounding==0);
 284 }
 285
 286 void ff_msmpeg4_encode_motion(MpegEncContext * s,
 287                                   int mx, int my)
 288 {
 289     int code;
 290     MVTable *mv;
 291
 292     /* modulo encoding */
 293     /* WARNING : you cannot reach all the MVs even with the modulo
 294        encoding. This is a somewhat strange compromise they took !!!  */
 295     if (mx <= -64)
 296         mx += 64;
 297     else if (mx >= 64)
 298         mx -= 64;
 299     if (my <= -64)
 300         my += 64;
 301     else if (my >= 64)
 302         my -= 64;
 303
 304     mx += 32;
 305     my += 32;
 306 #if 0
 307     if ((unsigned)mx >= 64 ||
 308         (unsigned)my >= 64)
 309         av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
 310 #endif
 311     mv = &ff_mv_tables[s->mv_table_index];
 312
 313     code = mv->table_mv_index[(mx << 6) | my];
 314     put_bits(&s->pb,
 315              mv->table_mv_bits[code],
 316              mv->table_mv_code[code]);
 317     if (code == mv->n) {
 318         /* escape : code literally */
 319         put_bits(&s->pb, 6, mx);
 320         put_bits(&s->pb, 6, my);
 321     }
 322 }
 323
 324 void ff_msmpeg4_handle_slices(MpegEncContext *s){
 325     if (s->mb_x == 0) {
 326         if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
 327             if(s->msmpeg4_version < 4){
 328                 ff_mpeg4_clean_buffers(s);
 329             }
 330             s->first_slice_line = 1;
 331         } else {
 332             s->first_slice_line = 0;
 333         }
 334     }
 335 }
 336
 337 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
 338 {
 339     int range, bit_size, sign, code, bits;
 340
 341     if (val == 0) {
 342         /* zero vector */
 343         code = 0;
 344         put_bits(&s->pb, ff_mvtab[code][1], ff_mvtab[code][0]);
 345     } else {
 346         bit_size = s->f_code - 1;
 347         range = 1 << bit_size;
 348         if (val <= -64)
 349             val += 64;
 350         else if (val >= 64)
 351             val -= 64;
 352
 353         if (val >= 0) {
 354             sign = 0;
 355         } else {
 356             val = -val;
 357             sign = 1;
 358         }
 359         val--;
 360         code = (val >> bit_size) + 1;
 361         bits = val & (range - 1);
 362
 363         put_bits(&s->pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
 364         if (bit_size > 0) {
 365             put_bits(&s->pb, bit_size, bits);
 366         }
 367     }
 368 }
 369
 370 void ff_msmpeg4_encode_mb(MpegEncContext * s,
 371                           int16_t block[6][64],
 372                           int motion_x, int motion_y)
 373 {
 374     int cbp, coded_cbp, i;
 375     int pred_x, pred_y;
 376     uint8_t *coded_block;
 377
 378     ff_msmpeg4_handle_slices(s);
 379
 380     if (!s->mb_intra) {
 381         /* compute cbp */
 382         cbp = 0;
 383         for (i = 0; i < 6; i++) {
 384             if (s->block_last_index[i] >= 0)
 385                 cbp |= 1 << (5 - i);
 386         }
 387         if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
 388             /* skip macroblock */
 389             put_bits(&s->pb, 1, 1);
 390             s->last_bits++;
 391             s->misc_bits++;
 392             s->skip_count++;
 393
 394             return;
 395         }
 396         if (s->use_skip_mb_code)
 397             put_bits(&s->pb, 1, 0);     /* mb coded */
 398
 399         if(s->msmpeg4_version<=2){
 400             put_bits(&s->pb,
 401                      ff_v2_mb_type[cbp&3][1],
 402                      ff_v2_mb_type[cbp&3][0]);
 403             if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
 404             else             coded_cbp= cbp;
 405
 406             put_bits(&s->pb,
 407                      ff_h263_cbpy_tab[coded_cbp>>2][1],
 408                      ff_h263_cbpy_tab[coded_cbp>>2][0]);
 409
 410             s->misc_bits += get_bits_diff(s);
 411
 412             ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 413             msmpeg4v2_encode_motion(s, motion_x - pred_x);
 414             msmpeg4v2_encode_motion(s, motion_y - pred_y);
 415         }else{
 416             put_bits(&s->pb,
 417                      ff_table_mb_non_intra[cbp + 64][1],
 418                      ff_table_mb_non_intra[cbp + 64][0]);
 419
 420             s->misc_bits += get_bits_diff(s);
 421
 422             /* motion vector */
 423             ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 424             ff_msmpeg4_encode_motion(s, motion_x - pred_x,
 425                                   motion_y - pred_y);
 426         }
 427
 428         s->mv_bits += get_bits_diff(s);
 429
 430         for (i = 0; i < 6; i++) {
 431             ff_msmpeg4_encode_block(s, block[i], i);
 432         }
 433         s->p_tex_bits += get_bits_diff(s);
 434     } else {
 435         /* compute cbp */
 436         cbp = 0;
 437         coded_cbp = 0;
 438         for (i = 0; i < 6; i++) {
 439             int val, pred;
 440             val = (s->block_last_index[i] >= 1);
 441             cbp |= val << (5 - i);
 442             if (i < 4) {
 443                 /* predict value for close blocks only for luma */
 444                 pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
 445                 *coded_block = val;
 446                 val = val ^ pred;
 447             }
 448             coded_cbp |= val << (5 - i);
 449         }
 450
 451         if(s->msmpeg4_version<=2){
 452             if (s->pict_type == AV_PICTURE_TYPE_I) {
 453                 put_bits(&s->pb,
 454                          ff_v2_intra_cbpc[cbp&3][1], ff_v2_intra_cbpc[cbp&3][0]);
 455             } else {
 456                 if (s->use_skip_mb_code)
 457                     put_bits(&s->pb, 1, 0);     /* mb coded */
 458                 put_bits(&s->pb,
 459                          ff_v2_mb_type[(cbp&3) + 4][1],
 460                          ff_v2_mb_type[(cbp&3) + 4][0]);
 461             }
 462             put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
 463             put_bits(&s->pb,
 464                      ff_h263_cbpy_tab[cbp>>2][1],
 465                      ff_h263_cbpy_tab[cbp>>2][0]);
 466         }else{
 467             if (s->pict_type == AV_PICTURE_TYPE_I) {
 468                 put_bits(&s->pb,
 469                          ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
 470             } else {
 471                 if (s->use_skip_mb_code)
 472                     put_bits(&s->pb, 1, 0);     /* mb coded */
 473                 put_bits(&s->pb,
 474                          ff_table_mb_non_intra[cbp][1],
 475                          ff_table_mb_non_intra[cbp][0]);
 476             }
 477             put_bits(&s->pb, 1, 0);             /* no AC prediction yet */
 478             if(s->inter_intra_pred){
 479                 s->h263_aic_dir=0;
 480                 put_bits(&s->pb, ff_table_inter_intra[s->h263_aic_dir][1], ff_table_inter_intra[s->h263_aic_dir][0]);
 481             }
 482         }
 483         s->misc_bits += get_bits_diff(s);
 484
 485         for (i = 0; i < 6; i++) {
 486             ff_msmpeg4_encode_block(s, block[i], i);
 487         }
 488         s->i_tex_bits += get_bits_diff(s);
 489         s->i_count++;
 490     }
 491 }
 492
 493 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
 494 {
 495     int sign, code;
 496     int pred, extquant;
 497     int extrabits = 0;
 498
 499     int16_t *dc_val;
 500     pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
 501
 502     /* update predictor */
 503     if (n < 4) {
 504         *dc_val = level * s->y_dc_scale;
 505     } else {
 506         *dc_val = level * s->c_dc_scale;
 507     }
 508
 509     /* do the prediction */
 510     level -= pred;
 511
 512     if(s->msmpeg4_version<=2){
 513         if (n < 4) {
 514             put_bits(&s->pb,
 515                      ff_v2_dc_lum_table[level + 256][1],
 516                      ff_v2_dc_lum_table[level + 256][0]);
 517         }else{
 518             put_bits(&s->pb,
 519                      ff_v2_dc_chroma_table[level + 256][1],
 520                      ff_v2_dc_chroma_table[level + 256][0]);
 521         }
 522     }else{
 523         sign = 0;
 524         if (level < 0) {
 525             level = -level;
 526             sign = 1;
 527         }
 528         code = level;
 529         if (code > DC_MAX)
 530             code = DC_MAX;
 531         else if( s->msmpeg4_version>=6 ) {
 532             if( s->qscale == 1 ) {
 533                 extquant = (level + 3) & 0x3;
 534                 code  = ((level+3)>>2);
 535             } else if( s->qscale == 2 ) {
 536                 extquant = (level + 1) & 0x1;
 537                 code  = ((level+1)>>1);
 538             }
 539         }
 540
 541         if (s->dc_table_index == 0) {
 542             if (n < 4) {
 543                 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
 544             } else {
 545                 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
 546             }
 547         } else {
 548             if (n < 4) {
 549                 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
 550             } else {
 551                 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
 552             }
 553         }
 554
 555         if(s->msmpeg4_version>=6 && s->qscale<=2)
 556             extrabits = 3 - s->qscale;
 557
 558         if (code == DC_MAX)
 559             put_bits(&s->pb, 8 + extrabits, level);
 560         else if(extrabits > 0)//== VC1 && s->qscale<=2
 561             put_bits(&s->pb, extrabits, extquant);
 562
 563         if (level != 0) {
 564             put_bits(&s->pb, 1, sign);
 565         }
 566     }
 567 }
 568
 569 /* Encoding of a block. Very similar to MPEG4 except for a different
 570    escape coding (same as H263) and more vlc tables.
 571  */
 572 void ff_msmpeg4_encode_block(MpegEncContext * s, int16_t * block, int n)
 573 {
 574     int level, run, last, i, j, last_index;
 575     int last_non_zero, sign, slevel;
 576     int code, run_diff, dc_pred_dir;
 577     const RLTable *rl;
 578     const uint8_t *scantable;
 579
 580     if (s->mb_intra) {
 581         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
 582         i = 1;
 583         if (n < 4) {
 584             rl = &ff_rl_table[s->rl_table_index];
 585         } else {
 586             rl = &ff_rl_table[3 + s->rl_chroma_table_index];
 587         }
 588         run_diff = s->msmpeg4_version>=4;
 589         scantable= s->intra_scantable.permutated;
 590     } else {
 591         i = 0;
 592         rl = &ff_rl_table[3 + s->rl_table_index];
 593         if(s->msmpeg4_version<=2)
 594             run_diff = 0;
 595         else
 596             run_diff = 1;
 597         scantable= s->inter_scantable.permutated;
 598     }
 599
 600     /* recalculate block_last_index for M$ wmv1 */
 601     if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
 602         for(last_index=63; last_index>=0; last_index--){
 603             if(block[scantable[last_index]]) break;
 604         }
 605         s->block_last_index[n]= last_index;
 606     }else
 607         last_index = s->block_last_index[n];
 608     /* AC coefs */
 609     last_non_zero = i - 1;
 610     for (; i <= last_index; i++) {
 611         j = scantable[i];
 612         level = block[j];
 613         if (level) {
 614             run = i - last_non_zero - 1;
 615             last = (i == last_index);
 616             sign = 0;
 617             slevel = level;
 618             if (level < 0) {
 619                 sign = 1;
 620                 level = -level;
 621             }
 622
 623             if(level<=MAX_LEVEL && run<=MAX_RUN){
 624                 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
 625             }
 626
 627             s->ac_stats[s->mb_intra][n > 3][40][63][0]++; //esc3 like
 628
 629             code = get_rl_index(rl, last, run, level);
 630             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 631             if (code == rl->n) {
 632                 int level1, run1;
 633
 634                 level1 = level - rl->max_level[last][run];
 635                 if (level1 < 1)
 636                     goto esc2;
 637                 code = get_rl_index(rl, last, run, level1);
 638                 if (code == rl->n) {
 639                 esc2:
 640                     put_bits(&s->pb, 1, 0);
 641                     if (level > MAX_LEVEL)
 642                         goto esc3;
 643                     run1 = run - rl->max_run[last][level] - run_diff;
 644                     if (run1 < 0)
 645                         goto esc3;
 646                     code = get_rl_index(rl, last, run1+1, level);
 647                     if (s->msmpeg4_version == 4 && code == rl->n)
 648                         goto esc3;
 649                     code = get_rl_index(rl, last, run1, level);
 650                     if (code == rl->n) {
 651                     esc3:
 652                         /* third escape */
 653                         put_bits(&s->pb, 1, 0);
 654                         put_bits(&s->pb, 1, last);
 655                         if(s->msmpeg4_version>=4){
 656                             if(s->esc3_level_length==0){
 657                                 s->esc3_level_length=8;
 658                                 s->esc3_run_length= 6;
 659                                 //ESCLVLSZ + ESCRUNSZ
 660                                 if(s->qscale<8)
 661                                     put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
 662                                 else
 663                                     put_bits(&s->pb, 8, 3);
 664                             }
 665                             put_bits(&s->pb, s->esc3_run_length, run);
 666                             put_bits(&s->pb, 1, sign);
 667                             put_bits(&s->pb, s->esc3_level_length, level);
 668                         }else{
 669                             put_bits(&s->pb, 6, run);
 670                             put_sbits(&s->pb, 8, slevel);
 671                         }
 672                     } else {
 673                         /* second escape */
 674                         put_bits(&s->pb, 1, 1);
 675                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 676                         put_bits(&s->pb, 1, sign);
 677                     }
 678                 } else {
 679                     /* first escape */
 680                     put_bits(&s->pb, 1, 1);
 681                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 682                     put_bits(&s->pb, 1, sign);
 683                 }
 684             } else {
 685                 put_bits(&s->pb, 1, sign);
 686             }
 687             last_non_zero = i;
 688         }
 689     }
 690 }