/* -*- mode: C; mode: fold -*- */
/*
* set/get functions for lame_global_flags
*
* Copyright (c) 2001-2005 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.71.2.2 2005/11/26 18:37:34 bouvigne Exp $ */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <assert.h>
#include "util.h"
#include "bitstream.h" /* because of compute_flushbits */
#ifdef WITH_DMALLOC
#include <dmalloc.h>
#endif
#include "set_get.h"
/*
* 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 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 */
/* DEPRECATED */
int
lame_set_ogg( lame_global_flags* gfp,
int ogg )
{
return -1;
}
int
lame_get_ogg( const lame_global_flags* gfp )
{
return 0;
}
/*
* 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: 3 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 */
/* DEPRECATED */
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;
lame_set_mode( gfp, JOINT_STEREO );
return 0;
}
int
lame_get_mode_automs( const lame_global_flags* gfp )
{
return 1;
}
/*
* 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;
}
/* Perform ReplayGain analysis */
int
lame_set_findReplayGain( lame_global_flags* gfp,
int findReplayGain )
{
/* 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 > findReplayGain || 1 < findReplayGain )
return -1;
gfp->findReplayGain = findReplayGain;
return 0;
}
int
lame_get_findReplayGain( const lame_global_flags* gfp )
{
assert( 0 <= gfp->findReplayGain && 1 >= gfp->findReplayGain);
return gfp->findReplayGain;
}
/* Decode on the fly. Find the peak sample. If ReplayGain analysis is
enabled then perform it on the decoded data. */
int
lame_set_decode_on_the_fly( lame_global_flags* gfp,
int decode_on_the_fly )
{
#ifndef DECODE_ON_THE_FLY
return -1;
#else
/* 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_on_the_fly || 1 < decode_on_the_fly )
return -1;
gfp->decode_on_the_fly = decode_on_the_fly;
return 0;
#endif
}
int
lame_get_decode_on_the_fly( const lame_global_flags* gfp )
{
assert( 0 <= gfp->decode_on_the_fly && 1 >= gfp->decode_on_the_fly );
return gfp->decode_on_the_fly;
}
/* DEPRECATED. same as lame_set_decode_on_the_fly() */
int
lame_set_findPeakSample( lame_global_flags* gfp,
int arg )
{
return lame_set_decode_on_the_fly(gfp, arg);
}
int
lame_get_findPeakSample( const lame_global_flags* gfp )
{
return lame_get_decode_on_the_fly(gfp);
}
/* DEPRECATED. same as lame_set_findReplayGain() */
int
lame_set_ReplayGain_input( lame_global_flags* gfp,
int arg )
{
return lame_set_findReplayGain(gfp, arg);
}
int
lame_get_ReplayGain_input( const lame_global_flags* gfp )
{
return lame_get_findReplayGain(gfp);
}
/* DEPRECATED. same as lame_set_decode_on_the_fly() &&
lame_set_findReplayGain() */
int
lame_set_ReplayGain_decode( lame_global_flags* gfp,
int arg )
{
if( lame_set_decode_on_the_fly(gfp, arg) < 0 ||
lame_set_findReplayGain(gfp, arg) < 0)
return -1;
else
return 0;
}
int
lame_get_ReplayGain_decode( const lame_global_flags* gfp )
{
if (lame_get_decode_on_the_fly(gfp) > 0 &&
lame_get_findReplayGain(gfp) > 0)
return 1;
else
return 0;
}
/* set and get some gapless encoding flags */
int
lame_set_nogap_total( lame_global_flags* gfp,
int the_nogap_total )
{
lame_internal_flags *gfc = gfp->internal_flags;
gfc->nogap_total = the_nogap_total;
return 0;
}
int
lame_get_nogap_total( const lame_global_flags* gfp )
{
return gfp->internal_flags->nogap_total;
}
int
lame_set_nogap_currentindex( lame_global_flags* gfp,
int the_nogap_index )
{
lame_internal_flags *gfc = gfp->internal_flags;
gfc->nogap_current = the_nogap_index;
return 0;
}
int
lame_get_nogap_currentindex( const lame_global_flags* gfp )
{
return gfp->internal_flags->nogap_current;
}
/* 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;
if (brate > 320) {
gfp->disable_reservoir = 1;
}
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 )
{
return 0;
}
Padding_type
lame_get_padding_type( const lame_global_flags* gfp )
{
return PAD_ADJUST;
}
/* 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;
}
int
lame_set_experimentalX( lame_global_flags* gfp,
int experimentalX )
{
lame_set_quant_comp( gfp, experimentalX);
lame_set_quant_comp_short( gfp, experimentalX);
return 0;
}
int
lame_get_experimentalX( const lame_global_flags* gfp )
{
return lame_get_quant_comp( gfp);
}
/* Select a different "best quantization" function. default = 0 */
int
lame_set_quant_comp( lame_global_flags* gfp,
int quant_type )
{
gfp->quant_comp
= quant_type;
return 0;
}
int
lame_get_quant_comp( const lame_global_flags* gfp )
{
return gfp->quant_comp;
}
/* Select a different "best quantization" function. default = 0 */
int
lame_set_quant_comp_short( lame_global_flags* gfp,
int quant_type )
{
gfp->quant_comp_short = quant_type;
return 0;
}
int
lame_get_quant_comp_short( const lame_global_flags* gfp )
{
return gfp->quant_comp_short;
}
/* 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;
}
int
lame_set_experimentalZ( lame_global_flags* gfp,
int experimentalZ )
{
return 0;
}
int
lame_get_experimentalZ( const lame_global_flags* gfp )
{
return 0;
}
/* 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;
}
int
lame_set_exp_nspsytune2_int( lame_global_flags* gfp,
int adr,int val)
{
int ret = gfp->exp_nspsytune2.integer[adr];
gfp->exp_nspsytune2.integer[adr] = val;
return ret;
}
float
lame_set_exp_nspsytune2_real( lame_global_flags* gfp,
int adr,float val)
{
float ret = gfp->exp_nspsytune2.real[adr];
gfp->exp_nspsytune2.real[adr] = val;
return ret;
}
void *
lame_set_exp_nspsytune2_pointer( lame_global_flags* gfp,
int adr,void *val)
{
void *ret = gfp->exp_nspsytune2.pointer[adr];
gfp->exp_nspsytune2.pointer[adr] = val;
return ret;
}
/********************************************************************
* 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;
/* lame_set_ATHcurve(gfp, 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
*/
int
lame_set_psy_model( lame_global_flags* gfp,
int psy )
{
gfp->psymodel = psy;
return 0;
}
int
lame_get_psy_model( const lame_global_flags* gfp )
{
return gfp->psymodel;
}
/* Adjust masking values. */
int
lame_set_maskingadjust( lame_global_flags* gfp,
float adjust )
{
gfp->maskingadjust = adjust;
return 0;
}
float
lame_get_maskingadjust( const lame_global_flags* gfp )
{
return gfp->maskingadjust;
}
int
lame_set_maskingadjust_short( lame_global_flags* gfp,
float adjust )
{
gfp->maskingadjust_short = adjust;
return 0;
}
float
lame_get_maskingadjust_short( const lame_global_flags* gfp )
{
return gfp->maskingadjust_short;
}
/* 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;
}
/* Select ATH formula 4 shape. */
int
lame_set_ATHcurve( lame_global_flags* gfp,
float ATHcurve )
{
gfp->ATHcurve = ATHcurve;
return 0;
}
float
lame_get_ATHcurve( const lame_global_flags* gfp )
{
return gfp->ATHcurve;
}
/* Lower ATH by this many db. */
int
lame_set_ATHlower( lame_global_flags* gfp,
float ATHlower )
{
gfp->ATHlower = -ATHlower / 10.0;
return 0;
}
float
lame_get_ATHlower( const lame_global_flags* gfp )
{
return -gfp->ATHlower * 10.0;
}
/* 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 )
{
ERRORF(gfp->internal_flags, "--athaa-loudapprox is obsolete\n");
return 0;
}
int
lame_get_athaa_loudapprox( const lame_global_flags* gfp )
{
/* obsolete, the type known under number 2 is the only survival */
return 2;
}
/* 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;
}
/* Use inter-channel masking effect */
int
lame_set_interChRatio( lame_global_flags* gfp,
float ratio )
{
/* default = 0.0 (no inter-channel maskin) */
if (! (0 <= ratio && ratio <= 1.0))
return -1;
gfp->interChRatio = ratio;
return 0;
}
float
lame_get_interChRatio( const lame_global_flags* gfp )
{
assert( (0 <= gfp->interChRatio && gfp->interChRatio <= 1.0) ||
(gfp->interChRatio == -1));
return gfp->interChRatio;
}
/* Use pseudo substep shaping method */
int
lame_set_substep( lame_global_flags* gfp,
int method )
{
lame_internal_flags *gfc = gfp->internal_flags;
/* default = 0.0 (no substep noise shaping) */
if (! (0 <= method && method <= 7))
return -1;
gfc->substep_shaping = method;
return 0;
}
int
lame_get_substep(const lame_global_flags* gfp )
{
lame_internal_flags *gfc = gfp->internal_flags;
assert(0 <= gfc->substep_shaping && gfc->substep_shaping <= 7);
return gfc->substep_shaping;
}
/* scalefactors scale */
int
lame_set_sfscale( lame_global_flags* gfp,
int val )
{
if (val)
gfp->internal_flags->noise_shaping = 2;
else
gfp->internal_flags->noise_shaping = 1;
return 0;
}
int
lame_get_sfscale(const lame_global_flags* gfp )
{
return (gfp->internal_flags->noise_shaping == 2);
}
/* subblock gain */
int
lame_set_subblock_gain(lame_global_flags *gfp, int sbgain)
{
gfp->internal_flags->subblock_gain = sbgain;
return sbgain;
}
int
lame_get_subblock_gain(const lame_global_flags * gfp)
{
return gfp->internal_flags->subblock_gain;
}
/* 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;
}
}
int
lame_set_short_threshold_lrm( lame_global_flags* gfp,
float lrm)
{
lame_internal_flags *gfc = gfp->internal_flags;
gfc->nsPsy.attackthre = lrm;
return 0;
}
float
lame_get_short_threshold_lrm( const lame_global_flags* gfp)
{
lame_internal_flags *gfc = gfp->internal_flags;
return gfc->nsPsy.attackthre;
}
int
lame_set_short_threshold_s( lame_global_flags* gfp,
float s)
{
lame_internal_flags *gfc = gfp->internal_flags;
gfc->nsPsy.attackthre_s = s;
return 0;
}
float
lame_get_short_threshold_s( const lame_global_flags* gfp)
{
lame_internal_flags *gfc = gfp->internal_flags;
return gfc->nsPsy.attackthre_s;
}
int
lame_set_short_threshold( lame_global_flags* gfp,
float lrm, float s)
{
lame_set_short_threshold_lrm(gfp, lrm);
lame_set_short_threshold_s(gfp, s);
return 0;
}
/*
* 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;
}
int
lame_get_RadioGain( const lame_global_flags* gfp )
{
lame_internal_flags *gfc = gfp->internal_flags;
return gfc->RadioGain;
}
int
lame_get_AudiophileGain( const lame_global_flags* gfp )
{
lame_internal_flags *gfc = gfp->internal_flags;
return gfc->AudiophileGain;
}
float
lame_get_PeakSample( const lame_global_flags* gfp )
{
lame_internal_flags *gfc = gfp->internal_flags;
return (float)gfc->PeakSample;
}
int
lame_get_noclipGainChange( const lame_global_flags* gfp )
{
lame_internal_flags *gfc = gfp->internal_flags;
return gfc->noclipGainChange;
}
float
lame_get_noclipScale( const lame_global_flags* gfp )
{
lame_internal_flags *gfc = gfp->internal_flags;
return gfc->noclipScale;
}
/*
* 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;
}
int
lame_set_preset( lame_global_flags* gfp, int preset )
{
gfp->preset = preset;
return apply_preset(gfp, preset, 1);
}
int
lame_set_asm_optimizations( lame_global_flags* gfp, int optim, int mode)
{
mode = (mode == 1? 1 : 0);
switch (optim){
case MMX: {
gfp->asm_optimizations.mmx = mode;
return optim;
}
case AMD_3DNOW: {
gfp->asm_optimizations.amd3dnow = mode;
return optim;
}
case SSE: {
gfp->asm_optimizations.sse = mode;
return optim;
}
default: return optim;
}
}
/*
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;
}
void lame_set_ms_sparsing( lame_global_flags* gfp, int val )
{
gfp->sparsing = val;
}
int lame_get_ms_sparsing( lame_global_flags* gfp )
{
return gfp->sparsing;
}
void lame_set_ms_sparse_low( lame_global_flags* gfp, float val )
{
gfp->sparse_low = val;
}
float lame_get_ms_sparse_low( lame_global_flags* gfp )
{
return gfp->sparse_low;
}
void lame_set_ms_sparse_high( lame_global_flags* gfp, float val )
{
gfp->sparse_high = val;
}
float lame_get_ms_sparse_high( lame_global_flags* gfp )
{
return gfp->sparse_high;
}
/* Custom msfix hack */
void
lame_set_msfix( lame_global_flags* gfp, double msfix )
{
/* default = 0 */
gfp->msfix = msfix;
}
float
lame_get_msfix( const lame_global_flags* gfp )
{
return gfp->msfix;
}
int
lame_set_preset_expopts( lame_global_flags* gfp, int preset_expopts )
{
return 0;
}
int
lame_set_preset_notune( lame_global_flags* gfp, int preset_notune )
{
return 0;
}
root