ref: 19cc46bc5ee1dd43537c4094d19d8da778b72bce
dir: /sys/src/cmd/audio/mp3enc/set_get.c/
/* -*- 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.2 2001/03/12 04:38:35 markt Exp $ */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <assert.h>
#include "lame.h"
#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 didn'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;
}
/* 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;
}
/* disable writing a wave header with *decoding* */
int
lame_set_disable_waveheader( lame_global_flags* gfp,
int disable_waveheader )
{
/* 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_waveheader || 1 < disable_waveheader )
return -1;
gfp->disable_waveheader = disable_waveheader;
return 0;
}
int
lame_get_disable_waveheader( const lame_global_flags* gfp )
{
assert( 0 <= gfp->disable_waveheader && 1 >= gfp->disable_waveheader );
return gfp->disable_waveheader;
}
/* 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_ms. Force M/S for all frames. For testing only.
// default = 0 (disabled)
int
lame_set_force_ms( lame_global_flags* gfp,
int force_ms );
int
lame_get_force_ms( const lame_global_flags* gfp );
// use free_format? default = 0 (disabled)
int
lame_set_free_format( lame_global_flags* gfp,
int free_format );
int
lame_get_free_format( const lame_global_flags* gfp );
/* 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 );
int
lame_get_brate( const lame_global_flags* gfp );
int
lame_set_compression_ratio( lame_global_flags* gfp,
float compression_ratio );
float
lame_get_compression_ratio( const lame_global_flags* gfp );
/*
* frame parameters
*/
// mark as copyright. default=0
int
lame_set_copyright( lame_global_flags* gfp,
int copyright );
int
lame_get_copyright( const lame_global_flags* gfp );
// mark as original. default=1
int
lame_set_original( lame_global_flags* gfp,
int original );
int
lame_get_original( const lame_global_flags* gfp );
// error_protection. Use 2 bytes from each fraome for CRC checksum. default=0
int
lame_set_error_protection( lame_global_flags* gfp,
int error_protection );
int
lame_get_error_protection( const lame_global_flags* gfp );
// padding_type. 0=pad no frames 1=pad all frames 2=adjust padding(default)
int
lame_set_padding_type( lame_global_flags* gfp,
int padding_type );
int
lame_get_padding_type( const lame_global_flags* gfp );
// MP3 'private extension' bit Meaningless
int
lame_set_extension( lame_global_flags* gfp,
int extension );
int
lame_get_extension( const lame_global_flags* gfp );
// enforce strict ISO compliance. default=0
int
lame_set_strict_ISO( lame_global_flags* gfp,
int strict_ISO );
int
lame_get_strict_ISO( const lame_global_flags* gfp );
/********************************************************************
* quantization/noise shaping
***********************************************************************/
// disable the bit reservoir. For testing only. default=0
int
lame_set_disable_reservoir( lame_global_flags* gfp,
int disable_reservoir );
int
lame_get_disable_reservoir( const lame_global_flags* gfp );
// select a different "best quantization" function. default=0
int
lame_set_experimentalX( lame_global_flags* gfp,
int experimentalX );
int
lame_get_experimentalX( const lame_global_flags* gfp );
// another experimental option. for testing only
int
lame_set_experimentalY( lame_global_flags* gfp,
int experimentalY );
int
lame_get_experimentalY( const lame_global_flags* gfp );
// another experimental option. for testing only
int
lame_set_experimentalZ( lame_global_flags* gfp,
int experimentalZ );
int
lame_get_experimentalZ( const lame_global_flags* gfp );
// Naoki's psycho acoustic model. default=0
int
lame_set_exp_nspsytune( lame_global_flags* gfp,
int exp_nspsytune );
int
lame_get_exp_nspsytune( const lame_global_flags* gfp );
/********************************************************************
* VBR control
***********************************************************************/
// Types of VBR. default = vbr_off = CBR
int
lame_set_VBR( lame_global_flags* gfp,
vbr_mode VBR );
vbr_mode
lame_get_exp_VBR( const lame_global_flags* gfp );
// VBR quality level. 0=highest 9=lowest
int
lame_set_VBR_q( lame_global_flags* gfp,
int VBR_q );
int
lame_get_VBR_q( const lame_global_flags* gfp );
// Ignored except for VBR=vbr_abr (ABR mode)
int
lame_set_VBR_mean_bitrate_kbps( lame_global_flags* gfp,
int VBR_mean_bitrate_kbps );
int
lame_get_VBR_mean_bitrate_kbps( const lame_global_flags* gfp );
int
lame_set_VBR_min_bitrate_kbps( lame_global_flags* gfp,
int VBR_min_bitrate_kbps );
int
lame_get_VBR_min_bitrate_kbps( const lame_global_flags* gfp );
int
lame_set_VBR_max_bitrate_kbps( lame_global_flags* gfp,
int VBR_max_bitrate_kbps );
int
lame_get_VBR_max_bitrate_kbps( const lame_global_flags* gfp );
// 1=stricetly 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 );
int
lame_get_VBR_hard_min( const lame_global_flags* gfp );
/********************************************************************
* Filtering control
***********************************************************************/
// freq in Hz to apply lowpass. Default = 0 = lame chooses. -1 = disabled
int
lame_set_lowpassfreq( lame_global_flags* gfp,
int lowpassfreq );
int
lame_get_lowpassfreq( const lame_global_flags* gfp );
// width of transition band, in Hz. Default = one polyphase filter band
int
lame_set_lowpasswidth( lame_global_flags* gfp,
int lowpasswidth );
int
lame_get_lowpasswidth( const lame_global_flags* gfp );
// freq in Hz to apply highpass. Default = 0 = lame chooses. -1 = disabled
int
lame_set_highpassfreq( lame_global_flags* gfp,
int highpassfreq );
int
lame_get_highpassfreq( const lame_global_flags* gfp );
// width of transition band, in Hz. Default = one polyphase filter band
int
lame_set_highpasswidth( lame_global_flags* gfp,
int highpasswidth );
int
lame_get_highpasswidth( const lame_global_flags* gfp );
/*
* 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 );
int
lame_get_ATHonly( const lame_global_flags* gfp );
// only use ATH for short blocks
int
lame_set_ATHshort( lame_global_flags* gfp,
int ATHshort );
int
lame_get_ATHshort( const lame_global_flags* gfp );
// disable ATH
int
lame_set_noATH( lame_global_flags* gfp,
int noATH );
int
lame_get_noATH( const lame_global_flags* gfp );
// select ATH formula
int
lame_set_ATHtype( lame_global_flags* gfp,
int ATHtype );
int
lame_get_ATHtype( const lame_global_flags* gfp );
// lower ATH by this many db
int
lame_set_ATHlower( lame_global_flags* gfp,
float ATHlower );
float
lame_get_ATHlower( const lame_global_flags* gfp );
// predictability limit (ISO tonality formula)
int
lame_set_cwlimit( lame_global_flags* gfp,
int cwlimit );
int
lame_get_cwlimit( const lame_global_flags* gfp );
// allow blocktypes to differ between channels?
// default: 0 for jstereo, 1 for stereo
int
lame_set_allow_diff_short( lame_global_flags* gfp,
int allow_diff_short );
int
lame_get_allow_diff_short( const lame_global_flags* gfp );
// use temporal masking effect (default = 1)
int
lame_set_useTemporal( lame_global_flags* gfp,
int useTemporal );
int
lame_get_useTemporal( const lame_global_flags* gfp );
// disable short blocks
int
lame_set_no_short_blocks( lame_global_flags* gfp,
int no_short_blocks );
int
lame_get_no_short_blocks( const lame_global_flags* gfp );
/* 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 );
int
lame_get_emphasis( const lame_global_flags* gfp );
/***************************************************************/
/* internal variables, cannot be set... */
/* provided because they may be of use to calling application */
/***************************************************************/
// version 0=MPEG-2 1=MPEG-1 (2=MPEG-2.5)
int
lame_get_version( const lame_global_flags* gfp );
// encoder delay
int
lame_get_encoder_delay( const lame_global_flags* gfp );
// size of MPEG frame
int
lame_get_framesize( const lame_global_flags* gfp );
// number of frames encoded so far
int
lame_get_frameNum( const lame_global_flags* gfp );
// 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 );