lib/lame/set_get.c

   1 /* -*- mode: C; mode: fold -*- */
   2 /*
   3  * set/get functions for lame_global_flags
   4  *
   5  * Copyright (c) 2001 Alexander Leidinger
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /* $Id: set_get.c,v 1.1 2002/04/28 17:30:28 kramm Exp $ */
  24
  25 #include "config_static.h"
  26
  27 #include <assert.h>
  28 #include "util.h"
  29 #include "bitstream.h"  /* because of compute_flushbits */
  30
  31 #ifdef WITH_DMALLOC
  32 #include <dmalloc.h>
  33 #endif
  34
  35
  36 /*
  37  * input stream description
  38  */
  39
  40 /* number of samples */
  41 /* it's unlikely for this function to return an error */
  42 int
  43 lame_set_num_samples( lame_global_flags*  gfp,
  44                       unsigned long       num_samples)
  45 {
  46     /* default = 2^32-1 */
  47
  48     gfp->num_samples = num_samples;
  49
  50     return 0;
  51 }
  52
  53 unsigned long
  54 lame_get_num_samples( const lame_global_flags* gfp )
  55 {
  56     return gfp->num_samples;
  57 }
  58
  59
  60 /* input samplerate */
  61 int
  62 lame_set_in_samplerate( lame_global_flags*  gfp,
  63                         int                 in_samplerate )
  64 {
  65     /* input sample rate in Hz,  default = 44100 Hz */
  66     gfp->in_samplerate = in_samplerate;
  67
  68     return 0;
  69 }
  70
  71 int
  72 lame_get_in_samplerate( const lame_global_flags*  gfp )
  73 {
  74     return gfp->in_samplerate;
  75 }
  76
  77
  78 /* number of channels in input stream */
  79 int
  80 lame_set_num_channels( lame_global_flags*  gfp,
  81                        int                 num_channels )
  82 {
  83     /* default = 2 */
  84
  85     if ( 2 < num_channels || 0 == num_channels )
  86         return -1;    /* we don't support more than 2 channels */
  87
  88     gfp->num_channels = num_channels;
  89
  90     return 0;
  91 }
  92
  93 int
  94 lame_get_num_channels( const lame_global_flags*  gfp )
  95 {
  96     return gfp->num_channels;
  97 }
  98
  99
 100 /* scale the input by this amount before encoding (not used for decoding) */
 101 int
 102 lame_set_scale( lame_global_flags*  gfp,
 103                 float               scale )
 104 {
 105     /* default = 0 */
 106     gfp->scale = scale;
 107
 108     return 0;
 109 }
 110
 111 float
 112 lame_get_scale( const lame_global_flags*  gfp )
 113 {
 114     return gfp->scale;
 115 }
 116
 117
 118 /* scale the channel 0 (left) input by this amount before
 119    encoding (not used for decoding) */
 120 int
 121 lame_set_scale_left( lame_global_flags*  gfp,
 122                      float               scale )
 123 {
 124     /* default = 0 */
 125     gfp->scale_left = scale;
 126
 127     return 0;
 128 }
 129
 130 float
 131 lame_get_scale_left( const lame_global_flags*  gfp )
 132 {
 133     return gfp->scale_left;
 134 }
 135
 136
 137 /* scale the channel 1 (right) input by this amount before
 138    encoding (not used for decoding) */
 139 int
 140 lame_set_scale_right( lame_global_flags*  gfp,
 141                       float               scale )
 142 {
 143     /* default = 0 */
 144     gfp->scale_right = scale;
 145
 146     return 0;
 147 }
 148
 149 float
 150 lame_get_scale_right( const lame_global_flags*  gfp )
 151 {
 152     return gfp->scale_right;
 153 }
 154
 155
 156 /* output sample rate in Hz */
 157 int
 158 lame_set_out_samplerate( lame_global_flags*  gfp,
 159                          int                 out_samplerate )
 160 {
 161     /*
 162      * default = 0: LAME picks best value based on the amount
 163      *              of compression
 164      * MPEG only allows:
 165      *  MPEG1    32, 44.1,   48khz
 166      *  MPEG2    16, 22.05,  24
 167      *  MPEG2.5   8, 11.025, 12
 168      *
 169      * (not used by decoding routines)
 170      */
 171     gfp->out_samplerate = out_samplerate;
 172
 173     return 0;
 174 }
 175
 176 int
 177 lame_get_out_samplerate( const lame_global_flags*  gfp )
 178 {
 179     return gfp->out_samplerate;
 180 }
 181
 182
 183
 184
 185 /*
 186  * general control parameters
 187  */
 188
 189 /* collect data for an MP3 frame analzyer */
 190 int
 191 lame_set_analysis( lame_global_flags*  gfp,
 192                    int                 analysis )
 193 {
 194     /* default = 0 */
 195
 196     /* enforce disable/enable meaning, if we need more than two values
 197        we need to switch to an enum to have an apropriate representation
 198        of the possible meanings of the value */
 199     if ( 0 > analysis || 1 < analysis )
 200         return -1;
 201
 202     gfp->analysis = analysis;
 203
 204     return 0;
 205 }
 206
 207 int
 208 lame_get_analysis( const lame_global_flags*  gfp )
 209 {
 210     assert( 0 <= gfp->analysis && 1 >= gfp->analysis );
 211
 212     return gfp->analysis;
 213 }
 214
 215
 216 /* write a Xing VBR header frame */
 217 int
 218 lame_set_bWriteVbrTag( lame_global_flags*  gfp,
 219                        int bWriteVbrTag )
 220 {
 221     /* default = 1 (on) for VBR/ABR modes, 0 (off) for CBR mode */
 222
 223     /* enforce disable/enable meaning, if we need more than two values
 224        we need to switch to an enum to have an apropriate representation
 225        of the possible meanings of the value */
 226     if ( 0 > bWriteVbrTag || 1 < bWriteVbrTag )
 227         return -1;
 228
 229     gfp->bWriteVbrTag = bWriteVbrTag;
 230
 231     return 0;
 232 }
 233
 234 int
 235 lame_get_bWriteVbrTag( const lame_global_flags*  gfp )
 236 {
 237     assert( 0 <= gfp->bWriteVbrTag && 1 >= gfp->bWriteVbrTag );
 238
 239     return gfp->bWriteVbrTag;
 240 }
 241
 242
 243
 244 /* decode only, use lame/mpglib to convert mp3/ogg to wav */
 245 int
 246 lame_set_decode_only( lame_global_flags*  gfp,
 247                       int                 decode_only )
 248 {
 249     /* default = 0 (disabled) */
 250
 251     /* enforce disable/enable meaning, if we need more than two values
 252        we need to switch to an enum to have an apropriate representation
 253        of the possible meanings of the value */
 254     if ( 0 > decode_only || 1 < decode_only )
 255         return -1;
 256
 257     gfp->decode_only = decode_only;
 258
 259     return 0;
 260 }
 261
 262 int
 263 lame_get_decode_only( const lame_global_flags*  gfp )
 264 {
 265     assert( 0 <= gfp->decode_only && 1 >= gfp->decode_only );
 266
 267     return gfp->decode_only;
 268 }
 269
 270
 271 /* encode a Vorbis .ogg file */
 272 int
 273 lame_set_ogg( lame_global_flags*  gfp,
 274               int                 ogg )
 275 {
 276     /* default = 0 (disabled) */
 277
 278     /* enforce disable/enable meaning, if we need more than two values
 279        we need to switch to an enum to have an apropriate representation
 280        of the possible meanings of the value */
 281     if ( 0 > ogg || 1 < ogg )
 282         return -1;
 283
 284     gfp->ogg = ogg;
 285
 286     return 0;
 287 }
 288
 289 int
 290 lame_get_ogg( const lame_global_flags*  gfp )
 291 {
 292     assert( 0 <= gfp->ogg && 1 >= gfp->ogg );
 293
 294     return gfp->ogg;
 295 }
 296
 297
 298 /*
 299  * Internal algorithm selection.
 300  * True quality is determined by the bitrate but this variable will effect
 301  * quality by selecting expensive or cheap algorithms.
 302  * quality=0..9.  0=best (very slow).  9=worst.
 303  * recommended:  2     near-best quality, not too slow
 304  *               5     good quality, fast
 305  *               7     ok quality, really fast
 306  */
 307 int
 308 lame_set_quality( lame_global_flags*  gfp,
 309                   int                 quality )
 310 {
 311     gfp->quality = quality;
 312
 313     return 0;
 314 }
 315
 316 int
 317 lame_get_quality( const lame_global_flags*  gfp )
 318 {
 319     return gfp->quality;
 320 }
 321
 322
 323 /* mode = STEREO, JOINT_STEREO, DUAL_CHANNEL (not supported), MONO */
 324 int
 325 lame_set_mode( lame_global_flags*  gfp,
 326                MPEG_mode           mode )
 327 {
 328     /* default: lame chooses based on compression ratio and input channels */
 329
 330     if( 0 > mode || MAX_INDICATOR <= mode )
 331         return -1;  /* Unknown MPEG mode! */
 332
 333     gfp->mode = mode;
 334
 335     return 0;
 336 }
 337
 338 MPEG_mode
 339 lame_get_mode( const lame_global_flags*  gfp )
 340 {
 341     assert( 0 <= gfp->mode && MAX_INDICATOR > gfp->mode );
 342
 343     return gfp->mode;
 344 }
 345
 346
 347 /* Us a M/S mode with a switching threshold based on compression ratio */
 348 int
 349 lame_set_mode_automs( lame_global_flags*  gfp,
 350                       int                 mode_automs )
 351 {
 352     /* default = 0 (disabled) */
 353
 354     /* enforce disable/enable meaning, if we need more than two values
 355        we need to switch to an enum to have an apropriate representation
 356        of the possible meanings of the value */
 357     if ( 0 > mode_automs || 1 < mode_automs )
 358         return -1;
 359
 360     gfp->mode_automs = mode_automs;
 361
 362     return 0;
 363 }
 364
 365 int
 366 lame_get_mode_automs( const lame_global_flags*  gfp )
 367 {
 368     assert( 0 <= gfp->mode_automs && 1 >= gfp->mode_automs );
 369
 370     return gfp->mode_automs;
 371 }
 372
 373
 374 /*
 375  * Force M/S for all frames.  For testing only.
 376  * Requires mode = 1.
 377  */
 378 int
 379 lame_set_force_ms( lame_global_flags*  gfp,
 380                    int                 force_ms )
 381 {
 382     /* default = 0 (disabled) */
 383
 384     /* enforce disable/enable meaning, if we need more than two values
 385        we need to switch to an enum to have an apropriate representation
 386        of the possible meanings of the value */
 387     if ( 0 > force_ms || 1 < force_ms )
 388         return -1;
 389
 390     gfp->force_ms = force_ms;
 391
 392     return 0;
 393 }
 394
 395 int
 396 lame_get_force_ms( const lame_global_flags*  gfp )
 397 {
 398     assert( 0 <= gfp->force_ms && 1 >= gfp->force_ms );
 399
 400     return gfp->force_ms;
 401 }
 402
 403
 404 /* Use free_format. */
 405 int
 406 lame_set_free_format( lame_global_flags*  gfp,
 407                       int                 free_format )
 408 {
 409     /* default = 0 (disabled) */
 410
 411     /* enforce disable/enable meaning, if we need more than two values
 412        we need to switch to an enum to have an apropriate representation
 413        of the possible meanings of the value */
 414     if ( 0 > free_format || 1 < free_format )
 415         return -1;
 416
 417     gfp->free_format = free_format;
 418
 419     return 0;
 420 }
 421
 422 int
 423 lame_get_free_format( const lame_global_flags*  gfp )
 424 {
 425     assert( 0 <= gfp->free_format && 1 >= gfp->free_format );
 426
 427     return gfp->free_format;
 428 }
 429
 430
 431 /* message handlers */
 432 int
 433 lame_set_errorf( lame_global_flags*  gfp,
 434                  void                (*func)( const char*, va_list ) )
 435 {
 436     gfp->report.errorf = func;
 437
 438     return 0;
 439 }
 440
 441 int
 442 lame_set_debugf( lame_global_flags*  gfp,
 443                  void                (*func)( const char*, va_list ) )
 444 {
 445     gfp->report.debugf = func;
 446
 447     return 0;
 448 }
 449
 450 int
 451 lame_set_msgf( lame_global_flags*  gfp,
 452                void                (*func)( const char *, va_list ) )
 453 {
 454     gfp->report.msgf = func;
 455
 456     return 0;
 457 }
 458
 459
 460 /*
 461  * Set one of
 462  *  - brate
 463  *  - compression ratio.
 464  *
 465  * Default is compression ratio of 11.
 466  */
 467 int
 468 lame_set_brate( lame_global_flags*  gfp,
 469                 int                 brate )
 470 {
 471     gfp->brate = brate;
 472
 473     return 0;
 474 }
 475
 476 int
 477 lame_get_brate( const lame_global_flags*  gfp )
 478 {
 479     return gfp->brate;
 480 }
 481
 482 int
 483 lame_set_compression_ratio( lame_global_flags*  gfp,
 484                             float               compression_ratio )
 485 {
 486     gfp->compression_ratio = compression_ratio;
 487
 488     return 0;
 489 }
 490
 491 float
 492 lame_get_compression_ratio( const lame_global_flags*  gfp )
 493 {
 494     return gfp->compression_ratio;
 495 }
 496
 497
 498
 499
 500 /*
 501  * frame parameters
 502  */
 503
 504 /* Mark as copyright protected. */
 505 int
 506 lame_set_copyright( lame_global_flags*  gfp,
 507                     int                 copyright )
 508 {
 509     /* default = 0 (disabled) */
 510
 511     /* enforce disable/enable meaning, if we need more than two values
 512        we need to switch to an enum to have an apropriate representation
 513        of the possible meanings of the value */
 514     if ( 0 > copyright || 1 < copyright )
 515         return -1;
 516
 517     gfp->copyright = copyright;
 518
 519     return 0;
 520 }
 521
 522 int
 523 lame_get_copyright( const lame_global_flags*  gfp )
 524 {
 525     assert( 0 <= gfp->copyright && 1 >= gfp->copyright );
 526
 527     return gfp->copyright;
 528 }
 529
 530
 531 /* Mark as original. */
 532 int
 533 lame_set_original( lame_global_flags*  gfp,
 534                    int                 original )
 535 {
 536     /* default = 1 (enabled) */
 537
 538     /* enforce disable/enable meaning, if we need more than two values
 539        we need to switch to an enum to have an apropriate representation
 540        of the possible meanings of the value */
 541     if ( 0 > original || 1 < original )
 542         return -1;
 543
 544     gfp->original = original;
 545
 546     return 0;
 547 }
 548
 549 int
 550 lame_get_original( const lame_global_flags*  gfp )
 551 {
 552     assert( 0 <= gfp->original && 1 >= gfp->original );
 553
 554     return gfp->original;
 555 }
 556
 557
 558 /*
 559  * error_protection.
 560  * Use 2 bytes from each frame for CRC checksum.
 561  */
 562 int
 563 lame_set_error_protection( lame_global_flags*  gfp,
 564                            int                 error_protection )
 565 {
 566     /* default = 0 (disabled) */
 567
 568     /* enforce disable/enable meaning, if we need more than two values
 569        we need to switch to an enum to have an apropriate representation
 570        of the possible meanings of the value */
 571     if ( 0 > error_protection || 1 < error_protection )
 572         return -1;
 573
 574     gfp->error_protection = error_protection;
 575
 576     return 0;
 577 }
 578
 579 int
 580 lame_get_error_protection( const lame_global_flags*  gfp )
 581 {
 582     assert( 0 <= gfp->error_protection && 1 >= gfp->error_protection );
 583
 584     return gfp->error_protection;
 585 }
 586
 587
 588 /*
 589  * padding_type.
 590  *  PAD_NO     = pad no frames
 591  *  PAD_ALL    = pad all frames
 592  *  PAD_ADJUST = adjust padding
 593  */
 594 int
 595 lame_set_padding_type( lame_global_flags*  gfp,
 596                        Padding_type        padding_type )
 597 {
 598     /* default = 2 */
 599
 600     if ( 0 > padding_type || PAD_MAX_INDICATOR < padding_type )
 601         return -1;  /* Unknown padding type */
 602
 603     gfp->padding_type = padding_type;
 604
 605     return 0;
 606 }
 607
 608 Padding_type
 609 lame_get_padding_type( const lame_global_flags*  gfp )
 610 {
 611     assert( 0 <= gfp->padding_type && PAD_MAX_INDICATOR > gfp->padding_type );
 612
 613     return gfp->padding_type;
 614 }
 615
 616
 617 /* MP3 'private extension' bit. Meaningless. */
 618 int
 619 lame_set_extension( lame_global_flags*  gfp,
 620                     int                 extension )
 621 {
 622     /* default = 0 (disabled) */
 623
 624     /* enforce disable/enable meaning, if we need more than two values
 625        we need to switch to an enum to have an apropriate representation
 626        of the possible meanings of the value */
 627     if ( 0 > extension || 1 < extension )
 628         return -1;
 629
 630     gfp->extension = extension;
 631
 632     return 0;
 633 }
 634
 635 int
 636 lame_get_extension( const lame_global_flags*  gfp )
 637 {
 638     assert( 0 <= gfp->extension && 1 >= gfp->extension );
 639
 640     return gfp->extension;
 641 }
 642
 643
 644 /* Enforce strict ISO compliance. */
 645 int
 646 lame_set_strict_ISO( lame_global_flags*  gfp,
 647                      int                 strict_ISO )
 648 {
 649     /* default = 0 (disabled) */
 650
 651     /* enforce disable/enable meaning, if we need more than two values
 652        we need to switch to an enum to have an apropriate representation
 653        of the possible meanings of the value */
 654     if ( 0 > strict_ISO || 1 < strict_ISO )
 655         return -1;
 656
 657     gfp->strict_ISO = strict_ISO;
 658
 659     return 0;
 660 }
 661
 662 int
 663 lame_get_strict_ISO( const lame_global_flags*  gfp )
 664 {
 665     assert( 0 <= gfp->strict_ISO && 1 >= gfp->strict_ISO );
 666
 667     return gfp->strict_ISO;
 668 }
 669
 670
 671
 672
 673 /********************************************************************
 674  * quantization/noise shaping
 675  ***********************************************************************/
 676
 677 /* Disable the bit reservoir. For testing only. */
 678 int
 679 lame_set_disable_reservoir( lame_global_flags*  gfp,
 680                             int                 disable_reservoir )
 681 {
 682     /* default = 0 (disabled) */
 683
 684     /* enforce disable/enable meaning, if we need more than two values
 685        we need to switch to an enum to have an apropriate representation
 686        of the possible meanings of the value */
 687     if ( 0 > disable_reservoir || 1 < disable_reservoir )
 688         return -1;
 689
 690     gfp->disable_reservoir = disable_reservoir;
 691
 692     return 0;
 693 }
 694
 695 int
 696 lame_get_disable_reservoir( const lame_global_flags*  gfp )
 697 {
 698     assert( 0 <= gfp->disable_reservoir && 1 >= gfp->disable_reservoir );
 699
 700     return gfp->disable_reservoir;
 701 }
 702
 703
 704
 705
 706 /* Select a different "best quantization" function. default = 0 */
 707 int
 708 lame_set_experimentalX( lame_global_flags*  gfp,
 709                         int                 experimentalX )
 710 {
 711     gfp->experimentalX = experimentalX;
 712
 713     return 0;
 714 }
 715
 716 int
 717 lame_get_experimentalX( const lame_global_flags*  gfp )
 718 {
 719     return gfp->experimentalX;
 720 }
 721
 722
 723 /* Another experimental option. For testing only. */
 724 int
 725 lame_set_experimentalY( lame_global_flags*  gfp,
 726                         int                 experimentalY )
 727 {
 728     gfp->experimentalY = experimentalY;
 729
 730     return 0;
 731 }
 732
 733 int
 734 lame_get_experimentalY( const lame_global_flags*  gfp )
 735 {
 736     return gfp->experimentalY;
 737 }
 738
 739
 740 /* Another experimental option. For testing only. */
 741 int
 742 lame_set_experimentalZ( lame_global_flags*  gfp,
 743                         int                 experimentalZ )
 744 {
 745     gfp->experimentalZ += experimentalZ;
 746
 747     return 0;
 748 }
 749
 750 int
 751 lame_get_experimentalZ( const lame_global_flags*  gfp )
 752 {
 753     return gfp->experimentalZ;
 754 }
 755
 756
 757 /* Naoki's psycho acoustic model. */
 758 int
 759 lame_set_exp_nspsytune( lame_global_flags*  gfp,
 760                         int                 exp_nspsytune )
 761 {
 762     /* default = 0 (disabled) */
 763
 764     gfp->exp_nspsytune = exp_nspsytune;
 765
 766     return 0;
 767 }
 768
 769 int
 770 lame_get_exp_nspsytune( const lame_global_flags*  gfp )
 771 {
 772     return gfp->exp_nspsytune;
 773 }
 774
 775
 776
 777
 778 /********************************************************************
 779  * VBR control
 780  ***********************************************************************/
 781
 782 // Types of VBR.  default = vbr_off = CBR
 783 int
 784 lame_set_VBR( lame_global_flags*  gfp,
 785               vbr_mode            VBR )
 786 {
 787     if( 0 > VBR || vbr_max_indicator <= VBR )
 788         return -1;  /* Unknown VBR mode! */
 789
 790     gfp->VBR = VBR;
 791
 792     return 0;
 793 }
 794
 795 vbr_mode
 796 lame_get_VBR( const lame_global_flags*  gfp )
 797 {
 798     assert( 0 <= gfp->VBR && vbr_max_indicator > gfp->VBR );
 799
 800     return gfp->VBR;
 801 }
 802
 803
 804 /*
 805  * VBR quality level.
 806  *  0 = highest
 807  *  9 = lowest
 808  */
 809 int
 810 lame_set_VBR_q( lame_global_flags*  gfp,
 811                 int                 VBR_q )
 812 {
 813     /* XXX: This should be an enum */
 814     /*  to whoever added this note: why should it be an enum?
 815         do you want to call a specific setting by name?
 816         say VBR quality level red? */
 817     /* No, but VBR_Q_HIGHEST, VBR_Q_HIGH, ..., VBR_Q_MID, ...
 818        VBR_Q_LOW, VBR_Q_LOWEST (or something like that )and a
 819        VBR_Q_DEFAULT, which aliases the default setting of
 820        e.g. VBR_Q_MID. */
 821
 822
 823     if( 0 > VBR_q || 10 <= VBR_q )
 824         return -1;  /* Unknown VBR quality level! */
 825
 826     gfp->VBR_q = VBR_q;
 827
 828     return 0;
 829 }
 830
 831 int
 832 lame_get_VBR_q( const lame_global_flags*  gfp )
 833 {
 834     assert( 0 <= gfp->VBR_q && 10 > gfp->VBR_q );
 835
 836     return gfp->VBR_q;
 837 }
 838
 839
 840 /* Ignored except for VBR = vbr_abr (ABR mode) */
 841 int
 842 lame_set_VBR_mean_bitrate_kbps( lame_global_flags*  gfp,
 843                                 int                 VBR_mean_bitrate_kbps )
 844 {
 845     gfp->VBR_mean_bitrate_kbps = VBR_mean_bitrate_kbps;
 846
 847     return 0;
 848 }
 849
 850 int
 851 lame_get_VBR_mean_bitrate_kbps( const lame_global_flags*  gfp )
 852 {
 853     return gfp->VBR_mean_bitrate_kbps;
 854 }
 855
 856 int
 857 lame_set_VBR_min_bitrate_kbps( lame_global_flags*  gfp,
 858                                int                 VBR_min_bitrate_kbps )
 859 {
 860     gfp->VBR_min_bitrate_kbps = VBR_min_bitrate_kbps;
 861
 862     return 0;
 863 }
 864
 865 int
 866 lame_get_VBR_min_bitrate_kbps( const lame_global_flags*  gfp )
 867 {
 868     return gfp->VBR_min_bitrate_kbps;
 869 }
 870
 871 int
 872 lame_set_VBR_max_bitrate_kbps( lame_global_flags*  gfp,
 873                                int                 VBR_max_bitrate_kbps )
 874 {
 875     gfp->VBR_max_bitrate_kbps = VBR_max_bitrate_kbps;
 876
 877     return 0;
 878 }
 879
 880 int
 881 lame_get_VBR_max_bitrate_kbps( const lame_global_flags*  gfp )
 882 {
 883     return gfp->VBR_max_bitrate_kbps;
 884 }
 885
 886
 887 /*
 888  * Strictly enforce VBR_min_bitrate.
 889  * Normally it will be violated for analog silence.
 890  */
 891 int
 892 lame_set_VBR_hard_min( lame_global_flags*  gfp,
 893                        int                 VBR_hard_min )
 894 {
 895     /* default = 0 (disabled) */
 896
 897     /* enforce disable/enable meaning, if we need more than two values
 898        we need to switch to an enum to have an apropriate representation
 899        of the possible meanings of the value */
 900     if ( 0 > VBR_hard_min || 1 < VBR_hard_min )
 901         return -1;
 902
 903     gfp->VBR_hard_min = VBR_hard_min;
 904
 905     return 0;
 906 }
 907
 908 int
 909 lame_get_VBR_hard_min( const lame_global_flags*  gfp )
 910 {
 911     assert( 0 <= gfp->VBR_hard_min && 1 >= gfp->VBR_hard_min );
 912
 913     return gfp->VBR_hard_min;
 914 }
 915
 916
 917 /********************************************************************
 918  * Filtering control
 919  ***********************************************************************/
 920
 921 /*
 922  * Freqency in Hz to apply lowpass.
 923  *   0 = default = lame chooses
 924  *  -1 = disabled
 925  */
 926 int
 927 lame_set_lowpassfreq( lame_global_flags*  gfp,
 928                       int                 lowpassfreq )
 929 {
 930     gfp->lowpassfreq = lowpassfreq;
 931
 932     return 0;
 933 }
 934
 935 int
 936 lame_get_lowpassfreq( const lame_global_flags*  gfp )
 937 {
 938     return gfp->lowpassfreq;
 939 }
 940
 941
 942 /*
 943  * Width of transition band (in Hz).
 944  *  default = one polyphase filter band
 945  */
 946 int
 947 lame_set_lowpasswidth( lame_global_flags*  gfp,
 948                        int                 lowpasswidth )
 949 {
 950     gfp->lowpasswidth = lowpasswidth;
 951
 952     return 0;
 953 }
 954
 955 int
 956 lame_get_lowpasswidth( const lame_global_flags*  gfp )
 957 {
 958     return gfp->lowpasswidth;
 959 }
 960
 961
 962 /*
 963  * Frequency in Hz to apply highpass.
 964  *   0 = default = lame chooses
 965  *  -1 = disabled
 966  */
 967 int
 968 lame_set_highpassfreq( lame_global_flags*  gfp,
 969                        int                 highpassfreq )
 970 {
 971     gfp->highpassfreq = highpassfreq;
 972
 973     return 0;
 974 }
 975
 976 int
 977 lame_get_highpassfreq( const lame_global_flags*  gfp )
 978 {
 979     return gfp->highpassfreq;
 980 }
 981
 982
 983 /*
 984  * Width of transition band (in Hz).
 985  *  default = one polyphase filter band
 986  */
 987 int
 988 lame_set_highpasswidth( lame_global_flags*  gfp,
 989                         int                 highpasswidth )
 990 {
 991     gfp->highpasswidth = highpasswidth;
 992
 993     return 0;
 994 }
 995
 996 int
 997 lame_get_highpasswidth( const lame_global_flags*  gfp )
 998 {
 999     return gfp->highpasswidth;
1000 }
1001
1002
1003
1004
1005 /*
1006  * psycho acoustics and other arguments which you should not change
1007  * unless you know what you are doing
1008  */
1009
1010 /* Only use ATH for masking. */
1011 int
1012 lame_set_ATHonly( lame_global_flags*  gfp,
1013                   int                 ATHonly )
1014 {
1015     gfp->ATHonly = ATHonly;
1016
1017     return 0;
1018 }
1019
1020 int
1021 lame_get_ATHonly( const lame_global_flags*  gfp )
1022 {
1023     return gfp->ATHonly;
1024 }
1025
1026
1027 /* Only use ATH for short blocks. */
1028 int
1029 lame_set_ATHshort( lame_global_flags*  gfp,
1030                    int                 ATHshort )
1031 {
1032     gfp->ATHshort = ATHshort;
1033
1034     return 0;
1035 }
1036
1037 int
1038 lame_get_ATHshort( const lame_global_flags*  gfp )
1039 {
1040     return gfp->ATHshort;
1041 }
1042
1043
1044 /* Disable ATH. */
1045 int
1046 lame_set_noATH( lame_global_flags*  gfp,
1047                 int                 noATH )
1048 {
1049     gfp->noATH = noATH;
1050
1051     return 0;
1052 }
1053
1054 int
1055 lame_get_noATH( const lame_global_flags*  gfp )
1056 {
1057     return gfp->noATH;
1058 }
1059
1060
1061 /* Select ATH formula. */
1062 int
1063 lame_set_ATHtype( lame_global_flags*  gfp,
1064                   int                 ATHtype )
1065 {
1066     /* XXX: ATHtype should be converted to an enum. */
1067     gfp->ATHtype = ATHtype;
1068
1069     return 0;
1070 }
1071
1072 int
1073 lame_get_ATHtype( const lame_global_flags*  gfp )
1074 {
1075     return gfp->ATHtype;
1076 }
1077
1078
1079 /* Lower ATH by this many db. */
1080 int
1081 lame_set_ATHlower( lame_global_flags*  gfp,
1082                    float               ATHlower )
1083 {
1084     gfp->ATHlower = ATHlower;
1085     return 0;
1086 }
1087
1088 float
1089 lame_get_ATHlower( const lame_global_flags*  gfp )
1090 {
1091     return gfp->ATHlower;
1092 }
1093
1094
1095 /* Select ATH adaptive adjustment scheme. */
1096 int
1097 lame_set_athaa_type( lame_global_flags*  gfp,
1098                       int                athaa_type )
1099 {
1100     gfp->athaa_type = athaa_type;
1101
1102     return 0;
1103 }
1104
1105 int
1106 lame_get_athaa_type( const lame_global_flags*  gfp )
1107 {
1108     return gfp->athaa_type;
1109 }
1110
1111
1112 /* Select the loudness approximation used by the ATH adaptive auto-leveling. */
1113 int
1114 lame_set_athaa_loudapprox( lame_global_flags*  gfp,
1115                            int                 athaa_loudapprox )
1116 {
1117     gfp->athaa_loudapprox = athaa_loudapprox;
1118
1119     return 0;
1120 }
1121
1122 int
1123 lame_get_athaa_loudapprox( const lame_global_flags*  gfp )
1124 {
1125     return gfp->athaa_loudapprox;
1126 }
1127
1128
1129 /* Adjust (in dB) the point below which adaptive ATH level adjustment occurs. */
1130 int
1131 lame_set_athaa_sensitivity( lame_global_flags*  gfp,
1132                             float               athaa_sensitivity )
1133 {
1134     gfp->athaa_sensitivity = athaa_sensitivity;
1135
1136     return 0;
1137 }
1138
1139 float
1140 lame_get_athaa_sensitivity( const lame_global_flags*  gfp )
1141 {
1142     return gfp->athaa_sensitivity;
1143 }
1144
1145
1146 /* Predictability limit (ISO tonality formula) */
1147 int
1148 lame_set_cwlimit( lame_global_flags*  gfp,
1149                   int                 cwlimit )
1150 {
1151     gfp->cwlimit = cwlimit;
1152
1153     return 0;
1154 }
1155
1156 int
1157 lame_get_cwlimit( const lame_global_flags*  gfp )
1158 {
1159     return gfp->cwlimit;
1160 }
1161
1162
1163
1164 /*
1165  * Allow blocktypes to differ between channels.
1166  * default:
1167  *  0 for jstereo => block types coupled
1168  *  1 for stereo  => block types may differ
1169  */
1170 int
1171 lame_set_allow_diff_short( lame_global_flags*  gfp,
1172                            int                 allow_diff_short )
1173 {
1174     gfp->short_blocks =
1175         allow_diff_short ? short_block_allowed : short_block_coupled;
1176
1177     return 0;
1178 }
1179
1180 int
1181 lame_get_allow_diff_short( const lame_global_flags*  gfp )
1182 {
1183     if ( gfp->short_blocks == short_block_allowed )
1184         return 1; /* short blocks allowed to differ */
1185     else
1186         return 0; /* not set, dispensed, forced or coupled */
1187 }
1188
1189
1190 /* Use temporal masking effect */
1191 int
1192 lame_set_useTemporal( lame_global_flags*  gfp,
1193                       int                 useTemporal )
1194 {
1195     /* default = 1 (enabled) */
1196
1197     /* enforce disable/enable meaning, if we need more than two values
1198        we need to switch to an enum to have an apropriate representation
1199        of the possible meanings of the value */
1200     if ( 0 > useTemporal || 1 < useTemporal )
1201         return -1;
1202
1203     gfp->useTemporal = useTemporal;
1204
1205     return 0;
1206 }
1207
1208 int
1209 lame_get_useTemporal( const lame_global_flags*  gfp )
1210 {
1211     assert( 0 <= gfp->useTemporal && 1 >= gfp->useTemporal );
1212
1213     return gfp->useTemporal;
1214 }
1215
1216
1217 /* Disable short blocks. */
1218 int
1219 lame_set_no_short_blocks( lame_global_flags*  gfp,
1220                           int                 no_short_blocks )
1221 {
1222     /* enforce disable/enable meaning, if we need more than two values
1223        we need to switch to an enum to have an apropriate representation
1224        of the possible meanings of the value */
1225     if ( 0 > no_short_blocks || 1 < no_short_blocks )
1226         return -1;
1227
1228     gfp->short_blocks =
1229         no_short_blocks ? short_block_dispensed : short_block_allowed;
1230
1231     return 0;
1232 }
1233 int
1234 lame_get_no_short_blocks( const lame_global_flags*  gfp )
1235 {
1236     switch ( gfp->short_blocks ) {
1237     default:
1238     case short_block_not_set:   return -1;
1239     case short_block_dispensed: return 1;
1240     case short_block_allowed:
1241     case short_block_coupled:
1242     case short_block_forced:    return 0;
1243     }
1244 }
1245
1246
1247 /* Force short blocks. */
1248 int
1249 lame_set_force_short_blocks( lame_global_flags*  gfp,
1250                           int                 short_blocks )
1251 {
1252     /* enforce disable/enable meaning, if we need more than two values
1253        we need to switch to an enum to have an apropriate representation
1254        of the possible meanings of the value */
1255     if ( 0 > short_blocks || 1 < short_blocks )
1256         return -1;
1257
1258     if (short_blocks == 1)
1259         gfp->short_blocks = short_block_forced;
1260     else if (gfp->short_blocks == short_block_forced)
1261         gfp->short_blocks = short_block_allowed;
1262
1263     return 0;
1264 }
1265 int
1266 lame_get_force_short_blocks( const lame_global_flags*  gfp )
1267 {
1268     switch ( gfp->short_blocks ) {
1269     default:
1270     case short_block_not_set:   return -1;
1271     case short_block_dispensed:
1272     case short_block_allowed:
1273     case short_block_coupled:   return 0;
1274     case short_block_forced:    return 1;
1275     }
1276 }
1277
1278
1279 /*
1280  * Input PCM is emphased PCM
1281  * (for instance from one of the rarely emphased CDs).
1282  *
1283  * It is STRONGLY not recommended to use this, because psycho does not
1284  * take it into account, and last but not least many decoders
1285  * ignore these bits
1286  */
1287 int
1288 lame_set_emphasis( lame_global_flags*  gfp,
1289                    int                 emphasis )
1290 {
1291     /* XXX: emphasis should be converted to an enum */
1292     if ( 0 > emphasis || 4 <= emphasis )
1293         return -1;
1294
1295     gfp->emphasis = emphasis;
1296
1297     return 0;
1298 }
1299
1300 int
1301 lame_get_emphasis( const lame_global_flags*  gfp )
1302 {
1303     assert( 0 <= gfp->emphasis && 4 > gfp->emphasis );
1304
1305     return gfp->emphasis;
1306 }
1307
1308
1309
1310
1311 /***************************************************************/
1312 /* internal variables, cannot be set...                        */
1313 /* provided because they may be of use to calling application  */
1314 /***************************************************************/
1315
1316 /* MPEG version.
1317  *  0 = MPEG-2
1318  *  1 = MPEG-1
1319  * (2 = MPEG-2.5)
1320  */
1321 int
1322 lame_get_version( const lame_global_flags* gfp )
1323 {
1324     return gfp->version;
1325 }
1326
1327
1328 /* Encoder delay. */
1329 int
1330 lame_get_encoder_delay( const lame_global_flags*  gfp )
1331 {
1332     return gfp->encoder_delay;
1333 }
1334
1335 /* padding added to the end of the input */
1336 int
1337 lame_get_encoder_padding( const lame_global_flags*  gfp )
1338 {
1339     return gfp->encoder_padding;
1340 }
1341
1342
1343 /* Size of MPEG frame. */
1344 int
1345 lame_get_framesize( const lame_global_flags*  gfp )
1346 {
1347     return gfp->framesize;
1348 }
1349
1350
1351 /* Number of frames encoded so far. */
1352 int
1353 lame_get_frameNum( const lame_global_flags*  gfp )
1354 {
1355     return gfp->frameNum;
1356 }
1357
1358 int
1359 lame_get_mf_samples_to_encode( const lame_global_flags*  gfp )
1360 {
1361     lame_internal_flags *gfc = gfp->internal_flags;
1362     return gfc->mf_samples_to_encode;
1363 }
1364
1365
1366 int CDECL lame_get_size_mp3buffer( const lame_global_flags*  gfp )
1367 {
1368     int size;
1369     compute_flushbits(gfp,&size);
1370     return size;
1371 }
1372
1373
1374
1375 /*
1376  * LAME's estimate of the total number of frames to be encoded.
1377  * Only valid if calling program set num_samples.
1378  */
1379 int
1380 lame_get_totalframes( const lame_global_flags*  gfp )
1381 {
1382     int totalframes;
1383     /* estimate based on user set num_samples: */
1384     totalframes =
1385         2 + ((double)gfp->num_samples * gfp->out_samplerate) /
1386               ((double)gfp->in_samplerate * gfp->framesize);
1387
1388     /* check to see if we underestimated totalframes */
1389     //    if (totalframes < gfp->frameNum)
1390     //        totalframes = gfp->frameNum;
1391
1392     return totalframes;
1393 }
1394
1395
1396 /*
1397
1398 UNDOCUMENTED, experimental settings.  These routines are not prototyped
1399 in lame.h.  You should not use them, they are experimental and may
1400 change.
1401
1402 */
1403
1404
1405 /*
1406  *  just another daily changing developer switch
1407  */
1408 void lame_set_tune( lame_global_flags* gfp, float val )
1409 {
1410     gfp->tune_value_a = val;
1411     gfp->tune = 1;
1412 }
1413
1414 /* Custom msfix hack */
1415 void
1416 lame_set_msfix( lame_global_flags*  gfp, double msfix )
1417 {
1418     /* default = 0 */
1419     gfp->msfix = msfix;
1420
1421 }
1422
1423 int
1424 lame_set_preset_expopts( lame_global_flags*  gfp, int preset_expopts )
1425 {
1426
1427     lame_internal_flags *gfc = gfp->internal_flags;
1428
1429     gfc->presetTune.use = 1;
1430
1431     /* default = 0 (disabled) */
1432     gfp->preset_expopts = preset_expopts;
1433
1434     switch (preset_expopts)
1435     {
1436         case 1:
1437
1438           lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 1);
1439           lame_set_experimentalX(gfp, 3);
1440           lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 2); // safejoint
1441           lame_set_ATHtype(gfp, 2);
1442
1443           gfc->presetTune.attackthre   = 35;
1444           gfc->presetTune.attackthre_s = 150;
1445           gfc->presetTune.ms_maskadjust = .5;
1446                   gfc->presetTune.quantcomp_type_s = 3;
1447           gfc->presetTune.quantcomp_alt_type = 3;
1448           gfc->presetTune.athadjust_switch_level = 2; // Always switch
1449
1450           break;
1451
1452         case 2:
1453
1454           if (gfp->VBR == vbr_mtrh) {
1455              lame_set_experimentalX(gfp, 2);
1456              gfc->presetTune.quantcomp_adjust_mtrh = 9;
1457              gfc->presetTune.quantcomp_type_s = 4;
1458              gfc->presetTune.quantcomp_alt_type = 0;
1459              gfc->presetTune.athadjust_safe_noiseshaping_thre = 0.0;
1460                          gfc->presetTune.athadjust_safe_athaasensitivity = 8.0;
1461           }
1462           else {
1463              lame_set_experimentalX(gfp, 3);
1464              gfc->presetTune.quantcomp_adjust_rh_tot = 600;
1465                          gfc->presetTune.quantcomp_adjust_rh_max = 60;
1466              gfc->presetTune.quantcomp_type_s = 3;
1467              gfc->presetTune.quantcomp_alt_type = 1;
1468           }
1469
1470           lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 1);
1471           lame_set_experimentalZ(gfp, 1);
1472           lame_set_VBR_q(gfp, 2);
1473           lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 2); // safejoint
1474           lame_set_ATHtype(gfp, 2);
1475           // modify sfb21 by 3 dB plus ns-treble=0
1476           lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | (12 << 20));
1477
1478           gfc->presetTune.attackthre   = 35;
1479           gfc->presetTune.attackthre_s = 150;
1480           gfc->presetTune.ms_maskadjust = .5;
1481           gfc->presetTune.athadjust_switch_level = 1;
1482           gfc->presetTune.athadjust_msfix = 2.13;
1483
1484           break;
1485
1486         case 3:
1487
1488           if (gfp->VBR == vbr_mtrh) {
1489              gfc->presetTune.quantcomp_type_s = 4;
1490              gfc->presetTune.quantcomp_adjust_mtrh = 9;
1491                          gfc->presetTune.quantcomp_alt_type = 0;
1492              (void) lame_set_ATHlower( gfp, -2 );
1493              gfc->presetTune.athadjust_safe_noiseshaping_thre = 0.0;
1494                          gfc->presetTune.athadjust_safe_athaasensitivity = 8.0;
1495           }
1496           else {
1497              gfc->presetTune.quantcomp_type_s = 3;
1498              gfc->presetTune.quantcomp_adjust_rh_tot = 600;
1499                          gfc->presetTune.quantcomp_adjust_rh_max = 60;
1500              (void) lame_set_ATHlower( gfp, -1 );
1501           }
1502
1503           lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 1);
1504           lame_set_experimentalZ(gfp, 1);
1505           lame_set_experimentalX(gfp, 1);
1506           lame_set_VBR_q(gfp, 2);
1507           lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 2); // safejoint
1508    (void) lame_set_msfix( gfp, 2.13 );
1509           lame_set_ATHtype(gfp, 4);
1510           // modify sfb21 by 3.75 dB plus ns-treble=0
1511           lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | (15 << 20));
1512
1513           gfc->presetTune.attackthre   = 35;
1514           gfc->presetTune.attackthre_s = 150;
1515           gfc->presetTune.ms_maskadjust = .5;
1516           gfc->presetTune.athadjust_switch_level = 1;
1517
1518           break;
1519     }
1520     return 0;
1521 }
1522
1523 int
1524 lame_set_preset_notune( lame_global_flags*  gfp, int preset_notune )
1525 {
1526     lame_internal_flags *gfc = gfp->internal_flags;
1527
1528     gfc->presetTune.use = 0;  // Turn off specialized preset tunings
1529
1530     return 0;
1531 }
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550