git.sesse.net Git - vlc/blob - modules/stream_out/transrate/frame.c

   1 /*****************************************************************************
   2  * frame.c: MPEG2 video transrating module
   3  *****************************************************************************
   4  * Copyright (C) 2003 VideoLAN
   5  * Copyright (C) 2003 Antoine Missout
   6  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
   7  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
   8  * $Id: frame.c,v 1.2 2004/03/03 11:39:06 massiot Exp $
   9  *
  10  * Authors: Christophe Massiot <massiot@via.ecp.fr>
  11  *          Laurent Aimar <fenrir@via.ecp.fr>
  12  *          Antoine Missout
  13  *          Michel Lespinasse <walken@zoy.org>
  14  *          Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  15  *
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  29  *****************************************************************************/
  30
  31 /*****************************************************************************
  32  * Preamble
  33  *****************************************************************************/
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #define NDEBUG 1
  37 #include <assert.h>
  38 #include <math.h>
  39
  40 #include <vlc/vlc.h>
  41 #include <vlc/sout.h>
  42 #include <vlc/input.h>
  43
  44 #include "transrate.h"
  45
  46 /****************************************************************************
  47  * transrater, code from M2VRequantizer http://www.metakine.com/
  48  ****************************************************************************/
  49
  50 /* This is awful magic --Meuuh */
  51 //#define REACT_DELAY (1024.0*128.0)
  52 #define REACT_DELAY (256.0)
  53
  54 #define QUANT_I (1.7)
  55
  56 #define QUANT_P (1.4)
  57
  58 #define QUANT_P_INC (0.1)
  59
  60 #define B_HANDICAP 5
  61
  62 // notes:
  63 //
  64 // - intra block:
  65 //      - the quantiser is increment by one step
  66 //
  67 // - non intra block:
  68 //      - in P_FRAME we keep the original quantiser but drop the last coefficient
  69 //        if there is more than one
  70 //      - in B_FRAME we multiply the quantiser by a factor
  71 //
  72 // - I_FRAME is recoded when we're 5.0 * REACT_DELAY late
  73 // - P_FRAME is recoded when we're 2.5 * REACT_DELAY late
  74 // - B_FRAME are always recoded
  75
  76 // if we're getting *very* late (60 * REACT_DELAY)
  77 //
  78 // - intra blocks quantiser is incremented two step
  79 // - drop a few coefficients but always keep the first one
  80
  81 // useful constants
  82 enum
  83 {
  84     I_TYPE = 1,
  85     P_TYPE = 2,
  86     B_TYPE = 3
  87 };
  88
  89
  90 // gcc
  91 #ifdef HAVE_BUILTIN_EXPECT
  92 #define likely(x) __builtin_expect ((x) != 0, 1)
  93 #define unlikely(x) __builtin_expect ((x) != 0, 0)
  94 #else
  95 #define likely(x) (x)
  96 #define unlikely(x) (x)
  97 #endif
  98
  99 #define BITS_IN_BUF (8)
 100
 101 #define LOG(msg) fprintf (stderr, msg)
 102 #define LOGF(format, args...) fprintf (stderr, format, args)
 103
 104 static inline void bs_write( bs_transrate_t *s, unsigned int val, int n)
 105 {
 106     assert(n < 32);
 107     assert(!(val & (0xffffffffU << n)));
 108
 109     while (unlikely(n >= s->i_bit_out))
 110     {
 111         s->p_w[0] = (s->i_bit_out_cache << s->i_bit_out ) | (val >> (n - s->i_bit_out));
 112         s->p_w++;
 113         n -= s->i_bit_out;
 114         s->i_bit_out_cache = 0;
 115         val &= ~(0xffffffffU << n);
 116         s->i_bit_out = BITS_IN_BUF;
 117     }
 118
 119     if (likely(n))
 120     {
 121         s->i_bit_out_cache = (s->i_bit_out_cache << n) | val;
 122         s->i_bit_out -= n;
 123     }
 124
 125     assert(s->i_bit_out > 0);
 126     assert(s->i_bit_out <= BITS_IN_BUF);
 127 }
 128
 129 static inline void bs_refill( bs_transrate_t *s )
 130 {
 131     assert((s->p_r - s->p_c) >= 1);
 132     s->i_bit_in_cache |= s->p_c[0] << (24 - s->i_bit_in);
 133     s->i_bit_in += 8;
 134     s->p_c++;
 135 }
 136
 137 static inline void bs_flush( bs_transrate_t *s, unsigned int n )
 138 {
 139     assert(s->i_bit_in >= n);
 140
 141     s->i_bit_in_cache <<= n;
 142     s->i_bit_in -= n;
 143
 144     assert( (!n) || ((n>0) && !(s->i_bit_in_cache & 0x1)) );
 145
 146     while (unlikely(s->i_bit_in < 24)) bs_refill( s );
 147 }
 148
 149 static inline unsigned int bs_read( bs_transrate_t *s, unsigned int n)
 150 {
 151     unsigned int Val = ((unsigned int)s->i_bit_in_cache) >> (32 - n);
 152     bs_flush( s, n );
 153     return Val;
 154 }
 155
 156 static inline unsigned int bs_copy( bs_transrate_t *s, unsigned int n)
 157 {
 158     unsigned int Val = bs_read( s, n);
 159     bs_write(s, Val, n);
 160     return Val;
 161 }
 162
 163 static inline void bs_flush_read( bs_transrate_t *s )
 164 {
 165     int i = s->i_bit_in & 0x7;
 166     if( i )
 167     {
 168         assert(((unsigned int)bs->i_bit_in_cache) >> (32 - i) == 0);
 169         s->i_bit_in_cache <<= i;
 170         s->i_bit_in -= i;
 171     }
 172     s->p_c += -1 * (s->i_bit_in >> 3);
 173     s->i_bit_in = 0;
 174 }
 175 static inline void bs_flush_write( bs_transrate_t *s )
 176 {
 177     if( s->i_bit_out != 8 ) bs_write(s, 0, s->i_bit_out);
 178 }
 179
 180 /////---- begin ext mpeg code
 181
 182 const uint8_t non_linear_mquant_table[32] =
 183 {
 184     0, 1, 2, 3, 4, 5, 6, 7,
 185     8,10,12,14,16,18,20,22,
 186     24,28,32,36,40,44,48,52,
 187     56,64,72,80,88,96,104,112
 188 };
 189 const uint8_t map_non_linear_mquant[113] =
 190 {
 191     0,1,2,3,4,5,6,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,
 192     16,17,17,17,18,18,18,18,19,19,19,19,20,20,20,20,21,21,21,21,22,22,
 193     22,22,23,23,23,23,24,24,24,24,24,24,24,25,25,25,25,25,25,25,26,26,
 194     26,26,26,26,26,26,27,27,27,27,27,27,27,27,28,28,28,28,28,28,28,29,
 195     29,29,29,29,29,29,29,29,29,30,30,30,30,30,30,30,31,31,31,31,31
 196 };
 197
 198 static int scale_quant( unsigned int q_scale_type, double quant )
 199 {
 200     int iquant;
 201     if (q_scale_type)
 202     {
 203         iquant = (int) floor(quant+0.5);
 204
 205         /* clip mquant to legal (linear) range */
 206         if (iquant<1) iquant = 1;
 207         if (iquant>112) iquant = 112;
 208
 209         iquant = non_linear_mquant_table[map_non_linear_mquant[iquant]];
 210     }
 211     else
 212     {
 213         /* clip mquant to legal (linear) range */
 214         iquant = (int)floor(quant+0.5);
 215         if (iquant<2) iquant = 2;
 216         if (iquant>62) iquant = 62;
 217         iquant = (iquant/2)*2; // Must be *even*
 218     }
 219     return iquant;
 220 }
 221
 222 static int increment_quant( transrate_t *tr, int quant )
 223 {
 224     if( tr->q_scale_type )
 225     {
 226         assert(quant >= 1 && quant <= 112 );
 227         quant = map_non_linear_mquant[quant] + 1;
 228         if( tr->picture_coding_type == P_TYPE )
 229             quant += tr->level_p;
 230         if( quant > 31) quant = 31;
 231         quant = non_linear_mquant_table[quant];
 232     }
 233     else
 234     {
 235         assert(!(quant & 1));
 236         quant += 2;
 237         if( tr->picture_coding_type == P_TYPE )
 238             quant += 2 * tr->level_p;
 239         if (quant > 62) quant = 62;
 240     }
 241     return quant;
 242 }
 243
 244 static inline int intmax( register int x, register int y )
 245 {
 246     return x < y ? y : x;
 247 }
 248 static inline int intmin( register int x, register int y )
 249 {
 250     return x < y ? x : y;
 251 }
 252
 253 static int getNewQuant( transrate_t *tr, int curQuant)
 254 {
 255     bs_transrate_t *bs = &tr->bs;
 256
 257     double calc_quant, quant_to_use;
 258     int mquant = 0;
 259
 260     switch ( tr->picture_coding_type )
 261     {
 262         case I_TYPE:
 263         case P_TYPE:
 264             mquant = increment_quant( tr, curQuant );
 265             break;
 266
 267         case B_TYPE:
 268             tr->quant_corr = (((bs->i_byte_in - (bs->p_r - 4 - bs->p_c)) / tr->fact_x) - (bs->i_byte_out + (bs->p_w - bs->p_ow))) / REACT_DELAY + B_HANDICAP;
 269             calc_quant = curQuant * tr->current_fact_x;
 270             quant_to_use = calc_quant - tr->quant_corr;
 271
 272             mquant = intmax(scale_quant( tr->q_scale_type, quant_to_use), increment_quant( tr, curQuant) );
 273             break;
 274
 275         default:
 276             assert(0);
 277             break;
 278     }
 279
 280     /*
 281         LOGF("type: %s orig_quant: %3i calc_quant: %7.1f quant_corr: %7.1f using_quant: %3i\n",
 282         (picture_coding_type == I_TYPE ? "I_TYPE" : (picture_coding_type == P_TYPE ? "P_TYPE" : "B_TYPE")),
 283         (int)curQuant, (float)calc_quant, (float)quant_corr, (int)mquant);
 284     */
 285
 286     assert(mquant >= curQuant);
 287
 288     return mquant;
 289 }
 290
 291 static inline int isNotEmpty(RunLevel *blk)
 292 {
 293     return (blk->level);
 294 }
 295
 296 #include "putvlc.h"
 297
 298 static void putAC( bs_transrate_t *bs, int run, int signed_level, int vlcformat)
 299 {
 300     int level, len;
 301     const VLCtable *ptab = NULL;
 302
 303     level = (signed_level<0) ? -signed_level : signed_level; /* abs(signed_level) */
 304
 305     assert(!(run<0 || run>63 || level==0 || level>2047));
 306
 307     len = 0;
 308
 309     if (run<2 && level<41)
 310     {
 311         if (vlcformat)  ptab = &dct_code_tab1a[run][level-1];
 312         else ptab = &dct_code_tab1[run][level-1];
 313         len = ptab->len;
 314     }
 315     else if (run<32 && level<6)
 316     {
 317         if (vlcformat) ptab = &dct_code_tab2a[run-2][level-1];
 318         else ptab = &dct_code_tab2[run-2][level-1];
 319         len = ptab->len;
 320     }
 321
 322     if (len) /* a VLC code exists */
 323     {
 324         bs_write( bs, ptab->code, len);
 325         bs_write( bs, signed_level<0, 1); /* sign */
 326     }
 327     else
 328     {
 329         bs_write( bs, 1l, 6); /* Escape */
 330         bs_write( bs, run, 6); /* 6 bit code for run */
 331         bs_write( bs, ((unsigned int)signed_level) & 0xFFF, 12);
 332     }
 333 }
 334
 335
 336 static inline void putACfirst( bs_transrate_t *bs, int run, int val)
 337 {
 338     if (run==0 && (val==1 || val==-1)) bs_write( bs, 2|(val<0),2);
 339     else putAC( bs, run,val,0);
 340 }
 341
 342 static void putnonintrablk( bs_transrate_t *bs, RunLevel *blk)
 343 {
 344     assert(blk->level);
 345
 346     putACfirst( bs, blk->run, blk->level);
 347     blk++;
 348
 349     while(blk->level)
 350     {
 351         putAC( bs, blk->run, blk->level, 0);
 352         blk++;
 353     }
 354
 355     bs_write( bs, 2,2);
 356 }
 357
 358 #include "getvlc.h"
 359
 360 static const int non_linear_quantizer_scale [] =
 361 {
 362      0,  1,  2,  3,  4,  5,   6,   7,
 363      8, 10, 12, 14, 16, 18,  20,  22,
 364     24, 28, 32, 36, 40, 44,  48,  52,
 365     56, 64, 72, 80, 88, 96, 104, 112
 366 };
 367
 368 static inline int get_macroblock_modes( transrate_t *tr )
 369 {
 370     bs_transrate_t *bs = &tr->bs;
 371
 372     int macroblock_modes;
 373     const MBtab * tab;
 374
 375     switch( tr->picture_coding_type)
 376     {
 377         case I_TYPE:
 378
 379             tab = MB_I + UBITS (bs->i_bit_in_cache, 1);
 380             bs_flush( bs, tab->len );
 381             macroblock_modes = tab->modes;
 382
 383             if ((! ( tr->frame_pred_frame_dct)) && ( tr->picture_structure == FRAME_PICTURE))
 384             {
 385                 macroblock_modes |= UBITS (bs->i_bit_in_cache, 1) * DCT_TYPE_INTERLACED;
 386                 bs_flush( bs, 1 );
 387             }
 388
 389             return macroblock_modes;
 390
 391         case P_TYPE:
 392
 393             tab = MB_P + UBITS (bs->i_bit_in_cache, 5);
 394             bs_flush( bs, tab->len );
 395             macroblock_modes = tab->modes;
 396
 397             if (tr->picture_structure != FRAME_PICTURE)
 398             {
 399                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
 400                 {
 401                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
 402                     bs_flush( bs, 2 );
 403                 }
 404                 return macroblock_modes;
 405             }
 406             else if (tr->frame_pred_frame_dct)
 407             {
 408                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
 409                     macroblock_modes |= MC_FRAME;
 410                 return macroblock_modes;
 411             }
 412             else
 413             {
 414                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
 415                 {
 416                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
 417                     bs_flush( bs, 2 );
 418                 }
 419                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
 420                 {
 421                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 1) * DCT_TYPE_INTERLACED;
 422                     bs_flush( bs, 1 );
 423                 }
 424                 return macroblock_modes;
 425             }
 426
 427         case B_TYPE:
 428
 429             tab = MB_B + UBITS (bs->i_bit_in_cache, 6);
 430             bs_flush( bs, tab->len );
 431             macroblock_modes = tab->modes;
 432
 433             if( tr->picture_structure != FRAME_PICTURE)
 434             {
 435                 if (! (macroblock_modes & MACROBLOCK_INTRA))
 436                 {
 437                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
 438                     bs_flush( bs, 2 );
 439                 }
 440                 return macroblock_modes;
 441             }
 442             else if (tr->frame_pred_frame_dct)
 443             {
 444                 /* if (! (macroblock_modes & MACROBLOCK_INTRA)) */
 445                 macroblock_modes |= MC_FRAME;
 446                 return macroblock_modes;
 447             }
 448             else
 449             {
 450                 if (macroblock_modes & MACROBLOCK_INTRA) goto intra;
 451                 macroblock_modes |= UBITS (bs->i_bit_in_cache, 2) * MOTION_TYPE_BASE;
 452                 bs_flush( bs, 2 );
 453                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
 454                 {
 455                     intra:
 456                     macroblock_modes |= UBITS (bs->i_bit_in_cache, 1) * DCT_TYPE_INTERLACED;
 457                     bs_flush( bs, 1 );
 458                 }
 459                 return macroblock_modes;
 460             }
 461
 462         default:
 463             return 0;
 464     }
 465
 466 }
 467
 468 static inline int get_quantizer_scale( transrate_t *tr )
 469 {
 470     bs_transrate_t *bs = &tr->bs;
 471
 472     int quantizer_scale_code;
 473
 474     quantizer_scale_code = UBITS (bs->i_bit_in_cache, 5);
 475     bs_flush( bs, 5 );
 476
 477     if( tr->q_scale_type )
 478         return non_linear_quantizer_scale[quantizer_scale_code];
 479     else
 480         return quantizer_scale_code << 1;
 481 }
 482
 483 static inline int get_motion_delta( bs_transrate_t *bs, const int f_code )
 484 {
 485     int delta;
 486     int sign;
 487     const MVtab * tab;
 488
 489     if (bs->i_bit_in_cache & 0x80000000)
 490     {
 491         bs_copy( bs, 1 );
 492         return 0;
 493     }
 494     else if (bs->i_bit_in_cache >= 0x0c000000)
 495     {
 496
 497         tab = MV_4 + UBITS (bs->i_bit_in_cache, 4);
 498         delta = (tab->delta << f_code) + 1;
 499         bs_copy( bs, tab->len);
 500
 501         sign = SBITS (bs->i_bit_in_cache, 1);
 502         bs_copy( bs, 1 );
 503
 504         if (f_code) delta += UBITS (bs->i_bit_in_cache, f_code);
 505         bs_copy( bs, f_code);
 506
 507         return (delta ^ sign) - sign;
 508     }
 509     else
 510     {
 511
 512         tab = MV_10 + UBITS (bs->i_bit_in_cache, 10);
 513         delta = (tab->delta << f_code) + 1;
 514         bs_copy( bs, tab->len);
 515
 516         sign = SBITS (bs->i_bit_in_cache, 1);
 517         bs_copy( bs, 1);
 518
 519         if (f_code)
 520         {
 521             delta += UBITS (bs->i_bit_in_cache, f_code);
 522             bs_copy( bs, f_code);
 523         }
 524
 525         return (delta ^ sign) - sign;
 526     }
 527 }
 528
 529
 530 static inline int get_dmv( bs_transrate_t *bs )
 531 {
 532     const DMVtab * tab;
 533
 534     tab = DMV_2 + UBITS (bs->i_bit_in_cache, 2);
 535     bs_copy( bs, tab->len);
 536     return tab->dmv;
 537 }
 538
 539 static inline int get_coded_block_pattern( bs_transrate_t *bs )
 540 {
 541     const CBPtab * tab;
 542
 543     if (bs->i_bit_in_cache >= 0x20000000)
 544     {
 545         tab = CBP_7 + (UBITS (bs->i_bit_in_cache, 7) - 16);
 546         bs_flush( bs, tab->len );
 547         return tab->cbp;
 548     }
 549     else
 550     {
 551         tab = CBP_9 + UBITS (bs->i_bit_in_cache, 9);
 552         bs_flush( bs, tab->len );
 553         return tab->cbp;
 554     }
 555 }
 556
 557 static inline int get_luma_dc_dct_diff( bs_transrate_t *bs )
 558 {
 559     const DCtab * tab;
 560     int size;
 561     int dc_diff;
 562
 563     if (bs->i_bit_in_cache < 0xf8000000)
 564     {
 565         tab = DC_lum_5 + UBITS (bs->i_bit_in_cache, 5);
 566         size = tab->size;
 567         if (size)
 568         {
 569             bs_copy( bs, tab->len);
 570             //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
 571             dc_diff = UBITS (bs->i_bit_in_cache, size);
 572             if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
 573             bs_copy( bs, size);
 574             return dc_diff;
 575         }
 576         else
 577         {
 578             bs_copy( bs, 3);
 579             return 0;
 580         }
 581     }
 582     else
 583     {
 584         tab = DC_long + (UBITS (bs->i_bit_in_cache, 9) - 0x1e0);
 585         size = tab->size;
 586         bs_copy( bs, tab->len);
 587         //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
 588         dc_diff = UBITS (bs->i_bit_in_cache, size);
 589         if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
 590         bs_copy( bs, size);
 591         return dc_diff;
 592     }
 593 }
 594
 595 static inline int get_chroma_dc_dct_diff( bs_transrate_t *bs )
 596 {
 597     const DCtab * tab;
 598     int size;
 599     int dc_diff;
 600
 601     if (bs->i_bit_in_cache < 0xf8000000)
 602     {
 603         tab = DC_chrom_5 + UBITS (bs->i_bit_in_cache, 5);
 604         size = tab->size;
 605         if (size)
 606         {
 607             bs_copy( bs, tab->len);
 608             //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
 609             dc_diff = UBITS (bs->i_bit_in_cache, size);
 610             if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
 611             bs_copy( bs, size);
 612             return dc_diff;
 613         } else
 614         {
 615             bs_copy( bs, 2);
 616             return 0;
 617         }
 618     }
 619     else
 620     {
 621         tab = DC_long + (UBITS (bs->i_bit_in_cache, 10) - 0x3e0);
 622         size = tab->size;
 623         bs_copy( bs, tab->len + 1);
 624         //dc_diff = UBITS (bs->i_bit_in_cache, size) - UBITS (SBITS (~bs->i_bit_in_cache, 1), size);
 625         dc_diff = UBITS (bs->i_bit_in_cache, size);
 626         if (!(dc_diff >> (size - 1))) dc_diff = (dc_diff + 1) - (1 << size);
 627         bs_copy( bs, size);
 628         return dc_diff;
 629     }
 630 }
 631
 632 static void get_intra_block_B14( bs_transrate_t *bs, const int i_qscale, const int i_qscale_new )
 633 {
 634     int tst;
 635     int i, li;
 636     int val;
 637     const DCTtab * tab;
 638
 639     /* Basic sanity check --Meuuh */
 640     if( i_qscale == 0 )
 641     {
 642         return;
 643     }
 644
 645     tst = i_qscale_new/i_qscale + ((i_qscale_new%i_qscale) ? 1 : 0);
 646
 647     li = i = 0;
 648
 649     for( ;; )
 650     {
 651         if (bs->i_bit_in_cache >= 0x28000000)
 652         {
 653             tab = DCT_B14AC_5 + (UBITS (bs->i_bit_in_cache, 5) - 5);
 654
 655             i += tab->run;
 656             if (i >= 64) break; /* end of block */
 657
 658     normal_code:
 659             bs_flush( bs, tab->len );
 660             val = tab->level;
 661             if (val >= tst)
 662             {
 663                 val = (val ^ SBITS (bs->i_bit_in_cache, 1)) - SBITS (bs->i_bit_in_cache, 1);
 664                 putAC( bs, i - li - 1, (val * i_qscale) / i_qscale_new, 0);
 665                 li = i;
 666             }
 667
 668             bs_flush( bs, 1 );
 669             continue;
 670         }
 671         else if (bs->i_bit_in_cache >= 0x04000000)
 672         {
 673             tab = DCT_B14_8 + (UBITS (bs->i_bit_in_cache, 8) - 4);
 674
 675             i += tab->run;
 676             if (i < 64) goto normal_code;
 677
 678             /* escape code */
 679             i += (UBITS (bs->i_bit_in_cache, 12) & 0x3F) - 64;
 680             if (i >= 64) break; /* illegal, check needed to avoid buffer overflow */
 681
 682             bs_flush( bs, 12 );
 683             val = SBITS (bs->i_bit_in_cache, 12);
 684             if (abs(val) >= tst)
 685             {
 686                 putAC( bs, i - li - 1, (val * i_qscale) / i_qscale_new, 0);
 687                 li = i;
 688             }
 689
 690             bs_flush( bs, 12 );
 691
 692             continue;
 693         }
 694         else if (bs->i_bit_in_cache >= 0x02000000)
 695         {
 696             tab = DCT_B14_10 + (UBITS (bs->i_bit_in_cache, 10) - 8);
 697             i += tab->run;
 698             if (i < 64 ) goto normal_code;
 699         }
 700         else if (bs->i_bit_in_cache >= 0x00800000)
 701         {
 702             tab = DCT_13 + (UBITS (bs->i_bit_in_cache, 13) - 16);
 703             i += tab->run;
 704             if (i < 64 ) goto normal_code;
 705         }
 706         else if (bs->i_bit_in_cache >= 0x00200000)
 707         {
 708             tab = DCT_15 + (UBITS (bs->i_bit_in_cache, 15) - 16);
 709             i += tab->run;
 710             if (i < 64 ) goto normal_code;
 711         }
 712         else
 713         {
 714             tab = DCT_16 + UBITS (bs->i_bit_in_cache, 16);
 715             bs_flush( bs, 16 );
 716             i += tab->run;
 717             if (i < 64 ) goto normal_code;
 718         }
 719         break;  /* illegal, check needed to avoid buffer overflow */
 720     }
 721
 722     bs_copy( bs, 2);    /* end of block code */
 723 }
 724
 725 static void get_intra_block_B15( bs_transrate_t *bs,  const int i_qscale, int const i_qscale_new )
 726 {
 727     int tst;
 728     int i, li;
 729     int val;
 730     const DCTtab * tab;
 731
 732     /* Basic sanity check --Meuuh */
 733     if( i_qscale == 0 )
 734     {
 735         return;
 736     }
 737
 738     tst = i_qscale_new/i_qscale + ((i_qscale_new%i_qscale) ? 1 : 0);
 739
 740     li = i = 0;
 741
 742     for( ;; )
 743     {
 744         if (bs->i_bit_in_cache >= 0x04000000)
 745         {
 746             tab = DCT_B15_8 + (UBITS (bs->i_bit_in_cache, 8) - 4);
 747
 748             i += tab->run;
 749             if (i < 64)
 750             {
 751     normal_code:
 752                 bs_flush( bs, tab->len );
 753
 754                 val = tab->level;
 755                 if (val >= tst)
 756                 {
 757                     val = (val ^ SBITS (bs->i_bit_in_cache, 1)) - SBITS (bs->i_bit_in_cache, 1);
 758                     putAC( bs, i - li - 1, (val * i_qscale) / i_qscale_new, 1);
 759                     li = i;
 760                 }
 761
 762                 bs_flush( bs, 1 );
 763                 continue;
 764             }
 765             else
 766             {
 767                 i += (UBITS (bs->i_bit_in_cache, 12) & 0x3F) - 64;
 768
 769                 if (i >= 64) break; /* illegal, check against buffer overflow */
 770
 771                 bs_flush( bs, 12 );
 772                 val = SBITS (bs->i_bit_in_cache, 12);
 773                 if (abs(val) >= tst)
 774                 {
 775                     putAC( bs, i - li - 1, (val * i_qscale) / i_qscale_new, 1);
 776                     li = i;
 777                 }
 778
 779                 bs_flush( bs, 12 );
 780                 continue;
 781             }
 782         }
 783         else if (bs->i_bit_in_cache >= 0x02000000)
 784         {
 785             tab = DCT_B15_10 + (UBITS (bs->i_bit_in_cache, 10) - 8);
 786             i += tab->run;
 787             if (i < 64) goto normal_code;
 788         }
 789         else if (bs->i_bit_in_cache >= 0x00800000)
 790         {
 791             tab = DCT_13 + (UBITS (bs->i_bit_in_cache, 13) - 16);
 792             i += tab->run;
 793             if (i < 64) goto normal_code;
 794         }
 795         else if (bs->i_bit_in_cache >= 0x00200000)
 796         {
 797             tab = DCT_15 + (UBITS (bs->i_bit_in_cache, 15) - 16);
 798             i += tab->run;
 799             if (i < 64) goto normal_code;
 800         }
 801         else
 802         {
 803             tab = DCT_16 + UBITS (bs->i_bit_in_cache, 16);
 804             bs_flush( bs, 16 );
 805             i += tab->run;
 806             if (i < 64) goto normal_code;
 807         }
 808         break;  /* illegal, check needed to avoid buffer overflow */
 809     }
 810
 811     bs_copy( bs, 4);    /* end of block code */
 812 }
 813
 814
 815 static int get_non_intra_block_drop( transrate_t *tr, RunLevel *blk)
 816 {
 817     bs_transrate_t *bs = &tr->bs;
 818
 819     int i, li;
 820     int val;
 821     const DCTtab * tab;
 822     RunLevel *sblk = blk + 1;
 823
 824     li = i = -1;
 825
 826     if (bs->i_bit_in_cache >= 0x28000000)
 827     {
 828         tab = DCT_B14DC_5 + (UBITS (bs->i_bit_in_cache, 5) - 5);
 829         goto entry_1;
 830     }
 831     else goto entry_2;
 832
 833     for( ;; )
 834     {
 835         if (bs->i_bit_in_cache >= 0x28000000)
 836         {
 837             tab = DCT_B14AC_5 + (UBITS (bs->i_bit_in_cache, 5) - 5);
 838
 839     entry_1:
 840             i += tab->run;
 841             if (i >= 64) break; /* end of block */
 842
 843     normal_code:
 844
 845             bs_flush( bs, tab->len );
 846             val = tab->level;
 847             val = (val ^ SBITS (bs->i_bit_in_cache, 1)) - SBITS (bs->i_bit_in_cache, 1); /* if (bitstream_get (1)) val = -val; */
 848
 849             blk->level = val;
 850             blk->run = i - li - 1;
 851             li = i;
 852             blk++;
 853
 854             bs_flush( bs, 1 );
 855             continue;
 856         }
 857
 858     entry_2:
 859
 860         if (bs->i_bit_in_cache >= 0x04000000)
 861         {
 862             tab = DCT_B14_8 + (UBITS (bs->i_bit_in_cache, 8) - 4);
 863
 864             i += tab->run;
 865             if (i < 64) goto normal_code;
 866
 867             /* escape code */
 868
 869             i += (UBITS (bs->i_bit_in_cache, 12) & 0x3F) - 64;
 870
 871             if (i >= 64) break; /* illegal, check needed to avoid buffer overflow */
 872
 873             bs_flush( bs, 12 );
 874             val = SBITS (bs->i_bit_in_cache, 12);
 875
 876             blk->level = val;
 877             blk->run = i - li - 1;
 878             li = i;
 879             blk++;
 880
 881             bs_flush( bs, 12 );
 882             continue;
 883         }
 884         else if (bs->i_bit_in_cache >= 0x02000000)
 885         {
 886             tab = DCT_B14_10 + (UBITS (bs->i_bit_in_cache, 10) - 8);
 887             i += tab->run;
 888             if (i < 64) goto normal_code;
 889         }
 890         else if (bs->i_bit_in_cache >= 0x00800000)
 891         {
 892             tab = DCT_13 + (UBITS (bs->i_bit_in_cache, 13) - 16);
 893             i += tab->run;
 894             if (i < 64) goto normal_code;
 895         }
 896         else if (bs->i_bit_in_cache >= 0x00200000)
 897         {
 898             tab = DCT_15 + (UBITS (bs->i_bit_in_cache, 15) - 16);
 899             i += tab->run;
 900             if (i < 64) goto normal_code;
 901         }
 902         else
 903         {
 904             tab = DCT_16 + UBITS (bs->i_bit_in_cache, 16);
 905             bs_flush( bs, 16 );
 906             i += tab->run;
 907             if (i < 64) goto normal_code;
 908         }
 909         break;  /* illegal, check needed to avoid buffer overflow */
 910     }
 911     bs_flush( bs, 2 ); /* dump end of block code */
 912
 913     // remove last coeff
 914     if (blk != sblk)
 915     {
 916         blk--;
 917     }
 918
 919     // remove more coeffs if very late
 920     if (tr->level_p >= 4 && (blk != sblk))
 921     {
 922         blk--;
 923         if (tr->level_p >= 5 && (blk != sblk))
 924         {
 925             blk--;
 926             if (tr->level_p >= 6 && (blk != sblk))
 927             {
 928                 blk--;
 929                 if (tr->level_p >= 7 && (blk != sblk))
 930                     blk--;
 931             }
 932         }
 933     }
 934
 935     blk->level = 0;
 936
 937     return i;
 938 }
 939
 940 static int get_non_intra_block_rq( bs_transrate_t *bs, RunLevel *blk,  const int i_qscale, const int i_qscale_new )
 941 {
 942     int tst;
 943     int i, li;
 944     int val;
 945     const DCTtab * tab;
 946
 947     /* Basic sanity check --Meuuh */
 948     if( i_qscale == 0 )
 949     {
 950         return 0;
 951     }
 952
 953     tst = i_qscale_new/i_qscale + ((i_qscale_new%i_qscale) ? 1 : 0);
 954
 955     li = i = -1;
 956
 957     if (bs->i_bit_in_cache >= 0x28000000)
 958     {
 959         tab = DCT_B14DC_5 + (UBITS (bs->i_bit_in_cache, 5) - 5);
 960         goto entry_1;
 961     }
 962     else goto entry_2;
 963
 964     for( ;; )
 965     {
 966         if (bs->i_bit_in_cache >= 0x28000000)
 967         {
 968             tab = DCT_B14AC_5 + (UBITS (bs->i_bit_in_cache, 5) - 5);
 969
 970     entry_1:
 971             i += tab->run;
 972             if (i >= 64)
 973             break;  /* end of block */
 974
 975     normal_code:
 976
 977             bs_flush( bs, tab->len );
 978             val = tab->level;
 979             if (val >= tst)
 980             {
 981                 val = (val ^ SBITS (bs->i_bit_in_cache, 1)) - SBITS (bs->i_bit_in_cache, 1);
 982                 blk->level = (val * i_qscale) / i_qscale_new;
 983                 blk->run = i - li - 1;
 984                 li = i;
 985                 blk++;
 986             }
 987
 988             //if ( ((val) && (tab->level < tst)) || ((!val) && (tab->level >= tst)) )
 989             //  LOGF("level: %i val: %i tst : %i q: %i nq : %i\n", tab->level, val, tst, q, nq);
 990
 991             bs_flush( bs, 1 );
 992             continue;
 993         }
 994
 995     entry_2:
 996         if (bs->i_bit_in_cache >= 0x04000000)
 997         {
 998             tab = DCT_B14_8 + (UBITS (bs->i_bit_in_cache, 8) - 4);
 999
1000             i += tab->run;
1001             if (i < 64) goto normal_code;
1002
1003             /* escape code */
1004
1005             i += (UBITS (bs->i_bit_in_cache, 12) & 0x3F) - 64;
1006
1007             if (i >= 64) break; /* illegal, check needed to avoid buffer overflow */
1008
1009             bs_flush( bs, 12 );
1010             val = SBITS (bs->i_bit_in_cache, 12);
1011             if (abs(val) >= tst)
1012             {
1013                 blk->level = (val * i_qscale) / i_qscale_new;
1014                 blk->run = i - li - 1;
1015                 li = i;
1016                 blk++;
1017             }
1018
1019             bs_flush( bs, 12 );
1020             continue;
1021         }
1022         else if (bs->i_bit_in_cache >= 0x02000000)
1023         {
1024             tab = DCT_B14_10 + (UBITS (bs->i_bit_in_cache, 10) - 8);
1025             i += tab->run;
1026             if (i < 64) goto normal_code;
1027         }
1028         else if (bs->i_bit_in_cache >= 0x00800000)
1029         {
1030             tab = DCT_13 + (UBITS (bs->i_bit_in_cache, 13) - 16);
1031             i += tab->run;
1032             if (i < 64) goto normal_code;
1033         }
1034         else if (bs->i_bit_in_cache >= 0x00200000)
1035         {
1036             tab = DCT_15 + (UBITS (bs->i_bit_in_cache, 15) - 16);
1037             i += tab->run;
1038             if (i < 64) goto normal_code;
1039         }
1040         else
1041         {
1042             tab = DCT_16 + UBITS (bs->i_bit_in_cache, 16);
1043             bs_flush( bs, 16 );
1044
1045             i += tab->run;
1046             if (i < 64) goto normal_code;
1047         }
1048         break;  /* illegal, check needed to avoid buffer overflow */
1049     }
1050     bs_flush( bs, 2 );    /* dump end of block code */
1051
1052     blk->level = 0;
1053
1054     return i;
1055 }
1056
1057 static void motion_fr_frame( bs_transrate_t *bs, unsigned int f_code[2] )
1058 {
1059     get_motion_delta( bs, f_code[0] );
1060     get_motion_delta( bs, f_code[1] );
1061 }
1062
1063 static void motion_fr_field( bs_transrate_t *bs, unsigned int f_code[2] )
1064 {
1065     bs_copy( bs, 1);
1066
1067     get_motion_delta( bs, f_code[0]);
1068     get_motion_delta( bs, f_code[1]);
1069
1070     bs_copy( bs, 1);
1071
1072     get_motion_delta( bs, f_code[0]);
1073     get_motion_delta( bs, f_code[1]);
1074 }
1075
1076 static void motion_fr_dmv( bs_transrate_t *bs, unsigned int f_code[2] )
1077 {
1078     get_motion_delta( bs, f_code[0]);
1079     get_dmv( bs );
1080
1081     get_motion_delta( bs, f_code[1]);
1082     get_dmv( bs );
1083 }
1084
1085 static void motion_fi_field( bs_transrate_t *bs, unsigned int f_code[2] )
1086 {
1087     bs_copy( bs, 1);
1088
1089     get_motion_delta( bs, f_code[0]);
1090     get_motion_delta( bs, f_code[1]);
1091 }
1092
1093 static void motion_fi_16x8( bs_transrate_t *bs, unsigned int f_code[2] )
1094 {
1095     bs_copy( bs, 1);
1096
1097     get_motion_delta( bs, f_code[0]);
1098     get_motion_delta( bs, f_code[1]);
1099
1100     bs_copy( bs, 1);
1101
1102     get_motion_delta( bs, f_code[0]);
1103     get_motion_delta( bs, f_code[1]);
1104 }
1105
1106 static void motion_fi_dmv( bs_transrate_t *bs, unsigned int f_code[2] )
1107 {
1108     get_motion_delta( bs, f_code[0]);
1109     get_dmv( bs );
1110
1111     get_motion_delta( bs, f_code[1]);
1112     get_dmv( bs );
1113 }
1114
1115
1116 #define MOTION_CALL(routine,direction)                      \
1117 do {                                                        \
1118     if ((direction) & MACROBLOCK_MOTION_FORWARD)            \
1119         routine( bs, tr->f_code[0]);                        \
1120     if ((direction) & MACROBLOCK_MOTION_BACKWARD)           \
1121         routine( bs, tr->f_code[1]);                        \
1122 } while (0)
1123
1124 #define NEXT_MACROBLOCK                                         \
1125 do {                                                            \
1126     tr->h_offset += 16;                                         \
1127     if( tr->h_offset == tr->horizontal_size_value)              \
1128     {                                                           \
1129         tr->v_offset += 16;                                         \
1130         if (tr->v_offset > (tr->vertical_size_value - 16)) return;      \
1131         tr->h_offset = 0;                                       \
1132     }                                                           \
1133 } while (0)
1134
1135 static void putmbdata( transrate_t *tr, int macroblock_modes )
1136 {
1137     bs_transrate_t *bs = &tr->bs;
1138
1139     bs_write( bs,
1140               mbtypetab[tr->picture_coding_type-1][macroblock_modes&0x1F].code,
1141               mbtypetab[tr->picture_coding_type-1][macroblock_modes&0x1F].len);
1142
1143     switch ( tr->picture_coding_type)
1144     {
1145         case I_TYPE:
1146             if ((! (tr->frame_pred_frame_dct)) && (tr->picture_structure == FRAME_PICTURE))
1147                 bs_write( bs, macroblock_modes & DCT_TYPE_INTERLACED ? 1 : 0, 1);
1148             break;
1149
1150         case P_TYPE:
1151             if (tr->picture_structure != FRAME_PICTURE)
1152             {
1153                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
1154                     bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
1155                 break;
1156             }
1157             else if (tr->frame_pred_frame_dct) break;
1158             else
1159             {
1160                 if (macroblock_modes & MACROBLOCK_MOTION_FORWARD)
1161                     bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
1162                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
1163                     bs_write( bs, macroblock_modes & DCT_TYPE_INTERLACED ? 1 : 0, 1);
1164                 break;
1165             }
1166
1167         case B_TYPE:
1168             if (tr->picture_structure != FRAME_PICTURE)
1169             {
1170                 if (! (macroblock_modes & MACROBLOCK_INTRA))
1171                     bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
1172                 break;
1173             }
1174             else if (tr->frame_pred_frame_dct) break;
1175             else
1176             {
1177                 if (macroblock_modes & MACROBLOCK_INTRA) goto intra;
1178                 bs_write( bs, (macroblock_modes & MOTION_TYPE_MASK) / MOTION_TYPE_BASE, 2);
1179                 if (macroblock_modes & (MACROBLOCK_INTRA | MACROBLOCK_PATTERN))
1180                 {
1181                     intra:
1182                     bs_write( bs, macroblock_modes & DCT_TYPE_INTERLACED ? 1 : 0, 1);
1183                 }
1184                 break;
1185             }
1186     }
1187 }
1188
1189 static inline void put_quantiser( transrate_t *tr )
1190 {
1191     bs_transrate_t *bs = &tr->bs;
1192
1193     bs_write( bs, tr->q_scale_type ? map_non_linear_mquant[tr->new_quantizer_scale] : tr->new_quantizer_scale >> 1, 5);
1194     tr->last_coded_scale = tr->new_quantizer_scale;
1195 }
1196
1197 static int slice_init( transrate_t *tr,  int code)
1198 {
1199     bs_transrate_t *bs = &tr->bs;
1200     int offset;
1201     const MBAtab * mba;
1202
1203     tr->v_offset = (code - 1) * 16;
1204
1205     tr->quantizer_scale = get_quantizer_scale( tr );
1206     if ( tr->picture_coding_type == P_TYPE)
1207     {
1208         tr->new_quantizer_scale = tr->quantizer_scale;
1209     }
1210     else
1211     {
1212         tr->new_quantizer_scale = getNewQuant(tr, tr->quantizer_scale);
1213     }
1214     put_quantiser( tr );
1215
1216     /*LOGF("************************\nstart of slice %i in %s picture. ori quant: %i new quant: %i\n", code,
1217         (picture_coding_type == I_TYPE ? "I_TYPE" : (picture_coding_type == P_TYPE ? "P_TYPE" : "B_TYPE")),
1218         quantizer_scale, new_quantizer_scale);*/
1219
1220     /* ignore intra_slice and all the extra data */
1221     while (bs->i_bit_in_cache & 0x80000000)
1222     {
1223         bs_flush( bs, 9 );
1224     }
1225
1226     /* decode initial macroblock address increment */
1227     offset = 0;
1228     for( ;; )
1229     {
1230         if (bs->i_bit_in_cache >= 0x08000000)
1231         {
1232             mba = MBA_5 + (UBITS (bs->i_bit_in_cache, 6) - 2);
1233             break;
1234         }
1235         else if (bs->i_bit_in_cache >= 0x01800000)
1236         {
1237             mba = MBA_11 + (UBITS (bs->i_bit_in_cache, 12) - 24);
1238             break;
1239         }
1240         else if( UBITS (bs->i_bit_in_cache, 12 ) == 8 )
1241         {
1242             /* macroblock_escape */
1243             offset += 33;
1244             bs_copy( bs, 11);
1245         }
1246         else
1247         {
1248             return -1;
1249         }
1250     }
1251
1252     bs_copy( bs, mba->len + 1);
1253     tr->h_offset = (offset + mba->mba) << 4;
1254
1255     while( tr->h_offset - (int)tr->horizontal_size_value >= 0)
1256     {
1257         tr->h_offset -= tr->horizontal_size_value;
1258         tr->v_offset += 16;
1259     }
1260
1261     if( tr->v_offset > tr->vertical_size_value - 16 )
1262     {
1263         return -1;
1264     }
1265     return 0;
1266 }
1267
1268 static void mpeg2_slice( transrate_t *tr, const int code )
1269 {
1270     bs_transrate_t *bs = &tr->bs;
1271
1272     if( slice_init( tr, code ) )
1273     {
1274         return;
1275     }
1276
1277     for( ;; )
1278     {
1279         int macroblock_modes;
1280         int mba_inc;
1281         const MBAtab * mba;
1282
1283         macroblock_modes = get_macroblock_modes( tr );
1284         if (macroblock_modes & MACROBLOCK_QUANT) tr->quantizer_scale = get_quantizer_scale( tr );
1285
1286         //LOGF("blk %i : ", h_offset >> 4);
1287
1288         if (macroblock_modes & MACROBLOCK_INTRA)
1289         {
1290             //LOG("intra "); if (macroblock_modes & MACROBLOCK_QUANT) LOGF("got new quant: %i ", quantizer_scale);
1291
1292             tr->new_quantizer_scale = increment_quant( tr, tr->quantizer_scale);
1293             if (tr->last_coded_scale == tr->new_quantizer_scale) macroblock_modes &= 0xFFFFFFEF; // remove MACROBLOCK_QUANT
1294             else macroblock_modes |= MACROBLOCK_QUANT; //add MACROBLOCK_QUANT
1295             putmbdata( tr, macroblock_modes);
1296             if (macroblock_modes & MACROBLOCK_QUANT) put_quantiser( tr );
1297
1298             //if (macroblock_modes & MACROBLOCK_QUANT) LOGF("put new quant: %i ", new_quantizer_scale);
1299
1300             if (tr->concealment_motion_vectors)
1301             {
1302                 if (tr->picture_structure != FRAME_PICTURE)
1303                 {
1304                     bs_copy( bs, 1); /* remove field_select */
1305                 }
1306                 /* like motion_frame, but parsing without actual motion compensation */
1307                 get_motion_delta( bs, tr->f_code[0][0]);
1308                 get_motion_delta( bs, tr->f_code[0][1]);
1309
1310                 bs_copy( bs, 1); /* remove marker_bit */
1311             }
1312
1313             if( tr->intra_vlc_format )
1314             {
1315                 /* Luma */
1316                 get_luma_dc_dct_diff( bs );     get_intra_block_B15( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1317                 get_luma_dc_dct_diff( bs );     get_intra_block_B15( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1318                 get_luma_dc_dct_diff( bs );     get_intra_block_B15( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1319                 get_luma_dc_dct_diff( bs );     get_intra_block_B15( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1320                 /* Chroma */
1321                 get_chroma_dc_dct_diff( bs );   get_intra_block_B15( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1322                 get_chroma_dc_dct_diff( bs );   get_intra_block_B15( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1323             }
1324             else
1325             {
1326                 /* Luma */
1327                 get_luma_dc_dct_diff( bs );     get_intra_block_B14( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1328                 get_luma_dc_dct_diff( bs );     get_intra_block_B14( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1329                 get_luma_dc_dct_diff( bs );     get_intra_block_B14( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1330                 get_luma_dc_dct_diff( bs );     get_intra_block_B14( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1331                 /* Chroma */
1332                 get_chroma_dc_dct_diff( bs );   get_intra_block_B14( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1333                 get_chroma_dc_dct_diff( bs );   get_intra_block_B14( bs, tr->quantizer_scale, tr->new_quantizer_scale );
1334             }
1335         }
1336         else
1337         {
1338             RunLevel block[6][65]; // terminated by level = 0, so we need 64+1
1339             int new_coded_block_pattern = 0;
1340
1341             // begin saving data
1342             int batb;
1343             uint8_t   p_n_ow[32], *p_n_w,
1344                     *p_o_ow = bs->p_ow, *p_o_w = bs->p_w;
1345             uint32_t  i_n_bit_out, i_n_bit_out_cache,
1346                     i_o_bit_out  = bs->i_bit_out, i_o_bit_out_cache = bs->i_bit_out_cache;
1347
1348             bs->i_bit_out_cache = 0; bs->i_bit_out = BITS_IN_BUF;
1349             bs->p_ow = bs->p_w = p_n_ow;
1350
1351             if (tr->picture_structure == FRAME_PICTURE)
1352                 switch (macroblock_modes & MOTION_TYPE_MASK)
1353                 {
1354                     case MC_FRAME: MOTION_CALL (motion_fr_frame, macroblock_modes); break;
1355                     case MC_FIELD: MOTION_CALL (motion_fr_field, macroblock_modes); break;
1356                     case MC_DMV: MOTION_CALL (motion_fr_dmv, MACROBLOCK_MOTION_FORWARD); break;
1357                 }
1358             else
1359                 switch (macroblock_modes & MOTION_TYPE_MASK)
1360                 {
1361                     case MC_FIELD: MOTION_CALL (motion_fi_field, macroblock_modes); break;
1362                     case MC_16X8: MOTION_CALL (motion_fi_16x8, macroblock_modes); break;
1363                     case MC_DMV: MOTION_CALL (motion_fi_dmv, MACROBLOCK_MOTION_FORWARD); break;
1364                 }
1365
1366             assert(bs->p_w - bs->p_ow < 32);
1367
1368             p_n_w = bs->p_w;
1369             i_n_bit_out = bs->i_bit_out;
1370             i_n_bit_out_cache = bs->i_bit_out_cache;
1371             assert(bs->p_ow == p_n_ow);
1372
1373             bs->i_bit_out = i_o_bit_out ;
1374             bs->i_bit_out_cache = i_o_bit_out_cache;
1375             bs->p_ow = p_o_ow;
1376             bs->p_w = p_o_w;
1377             // end saving data
1378
1379             if ( tr->picture_coding_type == P_TYPE) tr->new_quantizer_scale = tr->quantizer_scale;
1380             else tr->new_quantizer_scale = getNewQuant( tr, tr->quantizer_scale);
1381
1382             //LOG("non intra "); if (macroblock_modes & MACROBLOCK_QUANT) LOGF("got new quant: %i ", quantizer_scale);
1383
1384             if (macroblock_modes & MACROBLOCK_PATTERN)
1385             {
1386                 const int cbp = get_coded_block_pattern( bs );
1387
1388                 if( tr->picture_coding_type == P_TYPE )
1389                 {
1390                     if( cbp&0x20 ) get_non_intra_block_drop( tr, block[0] );
1391                     if( cbp&0x10 ) get_non_intra_block_drop( tr, block[1] );
1392                     if( cbp&0x08 ) get_non_intra_block_drop( tr, block[2] );
1393                     if( cbp&0x04 ) get_non_intra_block_drop( tr, block[3] );
1394                     if( cbp&0x02 ) get_non_intra_block_drop( tr, block[4] );
1395                     if( cbp&0x01 ) get_non_intra_block_drop( tr, block[5] );
1396
1397                     new_coded_block_pattern = cbp;
1398                 }
1399                 else
1400                 {
1401                     if( cbp&0x20 )
1402                     {
1403                         get_non_intra_block_rq( bs, block[0], tr->quantizer_scale, tr->new_quantizer_scale );
1404                         if( isNotEmpty( block[0] ) ) new_coded_block_pattern |= 0x20;
1405                     }
1406                     if( cbp&0x10 )
1407                     {
1408                         get_non_intra_block_rq( bs, block[1], tr->quantizer_scale, tr->new_quantizer_scale );
1409                         if( isNotEmpty( block[1] ) ) new_coded_block_pattern |= 0x10;
1410                     }
1411                     if( cbp&0x08 )
1412                     {
1413                         get_non_intra_block_rq( bs, block[2], tr->quantizer_scale, tr->new_quantizer_scale );
1414                         if( isNotEmpty( block[2] ) ) new_coded_block_pattern |= 0x08;
1415                     }
1416                     if( cbp&0x04 )
1417                     {
1418                         get_non_intra_block_rq( bs, block[3], tr->quantizer_scale, tr->new_quantizer_scale );
1419                         if( isNotEmpty( block[3] ) ) new_coded_block_pattern |= 0x04;
1420                     }
1421                     if( cbp&0x02 )
1422                     {
1423                         get_non_intra_block_rq( bs, block[4], tr->quantizer_scale, tr->new_quantizer_scale );
1424                         if( isNotEmpty( block[4] ) ) new_coded_block_pattern |= 0x02;
1425                     }
1426                     if( cbp&0x01 )
1427                     {
1428                         get_non_intra_block_rq( bs, block[5], tr->quantizer_scale, tr->new_quantizer_scale );
1429                         if( isNotEmpty( block[5] ) ) new_coded_block_pattern |= 0x01;
1430                     }
1431                     if( !new_coded_block_pattern) macroblock_modes &= 0xFFFFFFED; // remove MACROBLOCK_PATTERN and MACROBLOCK_QUANT flag
1432                 }
1433             }
1434
1435             if (tr->last_coded_scale == tr->new_quantizer_scale) macroblock_modes &= 0xFFFFFFEF; // remove MACROBLOCK_QUANT
1436             else if (macroblock_modes & MACROBLOCK_PATTERN) macroblock_modes |= MACROBLOCK_QUANT; //add MACROBLOCK_QUANT
1437             assert( (macroblock_modes & MACROBLOCK_PATTERN) || !(macroblock_modes & MACROBLOCK_QUANT) );
1438
1439             putmbdata( tr, macroblock_modes);
1440             if( macroblock_modes & MACROBLOCK_QUANT )
1441             {
1442                 put_quantiser( tr );
1443             }
1444
1445             // put saved motion data...
1446             for (batb = 0; batb < (p_n_w - p_n_ow); batb++)
1447             {
1448                 bs_write( bs, p_n_ow[batb], 8 );
1449             }
1450             bs_write( bs, i_n_bit_out_cache, BITS_IN_BUF - i_n_bit_out);
1451             // end saved motion data...
1452
1453             if (macroblock_modes & MACROBLOCK_PATTERN)
1454             {
1455                 /* Write CBP */
1456                 bs_write( bs, cbptable[new_coded_block_pattern].code,cbptable[new_coded_block_pattern].len);
1457
1458                 if (new_coded_block_pattern & 0x20) putnonintrablk( bs, block[0]);
1459                 if (new_coded_block_pattern & 0x10) putnonintrablk( bs, block[1]);
1460                 if (new_coded_block_pattern & 0x08) putnonintrablk( bs, block[2]);
1461                 if (new_coded_block_pattern & 0x04) putnonintrablk( bs, block[3]);
1462                 if (new_coded_block_pattern & 0x02) putnonintrablk( bs, block[4]);
1463                 if (new_coded_block_pattern & 0x01) putnonintrablk( bs, block[5]);
1464             }
1465         }
1466
1467         //LOGF("\n\to: %i c: %i n: %i\n", quantizer_scale, last_coded_scale, new_quantizer_scale);
1468
1469         NEXT_MACROBLOCK;
1470
1471         mba_inc = 0;
1472         for( ;; )
1473         {
1474             if (bs->i_bit_in_cache >= 0x10000000)
1475             {
1476                 mba = MBA_5 + (UBITS (bs->i_bit_in_cache, 5) - 2);
1477                 break;
1478             }
1479             else if (bs->i_bit_in_cache >= 0x03000000)
1480             {
1481                 mba = MBA_11 + (UBITS (bs->i_bit_in_cache, 11) - 24);
1482                 break;
1483             }
1484             else if( UBITS (bs->i_bit_in_cache, 11 ) == 8 )
1485             {
1486                 /* macroblock_escape */
1487                 mba_inc += 33;
1488                 bs_copy( bs, 11);
1489             }
1490             else
1491             {
1492                 /* EOS or error */
1493                 return;
1494             }
1495         }
1496         bs_copy( bs, mba->len);
1497         mba_inc += mba->mba;
1498
1499         while( mba_inc-- )
1500         {
1501             NEXT_MACROBLOCK;
1502         }
1503     }
1504 }
1505
1506 /////---- end ext mpeg code
1507
1508 static int do_next_start_code( transrate_t *tr )
1509 {
1510     bs_transrate_t *bs = &tr->bs;
1511     uint8_t ID;
1512
1513     // get start code
1514     ID = bs->p_c[0];
1515
1516     /* Copy one byte */
1517     *bs->p_w++ = *bs->p_c++;
1518
1519     if (ID == 0x00) // pic header
1520     {
1521         tr->picture_coding_type = (bs->p_c[1] >> 3) & 0x7;
1522         bs->p_c[1] |= 0x7; bs->p_c[2] = 0xFF; bs->p_c[3] |= 0xF8; // vbv_delay is now 0xFFFF
1523
1524         memcpy(bs->p_w, bs->p_c, 4);
1525         bs->p_c += 4;
1526         bs->p_w += 4;
1527     }
1528     else if (ID == 0xB3) // seq header
1529     {
1530         tr->horizontal_size_value = (bs->p_c[0] << 4) | (bs->p_c[1] >> 4);
1531         tr->vertical_size_value = ((bs->p_c[1] & 0xF) << 8) | bs->p_c[2];
1532         if(!tr->horizontal_size_value || !tr->vertical_size_value )
1533         {
1534             return -1;
1535         }
1536
1537         memcpy(bs->p_w, bs->p_c, 8 );
1538         bs->p_c += 8;
1539         bs->p_w += 8;
1540     }
1541     else if (ID == 0xB5) // extension
1542     {
1543         if ((bs->p_c[0] >> 4) == 0x8) // pic coding ext
1544         {
1545             tr->f_code[0][0] = (bs->p_c[0] & 0xF) - 1;
1546             tr->f_code[0][1] = (bs->p_c[1] >> 4) - 1;
1547             tr->f_code[1][0] = (bs->p_c[1] & 0xF) - 1;
1548             tr->f_code[1][1] = (bs->p_c[2] >> 4) - 1;
1549
1550             /* tr->intra_dc_precision = (bs->p_c[2] >> 2) & 0x3; */
1551             tr->picture_structure = bs->p_c[2] & 0x3;
1552             tr->frame_pred_frame_dct = (bs->p_c[3] >> 6) & 0x1;
1553             tr->concealment_motion_vectors = (bs->p_c[3] >> 5) & 0x1;
1554             tr->q_scale_type = (bs->p_c[3] >> 4) & 0x1;
1555             tr->intra_vlc_format = (bs->p_c[3] >> 3) & 0x1;
1556             /* tr->alternate_scan = (bs->p_c[3] >> 2) & 0x1; */
1557
1558
1559             memcpy(bs->p_w, bs->p_c, 5);
1560             bs->p_c += 5;
1561             bs->p_w += 5;
1562         }
1563         else
1564         {
1565             *bs->p_w++ = *bs->p_c++;
1566         }
1567     }
1568     else if (ID == 0xB8) // gop header
1569     {
1570         memcpy(bs->p_w, bs->p_c, 4);
1571         bs->p_c += 4;
1572         bs->p_w += 4;
1573     }
1574     else if ((ID >= 0x01) && (ID <= 0xAF)) // slice
1575     {
1576         uint8_t *outTemp = bs->p_w, *inTemp = bs->p_c;
1577
1578 #if 0
1579         if( ( tr->picture_coding_type == B_TYPE && tr->quant_corr <  2.5f ) || // don't recompress if we're in advance!
1580             ( tr->picture_coding_type == P_TYPE && tr->quant_corr < -2.5f ) ||
1581             ( tr->picture_coding_type == I_TYPE && tr->quant_corr < -5.0f ) )
1582 #else
1583         if( ( tr->picture_coding_type == B_TYPE ) ||
1584             ( tr->picture_coding_type == P_TYPE && tr->level_p ) ||
1585             ( tr->picture_coding_type == I_TYPE && tr->level_i ) )
1586 #endif
1587         {
1588             if( !tr->horizontal_size_value || !tr->vertical_size_value )
1589             {
1590                 return -1;
1591             }
1592
1593             // init bit buffer
1594             bs->i_bit_in_cache = 0; bs->i_bit_in = 0;
1595             bs->i_bit_out_cache = 0; bs->i_bit_out = BITS_IN_BUF;
1596
1597             // get 32 bits
1598             bs_refill( bs );
1599             bs_refill( bs );
1600             bs_refill( bs );
1601             bs_refill( bs );
1602
1603             // begin bit level recoding
1604             mpeg2_slice(tr, ID);
1605
1606             bs_flush_read( bs );
1607             bs_flush_write( bs );
1608             // end bit level recoding
1609
1610             /* Basic sanity checks --Meuuh */
1611             if (bs->p_c > bs->p_r || bs->p_w > bs->p_rw)
1612             {
1613                 return -1;
1614             }
1615
1616             /*LOGF("type: %s code: %02i in : %6i out : %6i diff : %6i fact: %2.2f\n",
1617             (picture_coding_type == I_TYPE ? "I_TYPE" : (picture_coding_type == P_TYPE ? "P_TYPE" : "B_TYPE")),
1618             ID,  bs->p_c - inTemp, bs->p_w - outTemp, (bs->p_w - outTemp) - (bs->p_c - inTemp), (float)(bs->p_c - inTemp) / (float)(bs->p_w - outTemp));*/
1619
1620             if (bs->p_w - outTemp > bs->p_c - inTemp) // yes that might happen, rarely
1621             {
1622                 /*LOGF("*** slice bigger than before !! (type: %s code: %i in : %i out : %i diff : %i)\n",
1623                 (picture_coding_type == I_TYPE ? "I_TYPE" : (picture_coding_type == P_TYPE ? "P_TYPE" : "B_TYPE")),
1624                 ID, bs->p_c - inTemp, bs->p_w - outTemp, (bs->p_w - outTemp) - (bs->p_c - inTemp));*/
1625
1626                 // in this case, we'll just use the original slice !
1627                 memcpy(outTemp, inTemp, bs->p_c - inTemp);
1628                 bs->p_w = outTemp + (bs->p_c - inTemp);
1629
1630                 // adjust bs->i_byte_out
1631                 bs->i_byte_out -= (bs->p_w - outTemp) - (bs->p_c - inTemp);
1632             }
1633         }
1634     }
1635     return 0;
1636 }
1637
1638 void E_(process_frame)( sout_stream_t *p_stream,
1639                     sout_stream_id_t *id, sout_buffer_t *in, sout_buffer_t **out )
1640 {
1641     transrate_t *tr = &id->tr;
1642     bs_transrate_t *bs = &tr->bs;
1643
1644     sout_buffer_t       *p_out;
1645
1646     double              next_fact_x = 1.0;
1647
1648     /* The output buffer can't be bigger than the input buffer. */
1649     p_out = sout_BufferNew( p_stream->p_sout, in->i_size );
1650
1651     p_out->i_length = in->i_length;
1652     p_out->i_dts    = in->i_dts;
1653     p_out->i_pts    = in->i_pts;
1654     p_out->i_flags  = in->i_flags;
1655
1656     sout_BufferChain( out, p_out );
1657
1658     bs->p_rw = bs->p_ow = bs->p_w = p_out->p_buffer;
1659     bs->p_c = bs->p_r = in->p_buffer;
1660     bs->p_r += in->i_size + 4;
1661     bs->p_rw += in->i_size;
1662     *(in->p_buffer + in->i_size) = 0;
1663     *(in->p_buffer + in->i_size + 1) = 0;
1664     *(in->p_buffer + in->i_size + 2) = 1;
1665     *(in->p_buffer + in->i_size + 3) = 0;
1666
1667     /* Calculate how late we are */
1668     tr->quant_corr = 0.0 + B_HANDICAP;
1669     tr->level_i = 0;
1670     tr->level_p = 0;
1671     bs->i_byte_in = in->i_size;
1672     bs->i_byte_out  = 0;
1673
1674     if (tr->i_current_gop_size - in->i_size > 100)
1675     {
1676         if (tr->i_wanted_gop_size == in->i_size)
1677         {
1678             next_fact_x = 1.0;
1679         }
1680         else if ( tr->i_wanted_gop_size < in->i_size )
1681         {
1682             /* We're really late */
1683             next_fact_x = 10.0;
1684         }
1685         else
1686         {
1687             next_fact_x = ((double)(tr->i_current_gop_size - in->i_size)) /
1688                           (tr->i_wanted_gop_size - in->i_size);
1689         }
1690
1691         if (next_fact_x > QUANT_I)
1692         {
1693             tr->level_i = 1;
1694         }
1695         if (next_fact_x > QUANT_P)
1696         {
1697             tr->level_p = 1 + (next_fact_x - QUANT_P) / (QUANT_P_INC);
1698         }
1699     }
1700     if ( tr->i_wanted_gop_size < 0 )
1701     {
1702         /* We're really late */
1703         tr->current_fact_x = 3.0;
1704     }
1705     else
1706     {
1707         tr->current_fact_x = ((double)(tr->i_current_gop_size) /
1708                               (tr->i_wanted_gop_size));
1709     }
1710
1711     for ( ; ; )
1712     {
1713         uint8_t *p_end = &in->p_buffer[in->i_size];
1714
1715         /* Search next start code */
1716         for( ;; )
1717         {
1718             if( bs->p_c < p_end - 3 && bs->p_c[0] == 0 && bs->p_c[1] == 0 && bs->p_c[2] == 1 )
1719             {
1720                 /* Next start code */
1721                 break;
1722             }
1723             else if( bs->p_c < p_end - 6 &&
1724                      bs->p_c[0] == 0 && bs->p_c[1] == 0 && bs->p_c[2] == 0 &&
1725                      bs->p_c[3] == 0 && bs->p_c[4] == 0 && bs->p_c[5] == 0 )
1726             {
1727                 /* remove stuffing (looking for 6 0x00 bytes) */
1728                 bs->p_c++;
1729             }
1730             else
1731             {
1732                 /* Copy */
1733                 *bs->p_w++ = *bs->p_c++;
1734             }
1735
1736             if( bs->p_c >= p_end)
1737             {
1738                 break;
1739             }
1740         }
1741
1742         if( bs->p_c >= p_end )
1743         {
1744             break;
1745         }
1746
1747         /* Copy the start code */
1748         memcpy(bs->p_w, bs->p_c, 3 );
1749         bs->p_c += 3;
1750         bs->p_w += 3;
1751
1752         if (do_next_start_code( tr ) )
1753         {
1754             /* Error */
1755             break;
1756         }
1757
1758         tr->quant_corr = (((bs->i_byte_in - (bs->p_r - 4 - bs->p_c)) / tr->fact_x) - (bs->i_byte_out + (bs->p_w - bs->p_ow))) / REACT_DELAY + B_HANDICAP;
1759     }
1760
1761     bs->i_byte_out += bs->p_w - bs->p_ow;
1762     p_out->i_size = bs->p_w - bs->p_ow;
1763     tr->i_current_gop_size -= in->i_size;
1764     tr->i_wanted_gop_size -= p_out->i_size;
1765     tr->i_new_gop_size += bs->i_byte_out;
1766
1767 #if 0
1768     msg_Dbg( p_stream, "%d: %d -> %d (r: %f, n:%f, corr:%f)",
1769              tr->picture_coding_type, in->i_size, p_out->i_size,
1770              (float)in->i_size / p_out->i_size,
1771              next_fact_x, tr->quant_corr);
1772 #endif
1773 }
1774
1775