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