lib/lame/quantize.c

   1 /*
   2  * MP3 quantization
   3  *
   4  * Copyright (c) 1999 Mark Taylor
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 /* $Id: quantize.c,v 1.1 2002/04/28 17:30:24 kramm Exp $ */
  23
  24 #include "config_static.h"
  25
  26 #include <math.h>
  27 #include <assert.h>
  28 #include "util.h"
  29 #include "l3side.h"
  30 #include "quantize.h"
  31 #include "reservoir.h"
  32 #include "quantize_pvt.h"
  33 #include "lame-analysis.h"
  34 #include "vbrquantize.h"
  35
  36 #ifdef WITH_DMALLOC
  37 #include <dmalloc.h>
  38 #endif
  39
  40
  41 /************************************************************************
  42  *
  43  *      init_outer_loop()
  44  *  mt 6/99
  45  *
  46  *  initializes cod_info, scalefac and xrpow
  47  *
  48  *  returns 0 if all energies in xr are zero, else 1
  49  *
  50  ************************************************************************/
  51
  52 static int
  53 init_outer_loop(
  54     lame_internal_flags *gfc,
  55     gr_info *const cod_info,
  56     III_scalefac_t *const scalefac,
  57     const FLOAT8 xr[576],
  58     FLOAT8 xrpow[576] )
  59 {
  60     FLOAT8 tmp, sum = 0;
  61     int i;
  62
  63     /*  initialize fresh cod_info
  64      */
  65     cod_info->part2_3_length      = 0;
  66     cod_info->big_values          = 0;
  67     cod_info->count1              = 0;
  68     cod_info->global_gain         = 210;
  69     cod_info->scalefac_compress   = 0;
  70     /* window_switching_flag was set in psymodel.c? */
  71     /* block_type            was set in psymodel.c? */
  72     /* mixed_block_flag      would be set in ^      */
  73     cod_info->table_select [0]    = 0;
  74     cod_info->table_select [1]    = 0;
  75     cod_info->table_select [2]    = 0;
  76     cod_info->subblock_gain[0]    = 0;
  77     cod_info->subblock_gain[1]    = 0;
  78     cod_info->subblock_gain[2]    = 0;
  79     cod_info->region0_count       = 0;
  80     cod_info->region1_count       = 0;
  81     cod_info->preflag             = 0;
  82     cod_info->scalefac_scale      = 0;
  83     cod_info->count1table_select  = 0;
  84     cod_info->part2_length        = 0;
  85     if (cod_info->block_type == SHORT_TYPE) {
  86         cod_info->sfb_lmax        = 0;
  87         cod_info->sfb_smin        = 0;
  88         if (cod_info->mixed_block_flag) {
  89             /*
  90              *  MPEG-1:      sfbs 0-7 long block, 3-12 short blocks
  91              *  MPEG-2(.5):  sfbs 0-5 long block, 3-12 short blocks
  92              */
  93             cod_info->sfb_lmax    = gfc->is_mpeg1 ? 8 : 6;
  94             cod_info->sfb_smin    = 3;
  95         }
  96     } else {
  97         cod_info->sfb_lmax        = SBPSY_l;
  98         cod_info->sfb_smin        = SBPSY_s;
  99     }
 100     cod_info->count1bits          = 0;
 101     cod_info->sfb_partition_table = nr_of_sfb_block[0][0];
 102     cod_info->slen[0]             = 0;
 103     cod_info->slen[1]             = 0;
 104     cod_info->slen[2]             = 0;
 105     cod_info->slen[3]             = 0;
 106
 107     /*  fresh scalefactors are all zero
 108      */
 109     memset(scalefac, 0, sizeof(III_scalefac_t));
 110     memset(&gfc->pseudohalf, 0, sizeof(gfc->pseudohalf));
 111
 112     /*  check if there is some energy we have to quantize
 113      *  and calculate xrpow matching our fresh scalefactors
 114      */
 115     for (i = 0; i < 576; ++i) {
 116         tmp = fabs (xr[i]);
 117         sum += tmp;
 118         xrpow[i] = sqrt (tmp * sqrt(tmp));
 119     }
 120    /*  return 1 if we have something to quantize, else 0
 121     */
 122    return sum > (FLOAT8)1E-20;
 123 }
 124
 125
 126
 127 /************************************************************************
 128  *
 129  *      bin_search_StepSize()
 130  *
 131  *  author/date??
 132  *
 133  *  binary step size search
 134  *  used by outer_loop to get a quantizer step size to start with
 135  *
 136  ************************************************************************/
 137
 138 typedef enum {
 139     BINSEARCH_NONE,
 140     BINSEARCH_UP,
 141     BINSEARCH_DOWN
 142 } binsearchDirection_t;
 143
 144 int
 145 bin_search_StepSize(
 146           lame_internal_flags * const gfc,
 147           gr_info * const cod_info,
 148     const int             desired_rate,
 149     const int             start,
 150     const FLOAT8          xrpow [576],
 151           int             l3enc [576] )
 152 {
 153     int nBits;
 154     int CurrentStep;
 155     int flag_GoneOver = 0;
 156     int StepSize      = start;
 157
 158     binsearchDirection_t Direction = BINSEARCH_NONE;
 159     assert(gfc->CurrentStep);
 160     CurrentStep = gfc->CurrentStep;
 161
 162     do {
 163         cod_info->global_gain = StepSize;
 164         nBits = count_bits(gfc,l3enc,xrpow,cod_info);
 165
 166         if (CurrentStep == 1) break; /* nothing to adjust anymore */
 167
 168         if (flag_GoneOver) CurrentStep /= 2;
 169
 170         if (nBits > desired_rate) {
 171             /* increase Quantize_StepSize */
 172             if (Direction == BINSEARCH_DOWN && !flag_GoneOver) {
 173                 flag_GoneOver = 1;
 174                 CurrentStep  /= 2; /* late adjust */
 175             }
 176             Direction = BINSEARCH_UP;
 177             StepSize += CurrentStep;
 178             if (StepSize > 255) break;
 179         }
 180         else if (nBits < desired_rate) {
 181             /* decrease Quantize_StepSize */
 182             if (Direction == BINSEARCH_UP && !flag_GoneOver) {
 183                 flag_GoneOver = 1;
 184                 CurrentStep  /= 2; /* late adjust */
 185             }
 186             Direction = BINSEARCH_DOWN;
 187             StepSize -= CurrentStep;
 188             if (StepSize < 0) break;
 189         }
 190         else break; /* nBits == desired_rate;; most unlikely to happen.*/
 191     } while (1); /* For-ever, break is adjusted. */
 192
 193     CurrentStep = start - StepSize;
 194
 195     gfc->CurrentStep = CurrentStep/4 != 0 ? 4 : 2;
 196
 197     return nBits;
 198 }
 199
 200
 201
 202
 203 /***************************************************************************
 204  *
 205  *         inner_loop ()
 206  *
 207  *  author/date??
 208  *
 209  *  The code selects the best global gain for a particular set of scalefacs
 210  *
 211  ***************************************************************************/
 212
 213 int
 214 inner_loop(
 215           lame_internal_flags * const gfc,
 216           gr_info * const cod_info,
 217     const int             max_bits,
 218     const FLOAT8          xrpow [576],
 219           int             l3enc [576] )
 220 {
 221     int bits;
 222
 223     assert(max_bits >= 0);
 224
 225     /*  scalefactors may have changed, so count bits
 226      */
 227     bits=count_bits(gfc,l3enc,xrpow,cod_info);
 228
 229     /*  increase quantizer stepsize until needed bits are below maximum
 230      */
 231     while (bits > max_bits) {
 232         cod_info->global_gain++;
 233         bits = count_bits (gfc, l3enc, xrpow, cod_info);
 234     }
 235
 236     return bits;
 237 }
 238
 239
 240
 241 /*************************************************************************
 242  *
 243  *      loop_break()
 244  *
 245  *  author/date??
 246  *
 247  *  Function: Returns zero if there is a scalefac which has not been
 248  *            amplified. Otherwise it returns one.
 249  *
 250  *************************************************************************/
 251
 252 inline
 253 static int
 254 loop_break(
 255     const gr_info        * const cod_info,
 256     const III_scalefac_t * const scalefac )
 257 {
 258     int i, sfb;
 259
 260     for (sfb = 0; sfb < cod_info->sfb_lmax; sfb++)
 261         if (scalefac->l[sfb] == 0)
 262             return 0;
 263
 264     for (sfb = cod_info->sfb_smin; sfb < SBPSY_s; sfb++)
 265         for (i = 0; i < 3; i++)
 266             if (scalefac->s[sfb][i] == 0 && cod_info->subblock_gain[i] == 0)
 267                 return 0;
 268
 269     return 1;
 270 }
 271
 272
 273
 274
 275 /*************************************************************************
 276  *
 277  *      quant_compare()
 278  *
 279  *  author/date??
 280  *
 281  *  several different codes to decide which quantization is better
 282  *
 283  *************************************************************************/
 284
 285 inline
 286 static int
 287 quant_compare(
 288     const int                       experimentalX,
 289           lame_internal_flags * const gfc,
 290     const calc_noise_result * const best,
 291     const calc_noise_result   * const calc,
 292         const int                         block_type )
 293 {
 294     /*
 295        noise is given in decibels (dB) relative to masking thesholds.
 296
 297        over_noise:  ??? (the previous comment is fully wrong)
 298        tot_noise:   ??? (the previous comment is fully wrong)
 299        max_noise:   max quantization noise
 300
 301      */
 302     int better;
 303
 304     switch (experimentalX) {
 305         default:
 306         case 0:
 307             better = calc->over_count  < best->over_count
 308                ||  ( calc->over_count == best->over_count  &&
 309                      calc->over_noise  < best->over_noise )
 310                ||  ( calc->over_count == best->over_count  &&
 311                      calc->over_noise == best->over_noise  &&
 312                      calc->tot_noise   < best->tot_noise  );
 313             break;
 314         case 1:
 315             better = calc->max_noise < best->max_noise;
 316             break;
 317         case 2:
 318             better = calc->tot_noise < best->tot_noise;
 319             break;
 320         case 3:
 321                 better = ( calc->tot_noise < (gfc->presetTune.use &&
 322                                       block_type != NORM_TYPE ? (best->tot_noise - gfc->presetTune.quantcomp_adjust_rh_tot)
 323                                                           :  best->tot_noise ) &&
 324                    calc->max_noise < (gfc->presetTune.use &&
 325                                       block_type != NORM_TYPE ? (best->max_noise - gfc->presetTune.quantcomp_adjust_rh_max)
 326                                                           :  best->max_noise ));
 327             break;
 328         case 4:
 329             better = ( calc->max_noise <= 0  &&
 330                        best->max_noise >  2 )
 331                  ||  ( calc->max_noise <= 0  &&
 332                        best->max_noise <  0  &&
 333                        best->max_noise >  calc->max_noise-2  &&
 334                        calc->tot_noise <  best->tot_noise )
 335                  ||  ( calc->max_noise <= 0  &&
 336                        best->max_noise >  0  &&
 337                        best->max_noise >  calc->max_noise-2  &&
 338                        calc->tot_noise <  best->tot_noise+best->over_noise )
 339                  ||  ( calc->max_noise >  0  &&
 340                        best->max_noise > -0.5  &&
 341                        best->max_noise >  calc->max_noise-1  &&
 342                        calc->tot_noise+calc->over_noise < best->tot_noise+best->over_noise )
 343                  ||  ( calc->max_noise >  0  &&
 344                        best->max_noise > -1  &&
 345                        best->max_noise >  calc->max_noise-1.5  &&
 346                        calc->tot_noise+calc->over_noise+calc->over_noise < best->tot_noise+best->over_noise+best->over_noise );
 347             break;
 348         case 5:
 349             better =   calc->over_noise  < best->over_noise
 350                  ||  ( calc->over_noise == best->over_noise  &&
 351                        calc->tot_noise   < best->tot_noise );
 352             break;
 353         case 6:
 354             better =   calc->over_noise  < best->over_noise
 355                  ||  ( calc->over_noise == best->over_noise  &&
 356                      ( calc->max_noise   < best->max_noise
 357                      ||  ( calc->max_noise  == best->max_noise  &&
 358                            calc->tot_noise  <= best->tot_noise )
 359                       ));
 360             break;
 361         case 7:
 362             better =   calc->over_count < best->over_count
 363                    ||  calc->over_noise < best->over_noise;
 364             break;
 365         case 8:
 366             better =   calc->klemm_noise < best->klemm_noise;
 367             break;
 368     }
 369
 370     return better;
 371 }
 372
 373
 374
 375 /*************************************************************************
 376  *
 377  *          amp_scalefac_bands()
 378  *
 379  *  author/date??
 380  *
 381  *  Amplify the scalefactor bands that violate the masking threshold.
 382  *  See ISO 11172-3 Section C.1.5.4.3.5
 383  *
 384  *  distort[] = noise/masking
 385  *  distort[] > 1   ==> noise is not masked
 386  *  distort[] < 1   ==> noise is masked
 387  *  max_dist = maximum value of distort[]
 388  *
 389  *  Three algorithms:
 390  *  noise_shaping_amp
 391  *        0             Amplify all bands with distort[]>1.
 392  *
 393  *        1             Amplify all bands with distort[] >= max_dist^(.5);
 394  *                     ( 50% in the db scale)
 395  *
 396  *        2             Amplify first band with distort[] >= max_dist;
 397  *
 398  *
 399  *  For algorithms 0 and 1, if max_dist < 1, then amplify all bands
 400  *  with distort[] >= .95*max_dist.  This is to make sure we always
 401  *  amplify at least one band.
 402  *
 403  *
 404  *************************************************************************/
 405 static void
 406 amp_scalefac_bands(
 407     lame_global_flags *gfp,
 408     const gr_info  *const cod_info,
 409     III_scalefac_t *const scalefac,
 410     III_psy_xmin *distort,
 411     FLOAT8 xrpow[576] )
 412 {
 413   lame_internal_flags *gfc=gfp->internal_flags;
 414   int start, end, l,i,j,sfb;
 415   FLOAT8 ifqstep34, trigger;
 416
 417   if (cod_info->scalefac_scale == 0) {
 418     ifqstep34 = 1.29683955465100964055; /* 2**(.75*.5)*/
 419   } else {
 420     ifqstep34 = 1.68179283050742922612;  /* 2**(.75*1) */
 421   }
 422
 423   /* compute maximum value of distort[]  */
 424   trigger = 0;
 425   for (sfb = 0; sfb < cod_info->sfb_lmax; sfb++) {
 426     if (trigger < distort->l[sfb])
 427         trigger = distort->l[sfb];
 428   }
 429   for (sfb = cod_info->sfb_smin; sfb < SBPSY_s; sfb++) {
 430     for (i = 0; i < 3; i++ ) {
 431       if (trigger < distort->s[sfb][i])
 432           trigger = distort->s[sfb][i];
 433     }
 434   }
 435
 436   switch (gfc->noise_shaping_amp) {
 437
 438   case 3:
 439   case 2:
 440     /* amplify exactly 1 band */
 441     //trigger = distort_thresh;
 442     break;
 443
 444   case 1:
 445     /* amplify bands within 50% of max (on db scale) */
 446     if (trigger>1.0)
 447         trigger = pow(trigger, .5);
 448     else
 449       trigger *= .95;
 450     break;
 451
 452   case 0:
 453   default:
 454     /* ISO algorithm.  amplify all bands with distort>1 */
 455     if (trigger>1.0)
 456         trigger=1.0;
 457     else
 458         trigger *= .95;
 459     break;
 460   }
 461
 462   for (sfb = 0; sfb < cod_info->sfb_lmax; sfb++ ) {
 463     start = gfc->scalefac_band.l[sfb];
 464     end   = gfc->scalefac_band.l[sfb+1];
 465     if (distort->l[sfb]>=trigger  ) {
 466       if (gfc->noise_shaping_amp==3) {
 467         if (gfc->pseudohalf.l[sfb]) {
 468           gfc->pseudohalf.l[sfb] = 0;
 469           goto done;
 470         }
 471         gfc->pseudohalf.l[sfb] = 1;
 472       }
 473       scalefac->l[sfb]++;
 474       for ( l = start; l < end; l++ )
 475         xrpow[l] *= ifqstep34;
 476       if (gfc->noise_shaping_amp==2
 477           ||gfc->noise_shaping_amp==3) goto done;
 478     }
 479   }
 480
 481   for ( j=0,sfb = cod_info->sfb_smin; sfb < SBPSY_s; sfb++ ) {
 482     start = gfc->scalefac_band.s[sfb];
 483     end   = gfc->scalefac_band.s[sfb+1];
 484     for ( i = 0; i < 3; i++ ) {
 485       int j2 = j;
 486       if ( distort->s[sfb][i]>=trigger) {
 487         if (gfc->noise_shaping_amp==3) {
 488           if (gfc->pseudohalf.s[sfb][i]) {
 489             gfc->pseudohalf.s[sfb][i] = 0;
 490             goto done;
 491           }
 492           gfc->pseudohalf.s[sfb][i] = 1;
 493         }
 494         scalefac->s[sfb][i]++;
 495         for (l = start; l < end; l++)
 496           xrpow[j2++] *= ifqstep34;
 497         if (gfc->noise_shaping_amp==2
 498             ||gfc->noise_shaping_amp==3) goto done;
 499       }
 500       j += end-start;
 501     }
 502   }
 503  done:
 504  return;
 505 }
 506
 507 /*************************************************************************
 508  *
 509  *      inc_scalefac_scale()
 510  *
 511  *  Takehiro Tominaga 2000-xx-xx
 512  *
 513  *  turns on scalefac scale and adjusts scalefactors
 514  *
 515  *************************************************************************/
 516
 517 static void
 518 inc_scalefac_scale (
 519     const lame_internal_flags        * const gfc,
 520           gr_info        * const cod_info,
 521           III_scalefac_t * const scalefac,
 522           FLOAT8                 xrpow[576] )
 523 {
 524     int start, end, l,i,j;
 525     int sfb;
 526     const FLOAT8 ifqstep34 = 1.29683955465100964055;
 527
 528     for (sfb = 0; sfb < cod_info->sfb_lmax; sfb++) {
 529         int s = scalefac->l[sfb] + (cod_info->preflag ? pretab[sfb] : 0);
 530         if (s & 1) {
 531             s++;
 532             start = gfc->scalefac_band.l[sfb];
 533             end   = gfc->scalefac_band.l[sfb+1];
 534             for (l = start; l < end; l++)
 535                 xrpow[l] *= ifqstep34;
 536         }
 537         scalefac->l[sfb]  = s >> 1;
 538         cod_info->preflag = 0;
 539     }
 540
 541     for (j = 0, sfb = cod_info->sfb_smin; sfb < SBPSY_s; sfb++) {
 542     start = gfc->scalefac_band.s[sfb];
 543     end   = gfc->scalefac_band.s[sfb+1];
 544     for (i = 0; i < 3; i++) {
 545         int j2 = j;
 546         if (scalefac->s[sfb][i] & 1) {
 547         scalefac->s[sfb][i]++;
 548         for (l = start; l < end; l++)
 549             xrpow[j2++] *= ifqstep34;
 550         }
 551         scalefac->s[sfb][i] >>= 1;
 552         j += end-start;
 553     }
 554     }
 555     cod_info->scalefac_scale = 1;
 556 }
 557
 558
 559
 560 /*************************************************************************
 561  *
 562  *      inc_subblock_gain()
 563  *
 564  *  Takehiro Tominaga 2000-xx-xx
 565  *
 566  *  increases the subblock gain and adjusts scalefactors
 567  *
 568  *************************************************************************/
 569
 570 static int
 571 inc_subblock_gain (
 572     const lame_internal_flags        * const gfc,
 573           gr_info        * const cod_info,
 574           III_scalefac_t * const scalefac,
 575           FLOAT8                 xrpow[576] )
 576 {
 577     int window;
 578
 579     for (window = 0; window < 3; window++) {
 580         int s1, s2, l;
 581         int sfb;
 582         s1 = s2 = 0;
 583
 584         for (sfb = cod_info->sfb_smin; sfb < 6; sfb++) {
 585             if (s1 < scalefac->s[sfb][window])
 586             s1 = scalefac->s[sfb][window];
 587         }
 588         for (; sfb < SBPSY_s; sfb++) {
 589             if (s2 < scalefac->s[sfb][window])
 590             s2 = scalefac->s[sfb][window];
 591         }
 592
 593         if (s1 < 16 && s2 < 8)
 594             continue;
 595
 596         if (cod_info->subblock_gain[window] >= 7)
 597             return 1;
 598
 599         /* even though there is no scalefactor for sfb12
 600          * subblock gain affects upper frequencies too, that's why
 601          * we have to go up to SBMAX_s
 602          */
 603         cod_info->subblock_gain[window]++;
 604         for (sfb = cod_info->sfb_smin; sfb < SBMAX_s; sfb++) {
 605             int i, width;
 606             int s = scalefac->s[sfb][window];
 607             FLOAT8 amp;
 608
 609             if (s < 0)
 610                 continue;
 611             s = s - (4 >> cod_info->scalefac_scale);
 612             if (s >= 0) {
 613                 scalefac->s[sfb][window] = s;
 614                 continue;
 615             }
 616
 617             scalefac->s[sfb][window] = 0;
 618             width = gfc->scalefac_band.s[sfb] - gfc->scalefac_band.s[sfb+1];
 619             i = gfc->scalefac_band.s[sfb] * 3 + width * window;
 620             amp = IPOW20(210 + (s << (cod_info->scalefac_scale + 1)));
 621             for (l = 0; l < width; l++) {
 622                 xrpow[i++] *= amp;
 623             }
 624         }
 625     }
 626     return 0;
 627 }
 628
 629
 630
 631 /********************************************************************
 632  *
 633  *      balance_noise()
 634  *
 635  *  Takehiro Tominaga /date??
 636  *  Robert Hegemann 2000-09-06: made a function of it
 637  *
 638  *  amplifies scalefactor bands,
 639  *   - if all are already amplified returns 0
 640  *   - if some bands are amplified too much:
 641  *      * try to increase scalefac_scale
 642  *      * if already scalefac_scale was set
 643  *          try on short blocks to increase subblock gain
 644  *
 645  ********************************************************************/
 646 inline
 647 static int
 648 balance_noise (
 649     lame_global_flags  *const gfp,
 650     gr_info        * const cod_info,
 651     III_scalefac_t * const scalefac,
 652     III_psy_xmin           *distort,
 653     FLOAT8                 xrpow[576] )
 654 {
 655     lame_internal_flags *const gfc = (lame_internal_flags *)gfp->internal_flags;
 656     int status;
 657
 658     amp_scalefac_bands ( gfp, cod_info, scalefac, distort, xrpow);
 659
 660     /* check to make sure we have not amplified too much
 661      * loop_break returns 0 if there is an unamplified scalefac
 662      * scale_bitcount returns 0 if no scalefactors are too large
 663      */
 664
 665     status = loop_break (cod_info, scalefac);
 666
 667     if (status)
 668         return 0; /* all bands amplified */
 669
 670     /* not all scalefactors have been amplified.  so these
 671      * scalefacs are possibly valid.  encode them:
 672      */
 673     if (gfc->is_mpeg1)
 674         status = scale_bitcount (scalefac, cod_info);
 675     else
 676         status = scale_bitcount_lsf (gfc, scalefac, cod_info);
 677
 678     if (!status)
 679         return 1; /* amplified some bands not exceeding limits */
 680
 681     /*  some scalefactors are too large.
 682      *  lets try setting scalefac_scale=1
 683      */
 684     if ((gfc->noise_shaping > 1) && (!(gfc->presetTune.use &&
 685                                       gfc->ATH->adjust < gfc->presetTune.athadjust_switch_level))) {
 686         memset(&gfc->pseudohalf, 0, sizeof(gfc->pseudohalf));
 687         if (!cod_info->scalefac_scale) {
 688             inc_scalefac_scale (gfc, cod_info, scalefac, xrpow);
 689             status = 0;
 690         } else {
 691             if (cod_info->block_type == SHORT_TYPE ) {
 692                 status = inc_subblock_gain (gfc, cod_info, scalefac, xrpow)
 693                     || loop_break (cod_info, scalefac);
 694             }
 695         }
 696     }
 697
 698     if (!status) {
 699         if (gfc->is_mpeg1 == 1)
 700             status = scale_bitcount (scalefac, cod_info);
 701         else
 702             status = scale_bitcount_lsf (gfc, scalefac, cod_info);
 703     }
 704     return !status;
 705 }
 706
 707
 708
 709 /************************************************************************
 710  *
 711  *  outer_loop ()
 712  *
 713  *  Function: The outer iteration loop controls the masking conditions
 714  *  of all scalefactorbands. It computes the best scalefac and
 715  *  global gain. This module calls the inner iteration loop
 716  *
 717  *  mt 5/99 completely rewritten to allow for bit reservoir control,
 718  *  mid/side channels with L/R or mid/side masking thresholds,
 719  *  and chooses best quantization instead of last quantization when
 720  *  no distortion free quantization can be found.
 721  *
 722  *  added VBR support mt 5/99
 723  *
 724  *  some code shuffle rh 9/00
 725  ************************************************************************/
 726
 727 static int
 728 outer_loop (
 729    lame_global_flags *gfp,
 730           gr_info        * const cod_info,
 731     const FLOAT8                 xr[576],   /* magnitudes of spectral values */
 732     const III_psy_xmin   * const l3_xmin,   /* allowed distortion of the scalefactor */
 733           III_scalefac_t * const scalefac,  /* scalefactors */
 734           FLOAT8                 xrpow[576], /* coloured magnitudes of spectral values */
 735           int                    l3enc[576], /* vector of quantized values ix(0..575) */
 736     const int                    ch,
 737     const int                    targ_bits )  /* maximum allowed bits */
 738 {
 739     lame_internal_flags *gfc=gfp->internal_flags;
 740     III_scalefac_t save_scalefac;
 741     gr_info save_cod_info;
 742     FLOAT8 save_xrpow[576];
 743     III_psy_xmin   distort;
 744     calc_noise_result noise_info;
 745     calc_noise_result best_noise_info;
 746     int l3_enc_w[576];
 747     int iteration = 0;
 748     int bits_found;
 749     int huff_bits;
 750     int real_bits;
 751     int better;
 752     int over;
 753
 754     int copy = 0;
 755     int age = 0;
 756
 757     noise_info.over_count = 100;
 758     noise_info.max_noise  = 0;
 759     noise_info.tot_noise  = 0;
 760     noise_info.over_noise = 0;
 761
 762     best_noise_info.over_count = 100;
 763
 764     bits_found = bin_search_StepSize (gfc, cod_info, targ_bits,
 765                                       gfc->OldValue[ch], xrpow, l3_enc_w);
 766     gfc->OldValue[ch] = cod_info->global_gain;
 767
 768     /* BEGIN MAIN LOOP */
 769     do {
 770         iteration ++;
 771
 772         /* inner_loop starts with the initial quantization step computed above
 773          * and slowly increases until the bits < huff_bits.
 774          * Thus it is important not to start with too large of an inital
 775          * quantization step.  Too small is ok, but inner_loop will take longer
 776          */
 777         huff_bits = targ_bits - cod_info->part2_length;
 778         if (huff_bits < 0) {
 779             assert(iteration != 1);
 780             /*  scale factors too large, not enough bits.
 781              *  use previous quantizaton */
 782             break;
 783         }
 784         /*  if this is the first iteration,
 785          *  see if we can reuse the quantization computed in
 786          *  bin_search_StepSize above */
 787
 788         if (iteration == 1) {
 789             if (bits_found > huff_bits) {
 790                 cod_info->global_gain++;
 791                 real_bits = inner_loop (gfc, cod_info, huff_bits, xrpow,
 792                                         l3_enc_w);
 793             } else {
 794                 real_bits = bits_found;
 795             }
 796         } else {
 797             real_bits = inner_loop (gfc, cod_info, huff_bits, xrpow,
 798                                     l3_enc_w);
 799         }
 800
 801         cod_info->part2_3_length = real_bits;
 802
 803         /* compute the distortion in this quantization */
 804         if (gfc->noise_shaping)
 805             /* coefficients and thresholds both l/r (or both mid/side) */
 806             over = calc_noise (gfc, xr, l3_enc_w, cod_info, l3_xmin,
 807                                scalefac, &distort, &noise_info);
 808         else {
 809             /* fast mode, no noise shaping, we are ready */
 810             best_noise_info = noise_info;
 811             copy = 0;
 812             memcpy(l3enc, l3_enc_w, sizeof(int)*576);
 813             break;
 814         }
 815
 816
 817         /* check if this quantization is better
 818          * than our saved quantization */
 819         if (iteration == 1) /* the first iteration is always better */
 820             better = 1;
 821         else
 822             better = quant_compare ((gfc->presetTune.use ? gfc->presetTune.quantcomp_current
 823                                                          : gfp->experimentalX),
 824                                      gfc, &best_noise_info, &noise_info, cod_info->block_type);
 825
 826         /* save data so we can restore this quantization later */
 827         if (better) {
 828             copy = 0;
 829             best_noise_info = noise_info;
 830             memcpy(l3enc, l3_enc_w, sizeof(int)*576);
 831             age = 0;
 832         }
 833         else
 834             age ++;
 835
 836
 837         /******************************************************************/
 838         /* stopping criterion */
 839         /******************************************************************/
 840         /* if no bands with distortion and -X0, we are done */
 841         if (0==gfc->noise_shaping_stop &&
 842             0==gfp->experimentalX &&
 843             (over == 0 || best_noise_info.over_count == 0) )
 844             break;
 845         /* Otherwise, allow up to 3 unsuccesful tries in serial, then stop
 846          * if our best quantization so far had no distorted bands. This
 847          * gives us more possibilities for different quant_compare modes.
 848          * Much more than 3 makes not a big difference, it is only slower.
 849          */
 850         if (age > 3 && best_noise_info.over_count == 0)
 851             break;
 852
 853         /* Check if the last scalefactor band is distorted.
 854          * in VBR mode we can't get rid of the distortion, so quit now
 855          * and VBR mode will try again with more bits.
 856          * (makes a 10% speed increase, the files I tested were
 857          * binary identical, 2000/05/20 Robert.Hegemann@gmx.de)
 858          * distort[] > 1 means noise > allowed noise
 859          */
 860         if (gfc->sfb21_extra) {
 861             if (cod_info->block_type == SHORT_TYPE) {
 862                 if (distort.s[SBMAX_s-1][0] > 1 ||
 863                     distort.s[SBMAX_s-1][1] > 1 ||
 864                     distort.s[SBMAX_s-1][2] > 1) break;
 865             } else {
 866                 if (distort.l[SBMAX_l-1] > 1) break;
 867             }
 868         }
 869
 870         /* save data so we can restore this quantization later */
 871         if (better) {
 872             copy = 1;
 873             save_scalefac = *scalefac;
 874             save_cod_info = *cod_info;
 875             if (gfp->VBR == vbr_rh || gfp->VBR == vbr_mtrh) {
 876                 /* store for later reuse */
 877                 memcpy(save_xrpow, xrpow, sizeof(FLOAT8)*576);
 878             }
 879         }
 880
 881         if (balance_noise (gfp, cod_info, scalefac, &distort, xrpow) == 0)
 882             break;
 883     }
 884     while (1); /* main iteration loop, breaks adjusted */
 885
 886     /*  finish up
 887      */
 888     if (copy) {
 889         *cod_info = save_cod_info;
 890         *scalefac = save_scalefac;
 891         if (gfp->VBR == vbr_rh || gfp->VBR == vbr_mtrh)
 892             /* restore for reuse on next try */
 893             memcpy(xrpow, save_xrpow, sizeof(FLOAT8)*576);
 894     }
 895     cod_info->part2_3_length += cod_info->part2_length;
 896
 897     assert (cod_info->global_gain < 256);
 898
 899     return best_noise_info.over_count;
 900 }
 901
 902
 903
 904
 905 /************************************************************************
 906  *
 907  *      iteration_finish()
 908  *
 909  *  Robert Hegemann 2000-09-06
 910  *
 911  *  update reservoir status after FINAL quantization/bitrate
 912  *
 913  *  rh 2000-09-06: it will not work with CBR due to the bitstream formatter
 914  *            you will get "Error: MAX_HEADER_BUF too small in bitstream.c"
 915  *
 916  ************************************************************************/
 917
 918 static void
 919 iteration_finish (
 920     lame_internal_flags *gfc,
 921     FLOAT8          xr      [2][2][576],
 922     int             l3_enc  [2][2][576],
 923     III_scalefac_t  scalefac[2][2],
 924     const int       mean_bits )
 925 {
 926     III_side_info_t *l3_side = &gfc->l3_side;
 927     int gr, ch, i;
 928
 929     for (gr = 0; gr < gfc->mode_gr; gr++) {
 930         for (ch = 0; ch < gfc->channels_out; ch++) {
 931             gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
 932
 933             /*  try some better scalefac storage
 934              */
 935             best_scalefac_store (gfc, gr, ch, l3_enc, l3_side, scalefac);
 936
 937             /*  best huffman_divide may save some bits too
 938              */
 939             if (gfc->use_best_huffman == 1)
 940                 best_huffman_divide (gfc, cod_info, l3_enc[gr][ch]);
 941
 942             /*  update reservoir status after FINAL quantization/bitrate
 943              */
 944             ResvAdjust (gfc, cod_info, l3_side, mean_bits);
 945
 946             /*  set the sign of l3_enc from the sign of xr
 947              */
 948             for (i = 0; i < 576; i++) {
 949                 if (xr[gr][ch][i] < 0) l3_enc[gr][ch][i] *= -1;
 950             }
 951         } /* for ch */
 952     }    /* for gr */
 953
 954     ResvFrameEnd (gfc, l3_side, mean_bits);
 955 }
 956
 957
 958
 959 /*********************************************************************
 960  *
 961  *      VBR_encode_granule()
 962  *
 963  *  2000-09-04 Robert Hegemann
 964  *
 965  *********************************************************************/
 966
 967 static void
 968 VBR_encode_granule (
 969           lame_global_flags *gfp,
 970           gr_info        * const cod_info,
 971           FLOAT8                 xr[576],     /* magnitudes of spectral values */
 972     const III_psy_xmin   * const l3_xmin,     /* allowed distortion of the scalefactor */
 973           III_scalefac_t * const scalefac,    /* scalefactors */
 974           FLOAT8                 xrpow[576],  /* coloured magnitudes of spectral values */
 975           int                    l3_enc[576], /* vector of quantized values ix(0..575) */
 976     const int                    ch,
 977           int                    min_bits,
 978           int                    max_bits )
 979 {
 980     lame_internal_flags *gfc=gfp->internal_flags;
 981     gr_info         bst_cod_info;
 982     III_scalefac_t  bst_scalefac;
 983     FLOAT8          bst_xrpow [576];
 984     int             bst_l3_enc[576];
 985     int Max_bits  = max_bits;
 986     int real_bits = max_bits+1;
 987     int this_bits = (max_bits+min_bits)/2;
 988     int dbits, over, found = 0;
 989     int sfb21_extra = gfc->sfb21_extra;
 990
 991     assert(Max_bits <= MAX_BITS);
 992
 993     /*  search within round about 40 bits of optimal
 994      */
 995     do {
 996         assert(this_bits >= min_bits);
 997         assert(this_bits <= max_bits);
 998         assert(min_bits <= max_bits);
 999
1000         if (this_bits > Max_bits-42)
1001             gfc->sfb21_extra = 0;
1002         else
1003             gfc->sfb21_extra = sfb21_extra;
1004
1005         over = outer_loop ( gfp, cod_info, xr, l3_xmin, scalefac,
1006                             xrpow, l3_enc, ch, this_bits );
1007
1008         /*  is quantization as good as we are looking for ?
1009          *  in this case: is no scalefactor band distorted?
1010          */
1011         if (over <= 0) {
1012             found = 1;
1013             /*  now we know it can be done with "real_bits"
1014              *  and maybe we can skip some iterations
1015              */
1016             real_bits = cod_info->part2_3_length;
1017
1018             /*  store best quantization so far
1019              */
1020             bst_cod_info = *cod_info;
1021             bst_scalefac = *scalefac;
1022             memcpy(bst_xrpow, xrpow, sizeof(FLOAT8)*576);
1023             memcpy(bst_l3_enc, l3_enc, sizeof(int)*576);
1024
1025             /*  try with fewer bits
1026              */
1027             max_bits  = real_bits-32;
1028             dbits     = max_bits-min_bits;
1029             this_bits = (max_bits+min_bits)/2;
1030         }
1031         else {
1032             /*  try with more bits
1033              */
1034             min_bits  = this_bits+32;
1035             dbits     = max_bits-min_bits;
1036             this_bits = (max_bits+min_bits)/2;
1037
1038             if (found) {
1039                 found = 2;
1040                 /*  start again with best quantization so far
1041                  */
1042                 *cod_info = bst_cod_info;
1043                 *scalefac = bst_scalefac;
1044                 memcpy(xrpow, bst_xrpow, sizeof(FLOAT8)*576);
1045             }
1046         }
1047     } while (dbits>12);
1048
1049     gfc->sfb21_extra = sfb21_extra;
1050
1051     /*  found=0 => nothing found, use last one
1052      *  found=1 => we just found the best and left the loop
1053      *  found=2 => we restored a good one and have now l3_enc to restore too
1054      */
1055     if (found==2) {
1056         memcpy(l3_enc, bst_l3_enc, sizeof(int)*576);
1057     }
1058     assert(cod_info->part2_3_length <= Max_bits);
1059
1060 }
1061
1062
1063
1064 /************************************************************************
1065  *
1066  *      get_framebits()
1067  *
1068  *  Robert Hegemann 2000-09-05
1069  *
1070  *  calculates
1071  *  * how many bits are available for analog silent granules
1072  *  * how many bits to use for the lowest allowed bitrate
1073  *  * how many bits each bitrate would provide
1074  *
1075  ************************************************************************/
1076
1077 static void
1078 get_framebits (
1079     lame_global_flags *gfp,
1080     int     * const analog_mean_bits,
1081     int     * const min_mean_bits,
1082     int             frameBits[15] )
1083 {
1084     lame_internal_flags *gfc=gfp->internal_flags;
1085     int bitsPerFrame, mean_bits, i;
1086     III_side_info_t *l3_side = &gfc->l3_side;
1087
1088     /*  always use at least this many bits per granule per channel
1089      *  unless we detect analog silence, see below
1090      */
1091     gfc->bitrate_index = gfc->VBR_min_bitrate;
1092     getframebits (gfp, &bitsPerFrame, &mean_bits);
1093     *min_mean_bits = mean_bits / gfc->channels_out;
1094
1095     /*  bits for analog silence
1096      */
1097     gfc->bitrate_index = 1;
1098     getframebits (gfp, &bitsPerFrame, &mean_bits);
1099     *analog_mean_bits = mean_bits / gfc->channels_out;
1100
1101     for (i = 1; i <= gfc->VBR_max_bitrate; i++) {
1102         gfc->bitrate_index = i;
1103         getframebits (gfp, &bitsPerFrame, &mean_bits);
1104         frameBits[i] = ResvFrameBegin (gfp, l3_side, mean_bits, bitsPerFrame);
1105     }
1106 }
1107
1108
1109
1110 /************************************************************************
1111  *
1112  *      calc_min_bits()
1113  *
1114  *  Robert Hegemann 2000-09-04
1115  *
1116  *  determine minimal bit skeleton
1117  *
1118  ************************************************************************/
1119 inline
1120 static int
1121 calc_min_bits (
1122     lame_global_flags *gfp,
1123     const gr_info * const cod_info,
1124     const int             pe,
1125     const FLOAT8          ms_ener_ratio,
1126     const int             bands,
1127     const int             mch_bits,
1128     const int             analog_mean_bits,
1129     const int             min_mean_bits,
1130     const int             analog_silence,
1131     const int             ch )
1132 {
1133     lame_internal_flags *gfc=gfp->internal_flags;
1134     int min_bits, min_pe_bits;
1135
1136     if (gfc->nsPsy.use) return 126;
1137                     /*  changed minimum from 1 to 126 bits
1138                      *  the iteration loops require a minimum of bits
1139                      *  for each granule to start with; robert 2001-07-02 */
1140
1141     /*  base amount of minimum bits
1142      */
1143     min_bits = Max (126, min_mean_bits);
1144
1145     if (gfc->mode_ext == MPG_MD_MS_LR && ch == 1)
1146         min_bits = Max (min_bits, mch_bits/5);
1147
1148     /*  bit skeleton based on PE
1149      */
1150     if (cod_info->block_type == SHORT_TYPE)
1151         /*  if LAME switches to short blocks then pe is
1152          *  >= 1000 on medium surge
1153          *  >= 3000 on big surge
1154          */
1155         min_pe_bits = (pe-350) * bands/39;
1156     else
1157         min_pe_bits = (pe-350) * bands/22;
1158
1159     if (gfc->mode_ext == MPG_MD_MS_LR && ch == 1) {
1160         /*  side channel will use a lower bit skeleton based on PE
1161          */
1162         FLOAT8 fac  = .33 * (.5 - ms_ener_ratio) / .5;
1163         min_pe_bits = (int)(min_pe_bits * ((1-fac)/(1+fac)));
1164     }
1165     min_pe_bits = Min (min_pe_bits, (1820 * gfp->out_samplerate / 44100));
1166
1167     /*  determine final minimum bits
1168      */
1169     if (analog_silence && !gfp->VBR_hard_min)
1170         min_bits = analog_mean_bits;
1171     else
1172         min_bits = Max (min_bits, min_pe_bits);
1173
1174     return min_bits;
1175 }
1176
1177
1178
1179 /*********************************************************************
1180  *
1181  *      VBR_prepare()
1182  *
1183  *  2000-09-04 Robert Hegemann
1184  *
1185  *  * converts LR to MS coding when necessary
1186  *  * calculates allowed/adjusted quantization noise amounts
1187  *  * detects analog silent frames
1188  *
1189  *  some remarks:
1190  *  - lower masking depending on Quality setting
1191  *  - quality control together with adjusted ATH MDCT scaling
1192  *    on lower quality setting allocate more noise from
1193  *    ATH masking, and on higher quality setting allocate
1194  *    less noise from ATH masking.
1195  *  - experiments show that going more than 2dB over GPSYCHO's
1196  *    limits ends up in very annoying artefacts
1197  *
1198  *********************************************************************/
1199
1200 /* RH: this one needs to be overhauled sometime */
1201
1202 static int
1203 VBR_prepare (
1204           lame_global_flags *gfp,
1205           FLOAT8          pe            [2][2],
1206           FLOAT8          ms_ener_ratio [2],
1207           FLOAT8          xr            [2][2][576],
1208           III_psy_ratio   ratio         [2][2],
1209           III_psy_xmin    l3_xmin       [2][2],
1210           int             frameBits     [16],
1211           int            *analog_mean_bits,
1212           int            *min_mean_bits,
1213           int             min_bits      [2][2],
1214           int             max_bits      [2][2],
1215           int             bands         [2][2] )
1216 {
1217     lame_internal_flags *gfc=gfp->internal_flags;
1218
1219
1220     FLOAT8  masking_lower_db, adjust = 0.0;
1221     int     gr, ch;
1222     int     analog_silence = 1;
1223     int     bpf, avg, mxb, bits = 0;
1224
1225     gfc->bitrate_index = gfc->VBR_max_bitrate;
1226     getframebits (gfp, &bpf, &avg);
1227     bpf = ResvFrameBegin (gfp, &gfc->l3_side, avg, bpf );
1228     avg = (bpf - 8*gfc->sideinfo_len) / gfc->mode_gr;
1229
1230     get_framebits (gfp, analog_mean_bits, min_mean_bits, frameBits);
1231
1232     for (gr = 0; gr < gfc->mode_gr; gr++) {
1233         mxb = on_pe (gfp, pe, &gfc->l3_side, max_bits[gr], avg, gr);
1234         if (gfc->mode_ext == MPG_MD_MS_LR) {
1235             ms_convert (xr[gr], xr[gr]);
1236             reduce_side (max_bits[gr], ms_ener_ratio[gr], avg, mxb);
1237         }
1238         for (ch = 0; ch < gfc->channels_out; ++ch) {
1239             gr_info *cod_info = &gfc->l3_side.gr[gr].ch[ch].tt;
1240
1241             if (gfc->nsPsy.use && gfp->VBR == vbr_rh) {
1242             if (cod_info->block_type == NORM_TYPE)
1243                 adjust = 1.28/(1+exp(3.5-pe[gr][ch]/300.))-0.05;
1244             else
1245                 adjust = 2.56/(1+exp(3.5-pe[gr][ch]/300.))-0.14;
1246             }
1247             masking_lower_db   = gfc->VBR->mask_adjust - adjust;
1248             gfc->masking_lower = pow (10.0, masking_lower_db * 0.1);
1249
1250             bands[gr][ch] = calc_xmin (gfp, xr[gr][ch], ratio[gr]+ch,
1251                                        cod_info, l3_xmin[gr]+ch);
1252             if (bands[gr][ch])
1253                 analog_silence = 0;
1254
1255             min_bits[gr][ch] = calc_min_bits (gfp, cod_info, (int)pe[gr][ch],
1256                                       ms_ener_ratio[gr], bands[gr][ch],
1257                                       0, *analog_mean_bits,
1258                                       *min_mean_bits, analog_silence, ch);
1259
1260             bits += max_bits[gr][ch];
1261         }
1262     }
1263     for (gr = 0; gr < gfc->mode_gr; gr++) {
1264         for (ch = 0; ch < gfc->channels_out; ch++) {
1265             if (bits > frameBits[gfc->VBR_max_bitrate]) {
1266                 max_bits[gr][ch] *= frameBits[gfc->VBR_max_bitrate];
1267                 max_bits[gr][ch] /= bits;
1268             }
1269             if (min_bits[gr][ch] > max_bits[gr][ch])
1270                 min_bits[gr][ch] = max_bits[gr][ch];
1271
1272         } /* for ch */
1273     }  /* for gr */
1274
1275     *min_mean_bits = Max(*min_mean_bits, 126);
1276
1277     return analog_silence;
1278 }
1279
1280
1281 inline
1282 void bitpressure_strategy1(
1283     lame_internal_flags * gfc,
1284     III_psy_xmin l3_xmin[2][2],
1285     int min_bits[2][2],
1286     int max_bits[2][2] )
1287 {
1288     int gr, ch, sfb;
1289     for (gr = 0; gr < gfc->mode_gr; gr++) {
1290         for (ch = 0; ch < gfc->channels_out; ch++) {
1291             if (gfc->l3_side.gr[gr].ch[ch].tt.block_type == SHORT_TYPE) {
1292                 for (sfb = 0; sfb < SBMAX_s; sfb++) {
1293                     l3_xmin[gr][ch].s[sfb][0] *= 1.+.029*sfb*sfb/SBMAX_s/SBMAX_s;
1294                     l3_xmin[gr][ch].s[sfb][1] *= 1.+.029*sfb*sfb/SBMAX_s/SBMAX_s;
1295                     l3_xmin[gr][ch].s[sfb][2] *= 1.+.029*sfb*sfb/SBMAX_s/SBMAX_s;
1296                 }
1297             }
1298             else {
1299                 for (sfb = 0; sfb < SBMAX_l; sfb++)
1300                     l3_xmin[gr][ch].l[sfb] *= 1.+.029*sfb*sfb/SBMAX_l/SBMAX_l;
1301             }
1302             max_bits[gr][ch] = Max(min_bits[gr][ch], 0.9*max_bits[gr][ch]);
1303         }
1304     }
1305 }
1306
1307 inline
1308 void bitpressure_strategy2(
1309     lame_internal_flags * gfc,
1310     int bpf, int used, int save_bits[2][2],
1311     int min_bits[2][2], int max_bits[2][2] )
1312 {
1313     int gr, ch;
1314     for (gr = 0; gr < gfc->mode_gr; gr++) {
1315         for (ch = 0; ch < gfc->channels_out; ch++) {
1316             max_bits[gr][ch]  = save_bits[gr][ch];
1317             max_bits[gr][ch] *= bpf;
1318             max_bits[gr][ch] /= used;
1319             max_bits[gr][ch]  = Max(min_bits[gr][ch],max_bits[gr][ch]);
1320         }
1321     }
1322 }
1323
1324 /************************************************************************
1325  *
1326  *      VBR_iteration_loop()
1327  *
1328  *  tries to find out how many bits are needed for each granule and channel
1329  *  to get an acceptable quantization. An appropriate bitrate will then be
1330  *  choosed for quantization.  rh 8/99
1331  *
1332  *  Robert Hegemann 2000-09-06 rewrite
1333  *
1334  ************************************************************************/
1335
1336 void
1337 VBR_iteration_loop (
1338     lame_global_flags *gfp,
1339     FLOAT8             pe           [2][2],
1340     FLOAT8             ms_ener_ratio[2],
1341     FLOAT8             xr           [2][2][576],
1342     III_psy_ratio      ratio        [2][2],
1343     int                l3_enc       [2][2][576],
1344     III_scalefac_t     scalefac     [2][2] )
1345 {
1346     lame_internal_flags *gfc=gfp->internal_flags;
1347     III_psy_xmin l3_xmin[2][2];
1348
1349     FLOAT8    xrpow[576];
1350     int       bands[2][2];
1351     int       frameBits[15];
1352     int       bitsPerFrame;
1353     int       save_bits[2][2];
1354     int       used_bits, used_bits2;
1355     int       bits;
1356     int       min_bits[2][2], max_bits[2][2];
1357     int       analog_mean_bits, min_mean_bits;
1358     int       mean_bits;
1359     int       ch, gr, analog_silence;
1360     gr_info             *cod_info;
1361     III_side_info_t     *l3_side  = &gfc->l3_side;
1362
1363     analog_silence = VBR_prepare (gfp, pe, ms_ener_ratio, xr, ratio,
1364                                   l3_xmin, frameBits, &analog_mean_bits,
1365                                   &min_mean_bits, min_bits, max_bits, bands);
1366
1367     /*---------------------------------*/
1368     for(;;) {
1369
1370     /*  quantize granules with lowest possible number of bits
1371      */
1372
1373     used_bits = 0;
1374     used_bits2 = 0;
1375
1376     for (gr = 0; gr < gfc->mode_gr; gr++) {
1377         for (ch = 0; ch < gfc->channels_out; ch++) {
1378             int ret;
1379             cod_info = &l3_side->gr[gr].ch[ch].tt;
1380
1381             /*  init_outer_loop sets up cod_info, scalefac and xrpow
1382              */
1383             ret = init_outer_loop(gfc, cod_info, &scalefac[gr][ch],
1384                                   xr[gr][ch], xrpow);
1385             if (ret == 0 || max_bits[gr][ch] == 0) {
1386                 /*  xr contains no energy
1387                  *  l3_enc, our encoding data, will be quantized to zero
1388                  */
1389                 memset(l3_enc[gr][ch], 0, sizeof(int)*576);
1390                 save_bits[gr][ch] = 0;
1391                 continue; /* with next channel */
1392             }
1393
1394             if (gfp->VBR == vbr_mtrh) {
1395                 ret = VBR_noise_shaping2 (gfp, xr[gr][ch], xrpow, l3_enc[gr][ch],
1396                                         min_bits[gr][ch], max_bits[gr][ch],
1397                                         &scalefac[gr][ch],
1398                                         &l3_xmin[gr][ch], gr, ch );
1399                 if (ret < 0)
1400                     cod_info->part2_3_length = 100000;
1401             }
1402             else
1403                 VBR_encode_granule (gfp, cod_info, xr[gr][ch], &l3_xmin[gr][ch],
1404                                     &scalefac[gr][ch], xrpow, l3_enc[gr][ch],
1405                                     ch, min_bits[gr][ch], max_bits[gr][ch] );
1406
1407             used_bits += cod_info->part2_3_length;
1408             save_bits[gr][ch] = Min(MAX_BITS, cod_info->part2_3_length);
1409             used_bits2 += Min(MAX_BITS, cod_info->part2_3_length);
1410         } /* for ch */
1411     }    /* for gr */
1412
1413     /*  find lowest bitrate able to hold used bits
1414      */
1415     if (analog_silence && !gfp->VBR_hard_min)
1416         /*  we detected analog silence and the user did not specify
1417          *  any hard framesize limit, so start with smallest possible frame
1418          */
1419         gfc->bitrate_index = 1;
1420     else
1421         gfc->bitrate_index = gfc->VBR_min_bitrate;
1422
1423     for( ; gfc->bitrate_index < gfc->VBR_max_bitrate; gfc->bitrate_index++) {
1424         if (used_bits <= frameBits[gfc->bitrate_index]) break;
1425     }
1426
1427     getframebits (gfp, &bitsPerFrame, &mean_bits);
1428     bits = ResvFrameBegin (gfp, l3_side, mean_bits, bitsPerFrame);
1429
1430     if (used_bits <= bits) break;
1431
1432     switch ( gfc -> VBR -> bitpressure ) {
1433     default:
1434     case  1:    bitpressure_strategy1( gfc, l3_xmin, min_bits, max_bits );
1435                 break;
1436     case  2:    bitpressure_strategy2( gfc, frameBits[gfc->bitrate_index],
1437                                used_bits2, save_bits, min_bits, max_bits );
1438                 break;
1439     }
1440
1441     }   /* breaks adjusted */
1442     /*--------------------------------------*/
1443
1444     iteration_finish (gfc, xr, l3_enc, scalefac, mean_bits);
1445 }
1446
1447
1448
1449
1450
1451
1452 /********************************************************************
1453  *
1454  *  calc_target_bits()
1455  *
1456  *  calculates target bits for ABR encoding
1457  *
1458  *  mt 2000/05/31
1459  *
1460  ********************************************************************/
1461
1462 static void
1463 calc_target_bits (
1464     lame_global_flags * gfp,
1465     FLOAT8               pe            [2][2],
1466     FLOAT8               ms_ener_ratio [2],
1467     int                  targ_bits     [2][2],
1468     int                 *analog_silence_bits,
1469     int                 *max_frame_bits )
1470 {
1471     lame_internal_flags *gfc=gfp->internal_flags;
1472     III_side_info_t *l3_side = &gfc->l3_side;
1473     FLOAT8 res_factor;
1474     int gr, ch, totbits, mean_bits, bitsPerFrame;
1475
1476     gfc->bitrate_index = gfc->VBR_max_bitrate;
1477     getframebits (gfp, &bitsPerFrame, &mean_bits);
1478     *max_frame_bits = ResvFrameBegin (gfp, l3_side, mean_bits, bitsPerFrame);
1479
1480     gfc->bitrate_index = 1;
1481     getframebits (gfp, &bitsPerFrame, &mean_bits);
1482     *analog_silence_bits = mean_bits / gfc->channels_out;
1483
1484     mean_bits  = gfp->VBR_mean_bitrate_kbps * gfp->framesize * 1000;
1485     mean_bits /= gfp->out_samplerate;
1486     mean_bits -= gfc->sideinfo_len*8;
1487     mean_bits /= gfc->mode_gr;
1488
1489     /*
1490         res_factor is the percentage of the target bitrate that should
1491         be used on average.  the remaining bits are added to the
1492         bitreservoir and used for difficult to encode frames.
1493
1494         Since we are tracking the average bitrate, we should adjust
1495         res_factor "on the fly", increasing it if the average bitrate
1496         is greater than the requested bitrate, and decreasing it
1497         otherwise.  Reasonable ranges are from .9 to 1.0
1498
1499         Until we get the above suggestion working, we use the following
1500         tuning:
1501         compression ratio    res_factor
1502           5.5  (256kbps)         1.0      no need for bitreservoir
1503           11   (128kbps)         .93      7% held for reservoir
1504
1505         with linear interpolation for other values.
1506
1507      */
1508     res_factor = .93 + .07 * (11.0 - gfp->compression_ratio) / (11.0 - 5.5);
1509     if (res_factor <  .90)
1510         res_factor =  .90;
1511     if (res_factor > 1.00)
1512         res_factor = 1.00;
1513
1514     for (gr = 0; gr < gfc->mode_gr; gr++) {
1515         for (ch = 0; ch < gfc->channels_out; ch++) {
1516             targ_bits[gr][ch] = res_factor * (mean_bits / gfc->channels_out);
1517
1518             if (pe[gr][ch] > 700) {
1519                 int add_bits = (pe[gr][ch] - 700) / 1.4;
1520
1521                 gr_info *cod_info = &l3_side->gr[gr].ch[ch].tt;
1522                 targ_bits[gr][ch] = res_factor * (mean_bits / gfc->channels_out);
1523
1524                 /* short blocks use a little extra, no matter what the pe */
1525                 if (cod_info->block_type == SHORT_TYPE) {
1526                     if (add_bits < mean_bits/4)
1527                         add_bits = mean_bits/4;
1528                 }
1529                 /* at most increase bits by 1.5*average */
1530                 if (add_bits > mean_bits*3/4)
1531                     add_bits = mean_bits*3/4;
1532                 else
1533                 if (add_bits < 0)
1534                     add_bits = 0;
1535
1536                 targ_bits[gr][ch] += add_bits;
1537             }
1538         }/* for ch */
1539     }   /* for gr */
1540
1541     if (gfc->mode_ext == MPG_MD_MS_LR)
1542         for (gr = 0; gr < gfc->mode_gr; gr++) {
1543             reduce_side (targ_bits[gr], ms_ener_ratio[gr], mean_bits,
1544                          MAX_BITS);
1545         }
1546
1547     /*  sum target bits
1548      */
1549     totbits=0;
1550     for (gr = 0; gr < gfc->mode_gr; gr++) {
1551         for (ch = 0; ch < gfc->channels_out; ch++) {
1552             if (targ_bits[gr][ch] > MAX_BITS)
1553                 targ_bits[gr][ch] = MAX_BITS;
1554             totbits += targ_bits[gr][ch];
1555         }
1556     }
1557
1558     /*  repartion target bits if needed
1559      */
1560     if (totbits > *max_frame_bits) {
1561         for(gr = 0; gr < gfc->mode_gr; gr++) {
1562             for(ch = 0; ch < gfc->channels_out; ch++) {
1563                 targ_bits[gr][ch] *= *max_frame_bits;
1564                 targ_bits[gr][ch] /= totbits;
1565             }
1566         }
1567     }
1568 }
1569
1570
1571
1572
1573
1574
1575 /********************************************************************
1576  *
1577  *  ABR_iteration_loop()
1578  *
1579  *  encode a frame with a disired average bitrate
1580  *
1581  *  mt 2000/05/31
1582  *
1583  ********************************************************************/
1584
1585 void
1586 ABR_iteration_loop(
1587     lame_global_flags *gfp,
1588     FLOAT8             pe           [2][2],
1589     FLOAT8             ms_ener_ratio[2],
1590     FLOAT8             xr           [2][2][576],
1591     III_psy_ratio      ratio        [2][2],
1592     int                l3_enc       [2][2][576],
1593     III_scalefac_t     scalefac     [2][2] )
1594 {
1595     lame_internal_flags *gfc=gfp->internal_flags;
1596     III_psy_xmin l3_xmin;
1597     FLOAT8    xrpow[576];
1598     int       targ_bits[2][2];
1599     int       bitsPerFrame, mean_bits, totbits, max_frame_bits;
1600     int       ch, gr, ath_over, ret;
1601     int       analog_silence_bits;
1602     gr_info             *cod_info;
1603     III_side_info_t     *l3_side  = &gfc->l3_side;
1604
1605     calc_target_bits (gfp, pe, ms_ener_ratio, targ_bits,
1606                       &analog_silence_bits, &max_frame_bits);
1607
1608     /*  encode granules
1609      */
1610     totbits=0;
1611     for (gr = 0; gr < gfc->mode_gr; gr++) {
1612
1613         if (gfc->mode_ext == MPG_MD_MS_LR)
1614             ms_convert (xr[gr], xr[gr]);
1615
1616         for (ch = 0; ch < gfc->channels_out; ch++) {
1617             cod_info = &l3_side->gr[gr].ch[ch].tt;
1618
1619             /*  cod_info, scalefac and xrpow get initialized in init_outer_loop
1620              */
1621             ret = init_outer_loop(gfc, cod_info, &scalefac[gr][ch],
1622                                   xr[gr][ch], xrpow);
1623             if (ret == 0) {
1624                 /*  xr contains no energy
1625                  *  l3_enc, our encoding data, will be quantized to zero
1626                  */
1627                 memset(l3_enc[gr][ch], 0, sizeof(int)*576);
1628             }
1629             else {
1630                 /*  xr contains energy we will have to encode
1631                  *  calculate the masking abilities
1632                  *  find some good quantization in outer_loop
1633                  */
1634                 ath_over = calc_xmin (gfp, xr[gr][ch], &ratio[gr][ch],
1635                                       cod_info, &l3_xmin);
1636                 if (0 == ath_over) /* analog silence */
1637                     targ_bits[gr][ch] = analog_silence_bits;
1638
1639                 outer_loop (gfp, cod_info, xr[gr][ch], &l3_xmin,
1640                             &scalefac[gr][ch], xrpow, l3_enc[gr][ch],
1641                             ch, targ_bits[gr][ch]);
1642             }
1643
1644             totbits += cod_info->part2_3_length;
1645         } /* ch */
1646     }  /* gr */
1647
1648     /*  find a bitrate which can handle totbits
1649      */
1650     for (gfc->bitrate_index =  gfc->VBR_min_bitrate ;
1651          gfc->bitrate_index <= gfc->VBR_max_bitrate;
1652          gfc->bitrate_index++    ) {
1653         getframebits (gfp, &bitsPerFrame, &mean_bits);
1654         max_frame_bits = ResvFrameBegin (gfp, l3_side, mean_bits, bitsPerFrame);
1655         if (totbits <= max_frame_bits) break;
1656     }
1657     assert (gfc->bitrate_index <= gfc->VBR_max_bitrate);
1658
1659     iteration_finish (gfc, xr, l3_enc, scalefac, mean_bits);
1660 }
1661
1662
1663
1664
1665
1666
1667 /************************************************************************
1668  *
1669  *      iteration_loop()
1670  *
1671  *  author/date??
1672  *
1673  *  encodes one frame of MP3 data with constant bitrate
1674  *
1675  ************************************************************************/
1676
1677 void
1678 iteration_loop(
1679     lame_global_flags *gfp,
1680     FLOAT8             pe           [2][2],
1681     FLOAT8             ms_ener_ratio[2],
1682     FLOAT8             xr           [2][2][576],
1683     III_psy_ratio      ratio        [2][2],
1684     int                l3_enc       [2][2][576],
1685     III_scalefac_t     scalefac     [2][2] )
1686 {
1687     lame_internal_flags *gfc=gfp->internal_flags;
1688     III_psy_xmin l3_xmin[2];
1689     FLOAT8 xrpow[576];
1690     int    targ_bits[2];
1691     int    bitsPerFrame;
1692     int    mean_bits, max_bits;
1693     int    gr, ch, i;
1694     III_side_info_t     *l3_side = &gfc->l3_side;
1695     gr_info             *cod_info;
1696
1697     getframebits (gfp, &bitsPerFrame, &mean_bits);
1698     ResvFrameBegin (gfp, l3_side, mean_bits, bitsPerFrame );
1699
1700     /* quantize! */
1701     for (gr = 0; gr < gfc->mode_gr; gr++) {
1702
1703         /*  calculate needed bits
1704          */
1705         max_bits = on_pe (gfp, pe, l3_side, targ_bits, mean_bits, gr);
1706
1707         if (gfc->mode_ext == MPG_MD_MS_LR) {
1708             ms_convert (xr[gr], xr[gr]);
1709             reduce_side (targ_bits, ms_ener_ratio[gr], mean_bits, max_bits);
1710         }
1711
1712         for (ch=0 ; ch < gfc->channels_out ; ch ++) {
1713             cod_info = &l3_side->gr[gr].ch[ch].tt;
1714
1715             /*  init_outer_loop sets up cod_info, scalefac and xrpow
1716              */
1717             i = init_outer_loop(gfc, cod_info, &scalefac[gr][ch],
1718                                 xr[gr][ch], xrpow);
1719             if (i == 0) {
1720                 /*  xr contains no energy, l3_enc will be quantized to zero
1721                  */
1722                 memset(l3_enc[gr][ch], 0, sizeof(int)*576);
1723             }
1724             else {
1725                 /*  xr contains energy we will have to encode
1726                  *  calculate the masking abilities
1727                  *  find some good quantization in outer_loop
1728                  */
1729                 calc_xmin (gfp, xr[gr][ch], &ratio[gr][ch], cod_info,
1730                            &l3_xmin[ch]);
1731                 outer_loop (gfp, cod_info, xr[gr][ch], &l3_xmin[ch],
1732                             &scalefac[gr][ch], xrpow, l3_enc[gr][ch],
1733                             ch, targ_bits[ch]);
1734             }
1735             assert (cod_info->part2_3_length <= MAX_BITS);
1736
1737             /*  try some better scalefac storage
1738              */
1739             best_scalefac_store (gfc, gr, ch, l3_enc, l3_side, scalefac);
1740
1741             /*  best huffman_divide may save some bits too
1742              */
1743             if (gfc->use_best_huffman == 1)
1744                 best_huffman_divide (gfc, cod_info, l3_enc[gr][ch]);
1745
1746             /*  update reservoir status after FINAL quantization/bitrate
1747              */
1748 #undef  NORES_TEST
1749 #ifndef NORES_TEST
1750             ResvAdjust (gfc, cod_info, l3_side, mean_bits);
1751 #endif
1752             /*  set the sign of l3_enc from the sign of xr
1753              */
1754             for (i = 0; i < 576; i++) {
1755                 if (xr[gr][ch][i] < 0) l3_enc[gr][ch][i] *= -1;
1756             }
1757         } /* for ch */
1758     }    /* for gr */
1759
1760 #ifdef NORES_TEST
1761     /* replace ResvAdjust above with this code if you do not want
1762        the second granule to use bits saved by the first granule.
1763        Requires using the --nores.  This is useful for testing only */
1764     for (gr = 0; gr < gfc->mode_gr; gr++) {
1765         for (ch =  0; ch < gfc->channels_out; ch++) {
1766             cod_info = &l3_side->gr[gr].ch[ch].tt;
1767             ResvAdjust (gfc, cod_info, l3_side, mean_bits);
1768         }
1769     }
1770 #endif
1771
1772     ResvFrameEnd (gfc, l3_side, mean_bits);
1773 }
1774
1775
1776