X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Flame%2Fset_get.c;fp=lib%2Flame%2Fset_get.c;h=5c04ca3a81f0fd695ae9db0615f9dc526d1ab232;hb=698acf324aaa52147b1486646f6549ffd95804da;hp=0000000000000000000000000000000000000000;hpb=f8d07c79494e8536e682da73cee2057740a0e4db;p=swftools.git

diff --git a/lib/lame/set_get.c b/lib/lame/set_get.c
new file mode 100644
index 0000000..5c04ca3
--- /dev/null
+++ b/lib/lame/set_get.c
@@ -0,0 +1,1550 @@
+/* -*- mode: C; mode: fold -*- */
+/*
+ * set/get functions for lame_global_flags
+ *
+ * Copyright (c) 2001 Alexander Leidinger
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/* $Id: set_get.c,v 1.1 2002/04/28 17:30:28 kramm Exp $ */
+
+#include "config_static.h"
+
+#include <assert.h>
+#include "util.h"
+#include "bitstream.h"  /* because of compute_flushbits */
+
+#ifdef WITH_DMALLOC
+#include <dmalloc.h>
+#endif
+
+
+/*
+ * input stream description
+ */
+
+/* number of samples */
+/* it's unlikely for this function to return an error */
+int
+lame_set_num_samples( lame_global_flags*  gfp,
+                      unsigned long       num_samples)
+{
+    /* default = 2^32-1 */
+
+    gfp->num_samples = num_samples;
+
+    return 0;
+}
+
+unsigned long
+lame_get_num_samples( const lame_global_flags* gfp )
+{
+    return gfp->num_samples;
+}
+
+
+/* input samplerate */
+int
+lame_set_in_samplerate( lame_global_flags*  gfp,
+                        int                 in_samplerate )
+{
+    /* input sample rate in Hz,  default = 44100 Hz */
+    gfp->in_samplerate = in_samplerate;
+
+    return 0;
+}
+
+int
+lame_get_in_samplerate( const lame_global_flags*  gfp )
+{
+    return gfp->in_samplerate;
+}
+
+
+/* number of channels in input stream */
+int
+lame_set_num_channels( lame_global_flags*  gfp,
+                       int                 num_channels )
+{
+    /* default = 2 */
+
+    if ( 2 < num_channels || 0 == num_channels )
+        return -1;    /* we don't support more than 2 channels */
+
+    gfp->num_channels = num_channels;
+
+    return 0;
+}
+
+int
+lame_get_num_channels( const lame_global_flags*  gfp )
+{
+    return gfp->num_channels;
+}
+
+
+/* scale the input by this amount before encoding (not used for decoding) */
+int
+lame_set_scale( lame_global_flags*  gfp,
+                float               scale )
+{
+    /* default = 0 */
+    gfp->scale = scale;
+
+    return 0;
+}
+
+float
+lame_get_scale( const lame_global_flags*  gfp )
+{
+    return gfp->scale;
+}
+
+
+/* scale the channel 0 (left) input by this amount before 
+   encoding (not used for decoding) */
+int
+lame_set_scale_left( lame_global_flags*  gfp,
+                     float               scale )
+{
+    /* default = 0 */
+    gfp->scale_left = scale;
+
+    return 0;
+}
+
+float
+lame_get_scale_left( const lame_global_flags*  gfp )
+{
+    return gfp->scale_left;
+}
+
+
+/* scale the channel 1 (right) input by this amount before 
+   encoding (not used for decoding) */
+int
+lame_set_scale_right( lame_global_flags*  gfp,
+                      float               scale )
+{
+    /* default = 0 */
+    gfp->scale_right = scale;
+
+    return 0;
+}
+
+float
+lame_get_scale_right( const lame_global_flags*  gfp )
+{
+    return gfp->scale_right;
+}
+
+
+/* output sample rate in Hz */
+int
+lame_set_out_samplerate( lame_global_flags*  gfp,
+                         int                 out_samplerate )
+{
+    /*
+     * default = 0: LAME picks best value based on the amount
+     *              of compression
+     * MPEG only allows:
+     *  MPEG1    32, 44.1,   48khz
+     *  MPEG2    16, 22.05,  24
+     *  MPEG2.5   8, 11.025, 12
+     *
+     * (not used by decoding routines)
+     */
+    gfp->out_samplerate = out_samplerate;
+
+    return 0;
+}
+
+int
+lame_get_out_samplerate( const lame_global_flags*  gfp )
+{
+    return gfp->out_samplerate;
+}
+
+
+
+
+/*
+ * general control parameters
+ */
+
+/* collect data for an MP3 frame analzyer */
+int
+lame_set_analysis( lame_global_flags*  gfp,
+                   int                 analysis )
+{
+    /* default = 0 */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > analysis || 1 < analysis )
+        return -1;
+
+    gfp->analysis = analysis;
+
+    return 0;
+}
+
+int
+lame_get_analysis( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->analysis && 1 >= gfp->analysis );
+
+    return gfp->analysis;
+}
+
+
+/* write a Xing VBR header frame */
+int
+lame_set_bWriteVbrTag( lame_global_flags*  gfp,
+                       int bWriteVbrTag )
+{
+    /* default = 1 (on) for VBR/ABR modes, 0 (off) for CBR mode */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > bWriteVbrTag || 1 < bWriteVbrTag )
+        return -1;
+
+    gfp->bWriteVbrTag = bWriteVbrTag;
+
+    return 0;
+}
+
+int
+lame_get_bWriteVbrTag( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->bWriteVbrTag && 1 >= gfp->bWriteVbrTag );
+
+    return gfp->bWriteVbrTag;
+}
+
+
+
+/* decode only, use lame/mpglib to convert mp3/ogg to wav */
+int
+lame_set_decode_only( lame_global_flags*  gfp,
+                      int                 decode_only )
+{
+    /* default = 0 (disabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > decode_only || 1 < decode_only )
+        return -1;
+
+    gfp->decode_only = decode_only;
+
+    return 0;
+}
+
+int
+lame_get_decode_only( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->decode_only && 1 >= gfp->decode_only );
+
+    return gfp->decode_only;
+}
+
+
+/* encode a Vorbis .ogg file */
+int
+lame_set_ogg( lame_global_flags*  gfp,
+              int                 ogg )
+{
+    /* default = 0 (disabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > ogg || 1 < ogg )
+        return -1;
+
+    gfp->ogg = ogg;
+
+    return 0;
+}
+
+int
+lame_get_ogg( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->ogg && 1 >= gfp->ogg );
+
+    return gfp->ogg;
+}
+
+
+/*
+ * Internal algorithm selection.
+ * True quality is determined by the bitrate but this variable will effect
+ * quality by selecting expensive or cheap algorithms.
+ * quality=0..9.  0=best (very slow).  9=worst.  
+ * recommended:  2     near-best quality, not too slow
+ *               5     good quality, fast
+ *               7     ok quality, really fast
+ */
+int
+lame_set_quality( lame_global_flags*  gfp,
+                  int                 quality )
+{
+    gfp->quality = quality;
+
+    return 0;
+}
+
+int
+lame_get_quality( const lame_global_flags*  gfp )
+{
+    return gfp->quality;
+}
+
+
+/* mode = STEREO, JOINT_STEREO, DUAL_CHANNEL (not supported), MONO */
+int
+lame_set_mode( lame_global_flags*  gfp,
+               MPEG_mode           mode )
+{
+    /* default: lame chooses based on compression ratio and input channels */
+
+    if( 0 > mode || MAX_INDICATOR <= mode )
+        return -1;  /* Unknown MPEG mode! */
+
+    gfp->mode = mode;
+
+    return 0;
+}
+
+MPEG_mode
+lame_get_mode( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->mode && MAX_INDICATOR > gfp->mode );
+
+    return gfp->mode;
+}
+
+
+/* Us a M/S mode with a switching threshold based on compression ratio */
+int
+lame_set_mode_automs( lame_global_flags*  gfp,
+                      int                 mode_automs )
+{
+    /* default = 0 (disabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > mode_automs || 1 < mode_automs )
+        return -1;
+
+    gfp->mode_automs = mode_automs;
+
+    return 0;
+}
+
+int
+lame_get_mode_automs( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->mode_automs && 1 >= gfp->mode_automs );
+
+    return gfp->mode_automs;
+}
+
+
+/*
+ * Force M/S for all frames.  For testing only.
+ * Requires mode = 1.
+ */
+int
+lame_set_force_ms( lame_global_flags*  gfp,
+                   int                 force_ms )
+{
+    /* default = 0 (disabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > force_ms || 1 < force_ms )
+        return -1;
+
+    gfp->force_ms = force_ms;
+
+    return 0;
+}
+
+int
+lame_get_force_ms( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->force_ms && 1 >= gfp->force_ms );
+
+    return gfp->force_ms;
+}
+
+
+/* Use free_format. */
+int
+lame_set_free_format( lame_global_flags*  gfp,
+                      int                 free_format )
+{
+    /* default = 0 (disabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > free_format || 1 < free_format )
+        return -1;
+
+    gfp->free_format = free_format;
+
+    return 0;
+}
+
+int
+lame_get_free_format( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->free_format && 1 >= gfp->free_format );
+
+    return gfp->free_format;
+}
+
+
+/* message handlers */
+int
+lame_set_errorf( lame_global_flags*  gfp,
+                 void                (*func)( const char*, va_list ) )
+{
+    gfp->report.errorf = func;
+
+    return 0;
+}
+
+int
+lame_set_debugf( lame_global_flags*  gfp,
+                 void                (*func)( const char*, va_list ) )
+{
+    gfp->report.debugf = func;
+
+    return 0;
+}
+
+int
+lame_set_msgf( lame_global_flags*  gfp,
+               void                (*func)( const char *, va_list ) )
+{
+    gfp->report.msgf = func;
+
+    return 0;
+}
+
+
+/*
+ * Set one of
+ *  - brate
+ *  - compression ratio.
+ *
+ * Default is compression ratio of 11.
+ */
+int
+lame_set_brate( lame_global_flags*  gfp,
+                int                 brate )
+{
+    gfp->brate = brate;
+
+    return 0;
+}
+
+int
+lame_get_brate( const lame_global_flags*  gfp )
+{
+    return gfp->brate;
+}
+
+int
+lame_set_compression_ratio( lame_global_flags*  gfp,
+                            float               compression_ratio )
+{
+    gfp->compression_ratio = compression_ratio;
+
+    return 0;
+}
+
+float
+lame_get_compression_ratio( const lame_global_flags*  gfp )
+{
+    return gfp->compression_ratio;
+}
+
+
+
+
+/*
+ * frame parameters
+ */
+
+/* Mark as copyright protected. */
+int
+lame_set_copyright( lame_global_flags*  gfp,
+                    int                 copyright )
+{
+    /* default = 0 (disabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > copyright || 1 < copyright )
+        return -1;
+
+    gfp->copyright = copyright;
+
+    return 0;
+}
+
+int
+lame_get_copyright( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->copyright && 1 >= gfp->copyright );
+
+    return gfp->copyright;
+}
+
+
+/* Mark as original. */
+int
+lame_set_original( lame_global_flags*  gfp,
+                   int                 original )
+{
+    /* default = 1 (enabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > original || 1 < original )
+        return -1;
+
+    gfp->original = original;
+
+    return 0;
+}
+
+int
+lame_get_original( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->original && 1 >= gfp->original );
+
+    return gfp->original;
+}
+
+
+/*
+ * error_protection.
+ * Use 2 bytes from each frame for CRC checksum.
+ */
+int
+lame_set_error_protection( lame_global_flags*  gfp,
+                           int                 error_protection )
+{
+    /* default = 0 (disabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > error_protection || 1 < error_protection )
+        return -1;
+
+    gfp->error_protection = error_protection;
+
+    return 0;
+}
+
+int
+lame_get_error_protection( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->error_protection && 1 >= gfp->error_protection );
+
+    return gfp->error_protection;
+}
+
+
+/*
+ * padding_type.
+ *  PAD_NO     = pad no frames
+ *  PAD_ALL    = pad all frames
+ *  PAD_ADJUST = adjust padding
+ */
+int
+lame_set_padding_type( lame_global_flags*  gfp,
+                       Padding_type        padding_type )
+{
+    /* default = 2 */
+
+    if ( 0 > padding_type || PAD_MAX_INDICATOR < padding_type )
+        return -1;  /* Unknown padding type */
+
+    gfp->padding_type = padding_type;
+
+    return 0;
+}
+
+Padding_type
+lame_get_padding_type( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->padding_type && PAD_MAX_INDICATOR > gfp->padding_type );
+
+    return gfp->padding_type;
+}
+
+
+/* MP3 'private extension' bit. Meaningless. */
+int
+lame_set_extension( lame_global_flags*  gfp,
+                    int                 extension )
+{
+    /* default = 0 (disabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > extension || 1 < extension )
+        return -1;
+
+    gfp->extension = extension;
+
+    return 0;
+}
+
+int
+lame_get_extension( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->extension && 1 >= gfp->extension );
+
+    return gfp->extension;
+}
+
+
+/* Enforce strict ISO compliance. */
+int
+lame_set_strict_ISO( lame_global_flags*  gfp,
+                     int                 strict_ISO )
+{
+    /* default = 0 (disabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > strict_ISO || 1 < strict_ISO )
+        return -1;
+
+    gfp->strict_ISO = strict_ISO;
+
+    return 0;
+}
+
+int
+lame_get_strict_ISO( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->strict_ISO && 1 >= gfp->strict_ISO );
+
+    return gfp->strict_ISO;
+}
+ 
+
+
+
+/********************************************************************
+ * quantization/noise shaping 
+ ***********************************************************************/
+
+/* Disable the bit reservoir. For testing only. */
+int
+lame_set_disable_reservoir( lame_global_flags*  gfp,
+                            int                 disable_reservoir )
+{
+    /* default = 0 (disabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > disable_reservoir || 1 < disable_reservoir )
+        return -1;
+
+    gfp->disable_reservoir = disable_reservoir;
+
+    return 0;
+}
+
+int
+lame_get_disable_reservoir( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->disable_reservoir && 1 >= gfp->disable_reservoir );
+
+    return gfp->disable_reservoir;
+}
+
+
+
+
+/* Select a different "best quantization" function. default = 0 */
+int
+lame_set_experimentalX( lame_global_flags*  gfp,
+                        int                 experimentalX )
+{
+    gfp->experimentalX = experimentalX;
+
+    return 0;
+}
+
+int
+lame_get_experimentalX( const lame_global_flags*  gfp )
+{
+    return gfp->experimentalX;
+}
+
+
+/* Another experimental option. For testing only. */
+int
+lame_set_experimentalY( lame_global_flags*  gfp,
+                        int                 experimentalY )
+{
+    gfp->experimentalY = experimentalY;
+
+    return 0;
+}
+
+int
+lame_get_experimentalY( const lame_global_flags*  gfp )
+{
+    return gfp->experimentalY;
+}
+
+
+/* Another experimental option. For testing only. */
+int
+lame_set_experimentalZ( lame_global_flags*  gfp,
+                        int                 experimentalZ )
+{
+    gfp->experimentalZ += experimentalZ;
+
+    return 0;
+}
+
+int
+lame_get_experimentalZ( const lame_global_flags*  gfp )
+{
+    return gfp->experimentalZ;
+}
+
+
+/* Naoki's psycho acoustic model. */
+int
+lame_set_exp_nspsytune( lame_global_flags*  gfp,
+                        int                 exp_nspsytune )
+{
+    /* default = 0 (disabled) */
+
+    gfp->exp_nspsytune = exp_nspsytune;
+
+    return 0;
+}
+
+int
+lame_get_exp_nspsytune( const lame_global_flags*  gfp )
+{
+    return gfp->exp_nspsytune;
+}
+
+
+
+
+/********************************************************************
+ * VBR control
+ ***********************************************************************/
+
+// Types of VBR.  default = vbr_off = CBR
+int
+lame_set_VBR( lame_global_flags*  gfp,
+              vbr_mode            VBR )
+{
+    if( 0 > VBR || vbr_max_indicator <= VBR )
+        return -1;  /* Unknown VBR mode! */
+
+    gfp->VBR = VBR;
+
+    return 0;
+}
+
+vbr_mode
+lame_get_VBR( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->VBR && vbr_max_indicator > gfp->VBR );
+
+    return gfp->VBR;
+}
+
+
+/*
+ * VBR quality level.
+ *  0 = highest
+ *  9 = lowest 
+ */
+int
+lame_set_VBR_q( lame_global_flags*  gfp,
+                int                 VBR_q )
+{
+    /* XXX: This should be an enum */
+    /*  to whoever added this note: why should it be an enum?
+        do you want to call a specific setting by name? 
+        say VBR quality level red? */
+    /* No, but VBR_Q_HIGHEST, VBR_Q_HIGH, ..., VBR_Q_MID, ...
+       VBR_Q_LOW, VBR_Q_LOWEST (or something like that )and a
+       VBR_Q_DEFAULT, which aliases the default setting of
+       e.g. VBR_Q_MID. */
+
+
+    if( 0 > VBR_q || 10 <= VBR_q )
+        return -1;  /* Unknown VBR quality level! */
+
+    gfp->VBR_q = VBR_q;
+
+    return 0;
+}
+
+int
+lame_get_VBR_q( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->VBR_q && 10 > gfp->VBR_q );
+
+    return gfp->VBR_q;
+}
+
+
+/* Ignored except for VBR = vbr_abr (ABR mode) */
+int
+lame_set_VBR_mean_bitrate_kbps( lame_global_flags*  gfp,
+                                int                 VBR_mean_bitrate_kbps )
+{
+    gfp->VBR_mean_bitrate_kbps = VBR_mean_bitrate_kbps;
+
+    return 0;
+}
+
+int
+lame_get_VBR_mean_bitrate_kbps( const lame_global_flags*  gfp )
+{
+    return gfp->VBR_mean_bitrate_kbps;
+}
+
+int
+lame_set_VBR_min_bitrate_kbps( lame_global_flags*  gfp,
+                               int                 VBR_min_bitrate_kbps )
+{
+    gfp->VBR_min_bitrate_kbps = VBR_min_bitrate_kbps;
+
+    return 0;
+}
+
+int
+lame_get_VBR_min_bitrate_kbps( const lame_global_flags*  gfp )
+{
+    return gfp->VBR_min_bitrate_kbps;
+}
+
+int
+lame_set_VBR_max_bitrate_kbps( lame_global_flags*  gfp,
+                               int                 VBR_max_bitrate_kbps )
+{
+    gfp->VBR_max_bitrate_kbps = VBR_max_bitrate_kbps;
+
+    return 0;
+}
+
+int
+lame_get_VBR_max_bitrate_kbps( const lame_global_flags*  gfp )
+{
+    return gfp->VBR_max_bitrate_kbps;
+}
+
+
+/*
+ * Strictly enforce VBR_min_bitrate.
+ * Normally it will be violated for analog silence.
+ */
+int
+lame_set_VBR_hard_min( lame_global_flags*  gfp,
+                       int                 VBR_hard_min )
+{
+    /* default = 0 (disabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > VBR_hard_min || 1 < VBR_hard_min )
+        return -1;
+
+    gfp->VBR_hard_min = VBR_hard_min;
+
+    return 0;
+}
+
+int
+lame_get_VBR_hard_min( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->VBR_hard_min && 1 >= gfp->VBR_hard_min );
+
+    return gfp->VBR_hard_min;
+}
+
+
+/********************************************************************
+ * Filtering control
+ ***********************************************************************/
+
+/*
+ * Freqency in Hz to apply lowpass.
+ *   0 = default = lame chooses
+ *  -1 = disabled
+ */
+int
+lame_set_lowpassfreq( lame_global_flags*  gfp,
+                      int                 lowpassfreq )
+{
+    gfp->lowpassfreq = lowpassfreq;
+
+    return 0;
+}
+
+int
+lame_get_lowpassfreq( const lame_global_flags*  gfp )
+{
+    return gfp->lowpassfreq;
+}
+
+
+/*
+ * Width of transition band (in Hz).
+ *  default = one polyphase filter band
+ */
+int
+lame_set_lowpasswidth( lame_global_flags*  gfp,
+                       int                 lowpasswidth )
+{
+    gfp->lowpasswidth = lowpasswidth;
+
+    return 0;
+}
+
+int
+lame_get_lowpasswidth( const lame_global_flags*  gfp )
+{
+    return gfp->lowpasswidth;
+}
+
+
+/*
+ * Frequency in Hz to apply highpass.
+ *   0 = default = lame chooses
+ *  -1 = disabled
+ */
+int
+lame_set_highpassfreq( lame_global_flags*  gfp,
+                       int                 highpassfreq )
+{
+    gfp->highpassfreq = highpassfreq;
+
+    return 0;
+}
+
+int
+lame_get_highpassfreq( const lame_global_flags*  gfp )
+{
+    return gfp->highpassfreq;
+}
+
+
+/*
+ * Width of transition band (in Hz).
+ *  default = one polyphase filter band
+ */
+int
+lame_set_highpasswidth( lame_global_flags*  gfp,
+                        int                 highpasswidth )
+{
+    gfp->highpasswidth = highpasswidth;
+
+    return 0;
+}
+
+int
+lame_get_highpasswidth( const lame_global_flags*  gfp )
+{
+    return gfp->highpasswidth;
+}
+
+
+
+
+/*
+ * psycho acoustics and other arguments which you should not change 
+ * unless you know what you are doing
+ */
+
+/* Only use ATH for masking. */
+int
+lame_set_ATHonly( lame_global_flags*  gfp,
+                  int                 ATHonly )
+{
+    gfp->ATHonly = ATHonly;
+
+    return 0;
+}
+
+int
+lame_get_ATHonly( const lame_global_flags*  gfp )
+{
+    return gfp->ATHonly;
+}
+
+
+/* Only use ATH for short blocks. */
+int
+lame_set_ATHshort( lame_global_flags*  gfp,
+                   int                 ATHshort )
+{
+    gfp->ATHshort = ATHshort;
+
+    return 0;
+}
+
+int
+lame_get_ATHshort( const lame_global_flags*  gfp )
+{
+    return gfp->ATHshort;
+}
+
+
+/* Disable ATH. */
+int
+lame_set_noATH( lame_global_flags*  gfp,
+                int                 noATH )
+{
+    gfp->noATH = noATH;
+
+    return 0;
+}
+
+int
+lame_get_noATH( const lame_global_flags*  gfp )
+{
+    return gfp->noATH;
+}
+
+
+/* Select ATH formula. */
+int
+lame_set_ATHtype( lame_global_flags*  gfp,
+                  int                 ATHtype )
+{
+    /* XXX: ATHtype should be converted to an enum. */
+    gfp->ATHtype = ATHtype;
+
+    return 0;
+}
+
+int
+lame_get_ATHtype( const lame_global_flags*  gfp )
+{
+    return gfp->ATHtype;
+}
+
+
+/* Lower ATH by this many db. */
+int
+lame_set_ATHlower( lame_global_flags*  gfp,
+                   float               ATHlower )
+{
+    gfp->ATHlower = ATHlower;
+    return 0;
+}
+
+float
+lame_get_ATHlower( const lame_global_flags*  gfp )
+{
+    return gfp->ATHlower;
+}
+
+
+/* Select ATH adaptive adjustment scheme. */
+int
+lame_set_athaa_type( lame_global_flags*  gfp,
+                      int                athaa_type )
+{
+    gfp->athaa_type = athaa_type;
+
+    return 0;
+}
+
+int
+lame_get_athaa_type( const lame_global_flags*  gfp )
+{
+    return gfp->athaa_type;
+}
+
+
+/* Select the loudness approximation used by the ATH adaptive auto-leveling. */
+int
+lame_set_athaa_loudapprox( lame_global_flags*  gfp,
+                           int                 athaa_loudapprox )
+{
+    gfp->athaa_loudapprox = athaa_loudapprox;
+
+    return 0;
+}
+
+int
+lame_get_athaa_loudapprox( const lame_global_flags*  gfp )
+{
+    return gfp->athaa_loudapprox;
+}
+
+
+/* Adjust (in dB) the point below which adaptive ATH level adjustment occurs. */
+int
+lame_set_athaa_sensitivity( lame_global_flags*  gfp,
+                            float               athaa_sensitivity )
+{
+    gfp->athaa_sensitivity = athaa_sensitivity;
+
+    return 0;
+}
+
+float
+lame_get_athaa_sensitivity( const lame_global_flags*  gfp )
+{
+    return gfp->athaa_sensitivity;
+}
+
+
+/* Predictability limit (ISO tonality formula) */
+int
+lame_set_cwlimit( lame_global_flags*  gfp,
+                  int                 cwlimit )
+{
+    gfp->cwlimit = cwlimit;
+
+    return 0;
+}
+
+int
+lame_get_cwlimit( const lame_global_flags*  gfp )
+{
+    return gfp->cwlimit;
+}
+
+
+
+/*
+ * Allow blocktypes to differ between channels.
+ * default:
+ *  0 for jstereo => block types coupled
+ *  1 for stereo  => block types may differ
+ */
+int
+lame_set_allow_diff_short( lame_global_flags*  gfp,
+                           int                 allow_diff_short )
+{
+    gfp->short_blocks = 
+        allow_diff_short ? short_block_allowed : short_block_coupled;
+
+    return 0;
+}
+
+int
+lame_get_allow_diff_short( const lame_global_flags*  gfp )
+{
+    if ( gfp->short_blocks == short_block_allowed ) 
+        return 1; /* short blocks allowed to differ */
+    else 
+        return 0; /* not set, dispensed, forced or coupled */
+}
+
+
+/* Use temporal masking effect */
+int
+lame_set_useTemporal( lame_global_flags*  gfp,
+                      int                 useTemporal )
+{
+    /* default = 1 (enabled) */
+
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > useTemporal || 1 < useTemporal )
+        return -1;
+
+    gfp->useTemporal = useTemporal;
+
+    return 0;
+}
+
+int
+lame_get_useTemporal( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->useTemporal && 1 >= gfp->useTemporal );
+
+    return gfp->useTemporal;
+}
+
+
+/* Disable short blocks. */
+int
+lame_set_no_short_blocks( lame_global_flags*  gfp,
+                          int                 no_short_blocks )
+{
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > no_short_blocks || 1 < no_short_blocks )
+        return -1;
+
+    gfp->short_blocks = 
+        no_short_blocks ? short_block_dispensed : short_block_allowed;
+
+    return 0;
+}
+int
+lame_get_no_short_blocks( const lame_global_flags*  gfp )
+{
+    switch ( gfp->short_blocks ) {
+    default:
+    case short_block_not_set:   return -1;
+    case short_block_dispensed: return 1;
+    case short_block_allowed:
+    case short_block_coupled:
+    case short_block_forced:    return 0;
+    }
+}
+
+
+/* Force short blocks. */
+int
+lame_set_force_short_blocks( lame_global_flags*  gfp,
+                          int                 short_blocks )
+{
+    /* enforce disable/enable meaning, if we need more than two values
+       we need to switch to an enum to have an apropriate representation
+       of the possible meanings of the value */
+    if ( 0 > short_blocks || 1 < short_blocks )
+        return -1;
+
+    if (short_blocks == 1)
+        gfp->short_blocks = short_block_forced;
+    else if (gfp->short_blocks == short_block_forced) 
+        gfp->short_blocks = short_block_allowed;
+
+    return 0;
+}
+int
+lame_get_force_short_blocks( const lame_global_flags*  gfp )
+{
+    switch ( gfp->short_blocks ) {
+    default:
+    case short_block_not_set:   return -1;
+    case short_block_dispensed: 
+    case short_block_allowed:
+    case short_block_coupled:   return 0;
+    case short_block_forced:    return 1;
+    }
+}
+
+
+/*
+ * Input PCM is emphased PCM
+ * (for instance from one of the rarely emphased CDs).
+ *
+ * It is STRONGLY not recommended to use this, because psycho does not
+ * take it into account, and last but not least many decoders
+ * ignore these bits
+ */
+int
+lame_set_emphasis( lame_global_flags*  gfp,
+                   int                 emphasis )
+{
+    /* XXX: emphasis should be converted to an enum */
+    if ( 0 > emphasis || 4 <= emphasis )
+        return -1;
+
+    gfp->emphasis = emphasis;
+
+    return 0;
+}
+
+int
+lame_get_emphasis( const lame_global_flags*  gfp )
+{
+    assert( 0 <= gfp->emphasis && 4 > gfp->emphasis );
+
+    return gfp->emphasis;
+}
+
+
+
+
+/***************************************************************/
+/* internal variables, cannot be set...                        */
+/* provided because they may be of use to calling application  */
+/***************************************************************/
+
+/* MPEG version.
+ *  0 = MPEG-2
+ *  1 = MPEG-1
+ * (2 = MPEG-2.5)    
+ */
+int
+lame_get_version( const lame_global_flags* gfp )
+{
+    return gfp->version;
+}
+
+
+/* Encoder delay. */
+int
+lame_get_encoder_delay( const lame_global_flags*  gfp )
+{
+    return gfp->encoder_delay;
+}
+
+/* padding added to the end of the input */
+int
+lame_get_encoder_padding( const lame_global_flags*  gfp )
+{
+    return gfp->encoder_padding;
+}
+
+
+/* Size of MPEG frame. */
+int
+lame_get_framesize( const lame_global_flags*  gfp )
+{
+    return gfp->framesize;
+}
+
+
+/* Number of frames encoded so far. */
+int
+lame_get_frameNum( const lame_global_flags*  gfp )
+{
+    return gfp->frameNum;
+}
+
+int
+lame_get_mf_samples_to_encode( const lame_global_flags*  gfp )
+{
+    lame_internal_flags *gfc = gfp->internal_flags;
+    return gfc->mf_samples_to_encode;
+}
+
+
+int CDECL lame_get_size_mp3buffer( const lame_global_flags*  gfp )
+{
+    int size;
+    compute_flushbits(gfp,&size);
+    return size;
+}
+
+
+
+/*
+ * LAME's estimate of the total number of frames to be encoded.
+ * Only valid if calling program set num_samples.
+ */
+int
+lame_get_totalframes( const lame_global_flags*  gfp )
+{
+    int totalframes;
+    /* estimate based on user set num_samples: */
+    totalframes =
+        2 + ((double)gfp->num_samples * gfp->out_samplerate) / 
+              ((double)gfp->in_samplerate * gfp->framesize);
+
+    /* check to see if we underestimated totalframes */
+    //    if (totalframes < gfp->frameNum)
+    //        totalframes = gfp->frameNum;
+
+    return totalframes;
+}
+
+
+/*
+
+UNDOCUMENTED, experimental settings.  These routines are not prototyped
+in lame.h.  You should not use them, they are experimental and may
+change.  
+
+*/
+
+
+/*
+ *  just another daily changing developer switch  
+ */
+void lame_set_tune( lame_global_flags* gfp, float val ) 
+{
+    gfp->tune_value_a = val;
+    gfp->tune = 1;
+}
+
+/* Custom msfix hack */
+void
+lame_set_msfix( lame_global_flags*  gfp, double msfix )
+{
+    /* default = 0 */
+    gfp->msfix = msfix;
+
+}
+
+int
+lame_set_preset_expopts( lame_global_flags*  gfp, int preset_expopts )
+{
+
+    lame_internal_flags *gfc = gfp->internal_flags;
+
+    gfc->presetTune.use = 1;
+
+    /* default = 0 (disabled) */
+    gfp->preset_expopts = preset_expopts;
+
+    switch (preset_expopts)
+    {
+        case 1:
+
+          lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 1);
+          lame_set_experimentalX(gfp, 3);
+          lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 2); // safejoint
+          lame_set_ATHtype(gfp, 2);
+
+          gfc->presetTune.attackthre   = 35;
+          gfc->presetTune.attackthre_s = 150;
+          gfc->presetTune.ms_maskadjust = .5;
+		  gfc->presetTune.quantcomp_type_s = 3;
+          gfc->presetTune.quantcomp_alt_type = 3;
+          gfc->presetTune.athadjust_switch_level = 2; // Always switch
+
+          break;
+
+        case 2:
+
+          if (gfp->VBR == vbr_mtrh) {
+             lame_set_experimentalX(gfp, 2);
+             gfc->presetTune.quantcomp_adjust_mtrh = 9;
+             gfc->presetTune.quantcomp_type_s = 4;
+             gfc->presetTune.quantcomp_alt_type = 0;
+             gfc->presetTune.athadjust_safe_noiseshaping_thre = 0.0;
+			 gfc->presetTune.athadjust_safe_athaasensitivity = 8.0;
+          }
+          else {
+             lame_set_experimentalX(gfp, 3);
+             gfc->presetTune.quantcomp_adjust_rh_tot = 600;
+			 gfc->presetTune.quantcomp_adjust_rh_max = 60;
+             gfc->presetTune.quantcomp_type_s = 3;
+             gfc->presetTune.quantcomp_alt_type = 1;
+          }
+
+          lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 1);
+          lame_set_experimentalZ(gfp, 1);
+          lame_set_VBR_q(gfp, 2);
+          lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 2); // safejoint
+          lame_set_ATHtype(gfp, 2);				
+          // modify sfb21 by 3 dB plus ns-treble=0                 
+          lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | (12 << 20));
+
+          gfc->presetTune.attackthre   = 35;
+          gfc->presetTune.attackthre_s = 150;
+          gfc->presetTune.ms_maskadjust = .5;
+          gfc->presetTune.athadjust_switch_level = 1;
+          gfc->presetTune.athadjust_msfix = 2.13;
+
+          break;
+
+        case 3:
+
+          if (gfp->VBR == vbr_mtrh) {
+             gfc->presetTune.quantcomp_type_s = 4;
+             gfc->presetTune.quantcomp_adjust_mtrh = 9;
+			 gfc->presetTune.quantcomp_alt_type = 0;
+             (void) lame_set_ATHlower( gfp, -2 );
+             gfc->presetTune.athadjust_safe_noiseshaping_thre = 0.0;
+			 gfc->presetTune.athadjust_safe_athaasensitivity = 8.0;
+          }
+          else {
+             gfc->presetTune.quantcomp_type_s = 3;
+             gfc->presetTune.quantcomp_adjust_rh_tot = 600;
+			 gfc->presetTune.quantcomp_adjust_rh_max = 60;
+             (void) lame_set_ATHlower( gfp, -1 );
+          }
+
+          lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 1);
+          lame_set_experimentalZ(gfp, 1);
+          lame_set_experimentalX(gfp, 1);
+          lame_set_VBR_q(gfp, 2);
+          lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | 2); // safejoint
+   (void) lame_set_msfix( gfp, 2.13 );
+          lame_set_ATHtype(gfp, 4);
+          // modify sfb21 by 3.75 dB plus ns-treble=0                 
+          lame_set_exp_nspsytune(gfp, lame_get_exp_nspsytune(gfp) | (15 << 20));
+
+          gfc->presetTune.attackthre   = 35;
+          gfc->presetTune.attackthre_s = 150;
+          gfc->presetTune.ms_maskadjust = .5;
+          gfc->presetTune.athadjust_switch_level = 1;
+
+          break;
+    }
+    return 0;
+}
+
+int
+lame_set_preset_notune( lame_global_flags*  gfp, int preset_notune )
+{
+    lame_internal_flags *gfc = gfp->internal_flags;
+
+    gfc->presetTune.use = 0;  // Turn off specialized preset tunings
+
+    return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+