lame.h   lame.h 
skipping to change at line 21 skipping to change at line 21
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; see the file COPYING. If not, write to * along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/* $Id: lame.h,v 1.118 2002/10/18 22:54:33 robert Exp $ */ /* $Id: lame.h,v 1.149 2003/12/03 03:09:40 olcios Exp $ */
#ifndef LAME_LAME_H #ifndef LAME_LAME_H
#define LAME_LAME_H #define LAME_LAME_H
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
#ifdef HAVE_MPGLIB
#define DECODE_ON_THE_FLY
#endif
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#endif #endif
#if defined(WIN32) #if defined(WIN32)
#undef CDECL #undef CDECL
#define CDECL _cdecl #define CDECL _cdecl
#else #else
#define CDECL #define CDECL
#endif #endif
skipping to change at line 74 skipping to change at line 78
PAD_ADJUST, PAD_ADJUST,
PAD_MAX_INDICATOR /* Don't use this! It's used for sanity checks. */ PAD_MAX_INDICATOR /* Don't use this! It's used for sanity checks. */
} Padding_type; } Padding_type;
/*presets*/ /*presets*/
typedef enum preset_mode_e { typedef enum preset_mode_e {
/*values from 8 to 320 should be reserved for abr bitrates*/ /*values from 8 to 320 should be reserved for abr bitrates*/
/*for abr I'd suggest to directly use the targeted bitrate as a value*/ /*for abr I'd suggest to directly use the targeted bitrate as a value*/
ABR_8 = 8, ABR_8 = 8,
ABR_320 = 320, ABR_320 = 320,
V9 = 410, /*Vx to match Lame and VBR_xx to match FhG*/
VBR_10 = 410,
V8 = 420,
VBR_20 = 420,
V7 = 430,
VBR_30 = 430,
V6 = 440,
VBR_40 = 440,
V5 = 450,
VBR_50 = 450,
V4 = 460,
VBR_60 = 460,
V3 = 470,
VBR_70 = 470,
V2 = 480,
VBR_80 = 480,
V1 = 490,
VBR_90 = 490,
V0 = 500,
VBR_100 = 500,
/*still there for compatibility*/
R3MIX = 1000, R3MIX = 1000,
STANDARD = 1001, STANDARD = 1001,
EXTREME = 1002, EXTREME = 1002,
INSANE = 1003, INSANE = 1003,
STANDARD_FAST = 1004, STANDARD_FAST = 1004,
EXTREME_FAST = 1005, EXTREME_FAST = 1005,
MEDIUM = 1006, MEDIUM = 1006,
MEDIUM_FAST = 1007 MEDIUM_FAST = 1007
} preset_mode; } preset_mode;
/*asm optimizations*/ /*asm optimizations*/
typedef enum asm_optimizations_e { typedef enum asm_optimizations_e {
MMX = 1, MMX = 1,
AMD_3DNOW = 2, AMD_3DNOW = 2,
SSE = 3 SSE = 3
} asm_optimizations; } asm_optimizations;
/* psychoacoustic model */
typedef enum Psy_model_e {
PSY_GPSYCHO = 1,
PSY_NSPSYTUNE = 2
} Psy_model;
struct lame_global_struct; struct lame_global_struct;
typedef struct lame_global_struct lame_global_flags; typedef struct lame_global_struct lame_global_flags;
typedef lame_global_flags *lame_t; typedef lame_global_flags *lame_t;
/*********************************************************************** /***********************************************************************
* *
* The LAME API * The LAME API
* These functions should be called, in this order, for each * These functions should be called, in this order, for each
* MP3 file to be encoded * MP3 file to be encoded. See the file "API" for more documentation
* *
***********************************************************************/ ***********************************************************************/
/* /*
* REQUIRED: * REQUIRED:
* initialize the encoder. sets default for all encoder paramters, * initialize the encoder. sets default for all encoder parameters,
* returns -1 if some malloc()'s failed * returns NULL if some malloc()'s failed
* otherwise returns 0 * otherwise returns pointer to structure needed for all future
* API calls.
*/ */
lame_global_flags * CDECL lame_init(void); lame_global_flags * CDECL lame_init(void);
/* obsolete version */ /* obsolete version */
int CDECL lame_init_old(lame_global_flags *); int CDECL lame_init_old(lame_global_flags *);
/* /*
* OPTIONAL: * OPTIONAL:
* set as needed to override defaults * set as needed to override defaults
*/ */
/******************************************************************** /********************************************************************
* input stream description * input stream description
***********************************************************************/ ***********************************************************************/
/* number of samples. default = 2^32-1 */ /* number of samples. default = 2^32-1 */
int CDECL lame_set_num_samples(lame_global_flags *, unsigned long); int CDECL lame_set_num_samples(lame_global_flags *, unsigned long);
unsigned long CDECL lame_get_num_samples(const lame_global_flags *); unsigned long CDECL lame_get_num_samples(const lame_global_flags *);
/* input sample rate in Hz. default = 44100hz */ /* input sample rate in Hz. default = 44100hz */
int CDECL lame_set_in_samplerate(lame_global_flags *, int); int CDECL lame_set_in_samplerate(lame_global_flags *, int);
int CDECL lame_get_in_samplerate(const lame_global_flags *); int CDECL lame_get_in_samplerate(const lame_global_flags *);
/* number of channels in input stream. default=2 */ /* number of channels in input stream. default=2 */
int CDECL lame_set_num_channels(lame_global_flags *, int); int CDECL lame_set_num_channels(lame_global_flags *, int);
int CDECL lame_get_num_channels(const lame_global_flags *); int CDECL lame_get_num_channels(const lame_global_flags *);
/* /*
scale the input by this amount before encoding. default=0 (disabled) scale the input by this amount before encoding. default=0 (disabled)
(not used by decoding routines) (not used by decoding routines)
*/ */
int CDECL lame_set_scale(lame_global_flags *, float); int CDECL lame_set_scale(lame_global_flags *, float);
float CDECL lame_get_scale(const lame_global_flags *); float CDECL lame_get_scale(const lame_global_flags *);
/* /*
scale the channel 0 (left) input by this amount before encoding. scale the channel 0 (left) input by this amount before encoding.
default=0 (disabled) default=0 (disabled)
(not used by decoding routines) (not used by decoding routines)
*/ */
int CDECL lame_set_scale_left(lame_global_flags *, float); int CDECL lame_set_scale_left(lame_global_flags *, float);
float CDECL lame_get_scale_left(const lame_global_flags *); float CDECL lame_get_scale_left(const lame_global_flags *);
/* /*
scale the channel 1 (right) input by this amount before encoding. scale the channel 1 (right) input by this amount before encoding.
default=0 (disabled) default=0 (disabled)
(not used by decoding routines) (not used by decoding routines)
*/ */
int CDECL lame_set_scale_right(lame_global_flags *, float); int CDECL lame_set_scale_right(lame_global_flags *, float);
float CDECL lame_get_scale_right(const lame_global_flags *); float CDECL lame_get_scale_right(const lame_global_flags *);
/* /*
output sample rate in Hz. default = 0, which means LAME picks best value output sample rate in Hz. default = 0, which means LAME picks best value
based on the amount of compression. MPEG only allows: based on the amount of compression. MPEG only allows:
MPEG1 32, 44.1, 48khz MPEG1 32, 44.1, 48khz
MPEG2 16, 22.05, 24 MPEG2 16, 22.05, 24
MPEG2.5 8, 11.025, 12 MPEG2.5 8, 11.025, 12
(not used by decoding routines) (not used by decoding routines)
*/ */
int CDECL lame_set_out_samplerate(lame_global_flags *, int); int CDECL lame_set_out_samplerate(lame_global_flags *, int);
int CDECL lame_get_out_samplerate(const lame_global_flags *); int CDECL lame_get_out_samplerate(const lame_global_flags *);
/******************************************************************** /********************************************************************
* general control parameters * general control parameters
***********************************************************************/ ***********************************************************************/
/* 1=cause LAME to collect data for an MP3 frame analyzer. default=0 */ /* 1=cause LAME to collect data for an MP3 frame analyzer. default=0 */
int CDECL lame_set_analysis(lame_global_flags *, int); int CDECL lame_set_analysis(lame_global_flags *, int);
int CDECL lame_get_analysis(const lame_global_flags *); int CDECL lame_get_analysis(const lame_global_flags *);
/* /*
1 = write a Xing header (VBR) / INFO tag (CBR) frame. 1 = write a Xing VBR header frame.
default = 1 default = 1
this variable must have been added by a Hungarian notation Windows program this variable must have been added by a Hungarian notation Windows progra
mer :-) mmer :-)
*/ */
int CDECL lame_set_bWriteVbrTag(lame_global_flags *, int); int CDECL lame_set_bWriteVbrTag(lame_global_flags *, int);
int CDECL lame_get_bWriteVbrTag(const lame_global_flags *); int CDECL lame_get_bWriteVbrTag(const lame_global_flags *);
/* 1=decode only. use lame/mpglib to convert mp3/ogg to wav. default=0 */ /* 1=decode only. use lame/mpglib to convert mp3/ogg to wav. default=0 */
int CDECL lame_set_decode_only(lame_global_flags *, int); int CDECL lame_set_decode_only(lame_global_flags *, int);
int CDECL lame_get_decode_only(const lame_global_flags *); int CDECL lame_get_decode_only(const lame_global_flags *);
/* 1=encode a Vorbis .ogg file. default=0 */ /* 1=encode a Vorbis .ogg file. default=0 */
/* DEPRECATED */
int CDECL lame_set_ogg(lame_global_flags *, int); int CDECL lame_set_ogg(lame_global_flags *, int);
int CDECL lame_get_ogg(const lame_global_flags *); int CDECL lame_get_ogg(const lame_global_flags *);
/* /*
internal algorithm selection. True quality is determined by the bitrate internal algorithm selection. True quality is determined by the bitrate
but this variable will effect quality by selecting expensive or cheap algo but this variable will effect quality by selecting expensive or cheap alg
rithms. orithms.
quality=0..9. 0=best (very slow). 9=worst. quality=0..9. 0=best (very slow). 9=worst.
recommended: 2 near-best quality, not too slow recommended: 2 near-best quality, not too slow
5 good quality, fast 5 good quality, fast
7 ok quality, really fast 7 ok quality, really fast
*/ */
int CDECL lame_set_quality(lame_global_flags *, int); int CDECL lame_set_quality(lame_global_flags *, int);
int CDECL lame_get_quality(const lame_global_flags *); int CDECL lame_get_quality(const lame_global_flags *);
/* /*
mode = 0,1,2,3 = stereo, jstereo, dual channel (not supported), mono mode = 0,1,2,3 = stereo, jstereo, dual channel (not supported), mono
default: lame picks based on compression ration and input channels default: lame picks based on compression ration and input channels
*/ */
int CDECL lame_set_mode(lame_global_flags *, MPEG_mode); int CDECL lame_set_mode(lame_global_flags *, MPEG_mode);
MPEG_mode CDECL lame_get_mode(const lame_global_flags *); MPEG_mode CDECL lame_get_mode(const lame_global_flags *);
/* /*
mode_automs. Use a M/S mode with a switching threshold based on mode_automs. Use a M/S mode with a switching threshold based on
compression ratio compression ratio
default = 0 (disabled) DEPRECATED
*/ */
int CDECL lame_set_mode_automs(lame_global_flags *, int); int CDECL lame_set_mode_automs(lame_global_flags *, int);
int CDECL lame_get_mode_automs(const lame_global_flags *); int CDECL lame_get_mode_automs(const lame_global_flags *);
/* /*
force_ms. Force M/S for all frames. For testing only. force_ms. Force M/S for all frames. For testing only.
default = 0 (disabled) default = 0 (disabled)
*/ */
int CDECL lame_set_force_ms(lame_global_flags *, int); int CDECL lame_set_force_ms(lame_global_flags *, int);
int CDECL lame_get_force_ms(const lame_global_flags *); int CDECL lame_get_force_ms(const lame_global_flags *);
/* use free_format? default = 0 (disabled) */ /* use free_format? default = 0 (disabled) */
int CDECL lame_set_free_format(lame_global_flags *, int); int CDECL lame_set_free_format(lame_global_flags *, int);
int CDECL lame_get_free_format(const lame_global_flags *); int CDECL lame_get_free_format(const lame_global_flags *);
/* perform ReplayGain analysis on input data? default = 0 (disabled) */
int CDECL lame_set_ReplayGain_input(lame_global_flags *, int);
int CDECL lame_get_ReplayGain_input(const lame_global_flags *);
#ifdef DECODE_ON_THE_FLY
/* perform ReplayGain analysis on decoded data? default = 0 (disabled)
* NOTE: this option enables decoding on the fly and therefore if it is
* set the build-in decoder should not be used */
int CDECL lame_set_ReplayGain_decode(lame_global_flags *, int);
int CDECL lame_get_ReplayGain_decode(const lame_global_flags *);
/* find peak sample? default = 0 (disabled)
* NOTE: this option enables decoding on the fly and therefore if it is
* set the build-in decoder should not be used */
int CDECL lame_set_findPeakSample(lame_global_flags *, int);
int CDECL lame_get_findPeakSample(const lame_global_flags *);
#endif
/* /*
* OPTIONAL: * OPTIONAL:
* Set printf like error/debug/message reporting functions. * Set printf like error/debug/message reporting functions.
* The second argument has to be a pointer to a function which looks like * The second argument has to be a pointer to a function which looks like
* void my_debugf(const char *format, va_list ap) * void my_debugf(const char *format, va_list ap)
* { * {
* (void) vfprintf(stdout, format, ap); * (void) vfprintf(stdout, format, ap);
* } * }
* If you use NULL as the value of the pointer in the set function, the * If you use NULL as the value of the pointer in the set function, the
* lame buildin function will be used (prints to stderr). * lame buildin function will be used (prints to stderr).
skipping to change at line 271 skipping to change at line 324
int CDECL lame_get_copyright(const lame_global_flags *); int CDECL lame_get_copyright(const lame_global_flags *);
/* mark as original. default=1 */ /* mark as original. default=1 */
int CDECL lame_set_original(lame_global_flags *, int); int CDECL lame_set_original(lame_global_flags *, int);
int CDECL lame_get_original(const lame_global_flags *); int CDECL lame_get_original(const lame_global_flags *);
/* error_protection. Use 2 bytes from each frame for CRC checksum. default =0 */ /* error_protection. Use 2 bytes from each frame for CRC checksum. default =0 */
int CDECL lame_set_error_protection(lame_global_flags *, int); int CDECL lame_set_error_protection(lame_global_flags *, int);
int CDECL lame_get_error_protection(const lame_global_flags *); int CDECL lame_get_error_protection(const lame_global_flags *);
/* padding_type. 0=pad no frames 1=pad all frames 2=adjust padding(defaul t) */ /* padding_type. 0=pad no frames 1=pad all frames 2=adjust padding(default ) */
int CDECL lame_set_padding_type(lame_global_flags *, Padding_type); int CDECL lame_set_padding_type(lame_global_flags *, Padding_type);
Padding_type CDECL lame_get_padding_type(const lame_global_flags *); Padding_type CDECL lame_get_padding_type(const lame_global_flags *);
/* MP3 'private extension' bit Meaningless. default=0 */ /* MP3 'private extension' bit Meaningless. default=0 */
int CDECL lame_set_extension(lame_global_flags *, int); int CDECL lame_set_extension(lame_global_flags *, int);
int CDECL lame_get_extension(const lame_global_flags *); int CDECL lame_get_extension(const lame_global_flags *);
/* enforce strict ISO compliance. default=0 */ /* enforce strict ISO compliance. default=0 */
int CDECL lame_set_strict_ISO(lame_global_flags *, int); int CDECL lame_set_strict_ISO(lame_global_flags *, int);
int CDECL lame_get_strict_ISO(const lame_global_flags *); int CDECL lame_get_strict_ISO(const lame_global_flags *);
/******************************************************************** /********************************************************************
* quantization/noise shaping * quantization/noise shaping
***********************************************************************/ ***********************************************************************/
/* disable the bit reservoir. For testing only. default=0 */ /* disable the bit reservoir. For testing only. default=0 */
int CDECL lame_set_disable_reservoir(lame_global_flags *, int); int CDECL lame_set_disable_reservoir(lame_global_flags *, int);
int CDECL lame_get_disable_reservoir(const lame_global_flags *); int CDECL lame_get_disable_reservoir(const lame_global_flags *);
/* select a different "best quantization" function. default=0 */ /* select a different "best quantization" function. default=0 */
int CDECL lame_set_experimentalX(lame_global_flags *, int); int CDECL lame_set_quant_comp(lame_global_flags *, int);
int CDECL lame_get_quant_comp(const lame_global_flags *);
int CDECL lame_set_quant_comp_short(lame_global_flags *, int);
int CDECL lame_get_quant_comp_short(const lame_global_flags *);
int CDECL lame_set_experimentalX(lame_global_flags *, int); /* compatibilit
y*/
int CDECL lame_get_experimentalX(const lame_global_flags *); int CDECL lame_get_experimentalX(const lame_global_flags *);
/* another experimental option. for testing only */ /* another experimental option. for testing only */
int CDECL lame_set_experimentalY(lame_global_flags *, int); int CDECL lame_set_experimentalY(lame_global_flags *, int);
int CDECL lame_get_experimentalY(const lame_global_flags *); int CDECL lame_get_experimentalY(const lame_global_flags *);
/* another experimental option. for testing only */ /* another experimental option. for testing only */
int CDECL lame_set_experimentalZ(lame_global_flags *, int); int CDECL lame_set_experimentalZ(lame_global_flags *, int);
int CDECL lame_get_experimentalZ(const lame_global_flags *); int CDECL lame_get_experimentalZ(const lame_global_flags *);
/* Naoki's psycho acoustic model. default=0 */ /* Naoki's psycho acoustic model. default=0 */
int CDECL lame_set_exp_nspsytune(lame_global_flags *, int); int CDECL lame_set_exp_nspsytune(lame_global_flags *, int);
int CDECL lame_get_exp_nspsytune(const lame_global_flags *); int CDECL lame_get_exp_nspsytune(const lame_global_flags *);
void CDECL lame_set_msfix(lame_global_flags *, double); void CDECL lame_set_msfix(lame_global_flags *, double);
float CDECL lame_get_msfix(const lame_global_flags *);
int lame_set_exp_nspsytune2_int( lame_global_flags*, int, int); int lame_set_exp_nspsytune2_int( lame_global_flags*, int, int);
float lame_set_exp_nspsytune2_real( lame_global_flags*, int, float); float lame_set_exp_nspsytune2_real( lame_global_flags*, int, float);
void * lame_set_exp_nspsytune2_pointer( lame_global_flags*, int, void *); void * lame_set_exp_nspsytune2_pointer( lame_global_flags*, int, void *);
/******************************************************************** /********************************************************************
* VBR control * VBR control
***********************************************************************/ ***********************************************************************/
/* Types of VBR. default = vbr_off = CBR */ /* Types of VBR. default = vbr_off = CBR */
int CDECL lame_set_VBR(lame_global_flags *, vbr_mode); int CDECL lame_set_VBR(lame_global_flags *, vbr_mode);
vbr_mode CDECL lame_get_VBR(const lame_global_flags *); vbr_mode CDECL lame_get_VBR(const lame_global_flags *);
/* VBR quality level. 0=highest 9=lowest */ /* VBR quality level. 0=highest 9=lowest */
int CDECL lame_set_VBR_q(lame_global_flags *, int); int CDECL lame_set_VBR_q(lame_global_flags *, int);
int CDECL lame_get_VBR_q(const lame_global_flags *); int CDECL lame_get_VBR_q(const lame_global_flags *);
/* Ignored except for VBR=vbr_abr (ABR mode) */ /* Ignored except for VBR=vbr_abr (ABR mode) */
int CDECL lame_set_VBR_mean_bitrate_kbps(lame_global_flags *, int); int CDECL lame_set_VBR_mean_bitrate_kbps(lame_global_flags *, int);
int CDECL lame_get_VBR_mean_bitrate_kbps(const lame_global_flags *); int CDECL lame_get_VBR_mean_bitrate_kbps(const lame_global_flags *);
int CDECL lame_set_VBR_min_bitrate_kbps(lame_global_flags *, int); int CDECL lame_set_VBR_min_bitrate_kbps(lame_global_flags *, int);
int CDECL lame_get_VBR_min_bitrate_kbps(const lame_global_flags *); int CDECL lame_get_VBR_min_bitrate_kbps(const lame_global_flags *);
int CDECL lame_set_VBR_max_bitrate_kbps(lame_global_flags *, int); int CDECL lame_set_VBR_max_bitrate_kbps(lame_global_flags *, int);
int CDECL lame_get_VBR_max_bitrate_kbps(const lame_global_flags *); int CDECL lame_get_VBR_max_bitrate_kbps(const lame_global_flags *);
/* /*
1=strictly enforce VBR_min_bitrate. Normally it will be violated for 1=strictly enforce VBR_min_bitrate. Normally it will be violated for
analog silence analog silence
*/ */
int CDECL lame_set_VBR_hard_min(lame_global_flags *, int); int CDECL lame_set_VBR_hard_min(lame_global_flags *, int);
int CDECL lame_get_VBR_hard_min(const lame_global_flags *); int CDECL lame_get_VBR_hard_min(const lame_global_flags *);
/* for preset */ /* for preset */
int CDECL lame_set_preset_expopts(lame_global_flags *, int); int CDECL lame_set_preset_expopts(lame_global_flags *, int);
int CDECL lame_set_preset_notune(lame_global_flags *, int);
/******************************************************************** /********************************************************************
* Filtering control * Filtering control
***********************************************************************/ ***********************************************************************/
/* freq in Hz to apply lowpass. Default = 0 = lame chooses. -1 = disabled */ /* freq in Hz to apply lowpass. Default = 0 = lame chooses. -1 = disabled */
int CDECL lame_set_lowpassfreq(lame_global_flags *, int); int CDECL lame_set_lowpassfreq(lame_global_flags *, int);
int CDECL lame_get_lowpassfreq(const lame_global_flags *); int CDECL lame_get_lowpassfreq(const lame_global_flags *);
/* width of transition band, in Hz. Default = one polyphase filter band */ /* width of transition band, in Hz. Default = one polyphase filter band */
int CDECL lame_set_lowpasswidth(lame_global_flags *, int); int CDECL lame_set_lowpasswidth(lame_global_flags *, int);
int CDECL lame_get_lowpasswidth(const lame_global_flags *); int CDECL lame_get_lowpasswidth(const lame_global_flags *);
skipping to change at line 390 skipping to change at line 449
int CDECL lame_get_ATHtype(const lame_global_flags *); int CDECL lame_get_ATHtype(const lame_global_flags *);
/* lower ATH by this many db */ /* lower ATH by this many db */
int CDECL lame_set_ATHlower(lame_global_flags *, float); int CDECL lame_set_ATHlower(lame_global_flags *, float);
float CDECL lame_get_ATHlower(const lame_global_flags *); float CDECL lame_get_ATHlower(const lame_global_flags *);
/* select ATH adaptive adjustment type */ /* select ATH adaptive adjustment type */
int CDECL lame_set_athaa_type( lame_global_flags *, int); int CDECL lame_set_athaa_type( lame_global_flags *, int);
int CDECL lame_get_athaa_type( const lame_global_flags *); int CDECL lame_get_athaa_type( const lame_global_flags *);
/* select the loudness approximation used by the ATH adaptive auto-leveling */ /* select the loudness approximation used by the ATH adaptive auto-leveling */
int CDECL lame_set_athaa_loudapprox( lame_global_flags *, int); int CDECL lame_set_athaa_loudapprox( lame_global_flags *, int);
int CDECL lame_get_athaa_loudapprox( const lame_global_flags *); int CDECL lame_get_athaa_loudapprox( const lame_global_flags *);
/* adjust (in dB) the point below which adaptive ATH level adjustment occur s */ /* adjust (in dB) the point below which adaptive ATH level adjustment occur s */
int CDECL lame_set_athaa_sensitivity( lame_global_flags *, float); int CDECL lame_set_athaa_sensitivity( lame_global_flags *, float);
float CDECL lame_get_athaa_sensitivity( const lame_global_flags* ); float CDECL lame_get_athaa_sensitivity( const lame_global_flags* );
/* predictability limit (ISO tonality formula) */ /* predictability limit (ISO tonality formula) */
int CDECL lame_set_cwlimit(lame_global_flags *, int); int CDECL lame_set_cwlimit(lame_global_flags *, int);
int CDECL lame_get_cwlimit(const lame_global_flags *); int CDECL lame_get_cwlimit(const lame_global_flags *);
/* /*
allow blocktypes to differ between channels? allow blocktypes to differ between channels?
default: 0 for jstereo, 1 for stereo default: 0 for jstereo, 1 for stereo
*/ */
int CDECL lame_set_allow_diff_short(lame_global_flags *, int); int CDECL lame_set_allow_diff_short(lame_global_flags *, int);
int CDECL lame_get_allow_diff_short(const lame_global_flags *); int CDECL lame_get_allow_diff_short(const lame_global_flags *);
/* use temporal masking effect (default = 1) */ /* use temporal masking effect (default = 1) */
int CDECL lame_set_useTemporal(lame_global_flags *, int); int CDECL lame_set_useTemporal(lame_global_flags *, int);
int CDECL lame_get_useTemporal(const lame_global_flags *); int CDECL lame_get_useTemporal(const lame_global_flags *);
/* use temporal masking effect (default = 1) */ /* use temporal masking effect (default = 1) */
int CDECL lame_set_interChRatio(lame_global_flags *, float); int CDECL lame_set_interChRatio(lame_global_flags *, float);
float CDECL lame_get_interChRatio(const lame_global_flags *); float CDECL lame_get_interChRatio(const lame_global_flags *);
/* substep shaping method */
int CDECL lame_set_substep(lame_global_flags *, int);
int CDECL lame_get_substep(const lame_global_flags *);
/* disable short blocks */ /* disable short blocks */
int CDECL lame_set_no_short_blocks(lame_global_flags *, int); int CDECL lame_set_no_short_blocks(lame_global_flags *, int);
int CDECL lame_get_no_short_blocks(const lame_global_flags *); int CDECL lame_get_no_short_blocks(const lame_global_flags *);
/* force short blocks */ /* force short blocks */
int CDECL lame_set_force_short_blocks(lame_global_flags *, int); int CDECL lame_set_force_short_blocks(lame_global_flags *, int);
int CDECL lame_get_force_short_blocks(const lame_global_flags *); int CDECL lame_get_force_short_blocks(const lame_global_flags *);
/* Input PCM is emphased PCM (for instance from one of the rarely /* Input PCM is emphased PCM (for instance from one of the rarely
emphased CDs), it is STRONGLY not recommended to use this, because emphased CDs), it is STRONGLY not recommended to use this, because
psycho does not take it into account, and last but not least many decode rs psycho does not take it into account, and last but not least many decode rs
ignore these bits */ ignore these bits */
int CDECL lame_set_emphasis(lame_global_flags *, int); int CDECL lame_set_emphasis(lame_global_flags *, int);
int CDECL lame_get_emphasis(const lame_global_flags *); int CDECL lame_get_emphasis(const lame_global_flags *);
/************************************************************************/ /************************************************************************/
/* internal variables, cannot be set... */ /* internal variables, cannot be set... */
/* provided because they may be of use to calling application */ /* provided because they may be of use to calling application */
/************************************************************************/ /************************************************************************/
/* version 0=MPEG-2 1=MPEG-1 (2=MPEG-2.5) */ /* version 0=MPEG-2 1=MPEG-1 (2=MPEG-2.5) */
int CDECL lame_get_version(const lame_global_flags *); int CDECL lame_get_version(const lame_global_flags *);
/* encoder delay */ /* encoder delay */
int CDECL lame_get_encoder_delay(const lame_global_flags *); int CDECL lame_get_encoder_delay(const lame_global_flags *);
/* /*
padding appended to the input to make sure decoder can fully decode padding appended to the input to make sure decoder can fully decode
all input. Note that this value can only be calculated during the all input. Note that this value can only be calculated during the
call to lame_encoder_flush(). Before lame_encoder_flush() has call to lame_encoder_flush(). Before lame_encoder_flush() has
been called, the value of encoder_padding = 0. been called, the value of encoder_padding = 0.
*/ */
int CDECL lame_get_encoder_padding(const lame_global_flags *); int CDECL lame_get_encoder_padding(const lame_global_flags *);
/* size of MPEG frame */ /* size of MPEG frame */
int CDECL lame_get_framesize(const lame_global_flags *); int CDECL lame_get_framesize(const lame_global_flags *);
/* number of PCM samples buffered, but not yet encoded to mp3 data. */ /* number of PCM samples buffered, but not yet encoded to mp3 data. */
int CDECL lame_get_mf_samples_to_encode( const lame_global_flags* gfp ); int CDECL lame_get_mf_samples_to_encode( const lame_global_flags* gfp );
/* /*
size (bytes) of mp3 data buffered, but not yet encoded. size (bytes) of mp3 data buffered, but not yet encoded.
this is the number of bytes which would be output by a call to this is the number of bytes which would be output by a call to
lame_encode_flush_nogap. NOTE: lame_encode_flush() will return lame_encode_flush_nogap. NOTE: lame_encode_flush() will return
more bytes than this because it will encode the reamining buffered more bytes than this because it will encode the reamining buffered
PCM samples before flushing the mp3 buffers. PCM samples before flushing the mp3 buffers.
*/ */
int CDECL lame_get_size_mp3buffer( const lame_global_flags* gfp ); int CDECL lame_get_size_mp3buffer( const lame_global_flags* gfp );
/* number of frames encoded so far */ /* number of frames encoded so far */
int CDECL lame_get_frameNum(const lame_global_flags *); int CDECL lame_get_frameNum(const lame_global_flags *);
/* /*
lame's estimate of the total number of frames to be encoded lame's estimate of the total number of frames to be encoded
only valid if calling program set num_samples only valid if calling program set num_samples
*/ */
int CDECL lame_get_totalframes(const lame_global_flags *); int CDECL lame_get_totalframes(const lame_global_flags *);
/* RadioGain value */
int CDECL lame_get_RadioGain(const lame_global_flags *);
/* AudiophileGain value */
int CDECL lame_get_AudiophileGain(const lame_global_flags *);
#ifdef DECODE_ON_THE_FLY
/* the peak sample */
float CDECL lame_get_PeakSample(const lame_global_flags *);
/* is decoding on the fly going to be performed */
int CDECL lame_get_decode_on_the_fly(const lame_global_flags *);
#endif
/* /*
* REQUIRED: * REQUIRED:
* sets more internal configuration based on data provided above. * sets more internal configuration based on data provided above.
* returns -1 if something failed. * returns -1 if something failed.
*/ */
int CDECL lame_init_params(lame_global_flags * const ); int CDECL lame_init_params(lame_global_flags * const );
/* /*
* OPTIONAL: * OPTIONAL:
* get the version number, in a string. of the form: * get the version number, in a string. of the form:
skipping to change at line 535 skipping to change at line 604
/* /*
* input pcm data, output (maybe) mp3 frames. * input pcm data, output (maybe) mp3 frames.
* This routine handles all buffering, resampling and filtering for you. * This routine handles all buffering, resampling and filtering for you.
* *
* return code number of bytes output in mp3buf. Can be 0 * return code number of bytes output in mp3buf. Can be 0
* -1: mp3buf was too small * -1: mp3buf was too small
* -2: malloc() problem * -2: malloc() problem
* -3: lame_init_params() not called * -3: lame_init_params() not called
* -4: psycho acoustic problems * -4: psycho acoustic problems
* -5: ogg cleanup encoding error
* -6: ogg frame encoding error
* *
* The required mp3buf_size can be computed from num_samples, * The required mp3buf_size can be computed from num_samples,
* samplerate and encoding rate, but here is a worst case estimate: * samplerate and encoding rate, but here is a worst case estimate:
* *
* mp3buf_size in bytes = 1.25*num_samples + 7200 * mp3buf_size in bytes = 1.25*num_samples + 7200
* *
* I think a tighter bound could be: (mt, March 2000) * I think a tighter bound could be: (mt, March 2000)
* MPEG1: * MPEG1:
* num_samples*(bitrate/8)/samplerate + 4*1152*(bitrate/8)/samplerate + 512 * num_samples*(bitrate/8)/samplerate + 4*1152*(bitrate/8)/samplerate + 512
* MPEG2: * MPEG2:
skipping to change at line 756 skipping to change at line 823
/* /*
* REQUIRED: * REQUIRED:
* final call to free all remaining buffers * final call to free all remaining buffers
*/ */
int CDECL lame_close (lame_global_flags *); int CDECL lame_close (lame_global_flags *);
/* /*
* OBSOLETE: * OBSOLETE:
* lame_encode_finish combines lame_encode_flush() and lame_close() in * lame_encode_finish combines lame_encode_flush() and lame_close() in
* one call. However, once this call is made, the statistics routines * one call. However, once this call is made, the statistics routines
* will no longer work because the data will have been cleared * will no longer work because the data will have been cleared, and
* lame_mp3_tags_fid() cannot be called to add data to the VBR header
*/ */
int CDECL lame_encode_finish( int CDECL lame_encode_finish(
lame_global_flags* gfp, lame_global_flags* gfp,
unsigned char* mp3buf, unsigned char* mp3buf,
int size ); int size );
/********************************************************************* /*********************************************************************
* *
* decoding * decoding
* *
skipping to change at line 789 skipping to change at line 857
int framesize; /* number of samples per mp3 frame */ int framesize; /* number of samples per mp3 frame */
/* this data is only computed if mpglib detects a Xing VBR header */ /* this data is only computed if mpglib detects a Xing VBR header */
unsigned long nsamp; /* number of samples in mp3 file. */ unsigned long nsamp; /* number of samples in mp3 file. */
int totalframes; /* total number of frames in mp3 file */ int totalframes; /* total number of frames in mp3 file */
/* this data is not currently computed by the mpglib routines */ /* this data is not currently computed by the mpglib routines */
int framenum; /* frames decoded counter */ int framenum; /* frames decoded counter */
} mp3data_struct; } mp3data_struct;
/* required call to initialize decoder */ /* required call to initialize decoder
* NOTE: the decoder should not be used when encoding is performed
* with decoding on the fly */
int CDECL lame_decode_init(void); int CDECL lame_decode_init(void);
/********************************************************************* /*********************************************************************
* input 1 mp3 frame, output (maybe) pcm data. * input 1 mp3 frame, output (maybe) pcm data.
* *
* nout = lame_decode(mp3buf,len,pcm_l,pcm_r); * nout = lame_decode(mp3buf,len,pcm_l,pcm_r);
* *
* input: * input:
* len : number of bytes of mp3 data in mp3buf * len : number of bytes of mp3 data in mp3buf
* mp3buf[len] : mp3 data to be decoded * mp3buf[len] : mp3 data to be decoded
skipping to change at line 939 skipping to change at line 1009
* 2: MPEG-2.5 values (sample frequencies 8...12 kHz) * 2: MPEG-2.5 values (sample frequencies 8...12 kHz)
***********************************************************************/ ***********************************************************************/
extern const int bitrate_table [3] [16]; extern const int bitrate_table [3] [16];
extern const int samplerate_table [3] [ 4]; extern const int samplerate_table [3] [ 4];
/* maximum size of mp3buffer needed if you encode at most 1152 samples for /* maximum size of mp3buffer needed if you encode at most 1152 samples for
each call to lame_encode_buffer. see lame_encode_buffer() below each call to lame_encode_buffer. see lame_encode_buffer() below
(LAME_MAXMP3BUFFER is now obsolete) */ (LAME_MAXMP3BUFFER is now obsolete) */
#define LAME_MAXMP3BUFFER 16384 #define LAME_MAXMP3BUFFER 16384
typedef enum {
LAME_OKAY = 0,
LAME_NOERROR = 0,
LAME_GENERICERROR = -1,
LAME_NOMEM = -10,
LAME_BADBITRATE = -11,
LAME_BADSAMPFREQ = -12,
LAME_INTERNALERROR = -13,
FRONTEND_READERROR = -80,
FRONTEND_WRITEERROR = -81,
FRONTEND_FILETOOLARGE = -82
} lame_errorcodes_t;
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif #endif
#endif /* LAME_LAME_H */ #endif /* LAME_LAME_H */
 End of changes. 38 change blocks. 
70 lines changed or deleted 155 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/