/* set/get functions for lame_global_flags
* Copyright (c) 2001-2005 Alexander Leidinger
*/
#include "lame.h"
#include "machine.h"
#include "encoder.h"
#include "util.h"
#include "bitstream.h" /* because of compute_flushbits */
#include "set_get.h"
#include "lame_global_flags.h"
/*
* input stream description
*/
#define FUNC(r,n) r n
/* number of samples */
/* it's unlikely for this function to return an error */
FUNC(int,lame_set_num_samples) (lame_global_flags&L, unsigned long n) {
if (!L.is_valid()) return -1;
L.set_num_samples(n); /* default = 2^32-1 */
return 0;
}
FUNC(unsigned long,lame_get_num_samples) (const lame_global_flags&L) {
if (!L.is_valid()) return 0;
return L.get_num_samples();
}
/* input samplerate */
FUNC(int,lame_set_in_samplerate) (lame_global_flags&L,int n) {
if (!L.is_valid()) return -1;
if (n < 1) return -1;
/* input sample rate in Hz, default = 44100 Hz */
L.set_in_samplerate(n);
return 0;
}
FUNC(int,lame_get_in_samplerate) (const lame_global_flags&L) {
if (!L.is_valid()) return 0;
return L.get_in_samplerate();
}
/* number of channels in input stream */
FUNC(int,lame_set_num_channels) (lame_global_flags&L,int n) {
if (!L.is_valid()) return -1;
if (n<1) return -1;
if (n>2) return -1; /* default = 2 */
L.set_num_channels(n);
return 0;
}
FUNC(int,lame_get_num_channels) (const lame_global_flags&L) {
if (!L.is_valid()) return 0;
return L.get_num_channels();
}
/* scale the input by this amount before encoding (not used for decoding) */
FUNC(int,lame_set_scale) (lame_global_flags&L,float v) {
if (!L.is_valid()) return -1;
L.set_scale(v); /* default = 1 */
return 0;
}
FUNC(float,lame_get_scale) (const lame_global_flags&L) {
if (!L.is_valid()) return 0;
return L.get_scale();
}
/* scale the channel 0 (left) input by this amount before
encoding (not used for decoding) */
int lame_global_flags::lame_set_scale_left(float v) {
if (is_valid()) {
/* default = 1 */
scale_left = v;
return 0;
}
return -1;
}
float lame_global_flags::lame_get_scale_left() const {
if (is_valid()) return scale_left;
return 0;
}
/* scale the channel 1 (right) input by this amount before
encoding (not used for decoding) */
int lame_global_flags::lame_set_scale_right(float v) {
if (is_valid()) {
/* default = 1 */
scale_right = v;
return 0;
}
return -1;
}
float lame_global_flags::lame_get_scale_right() const {
if (is_valid()) return scale_right;
return 0;
}
/* output sample rate in Hz */
FUNC(int,lame_set_out_samplerate) (lame_global_flags&L,int n) {
if (!L.is_valid()) return -1;
/*
* 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)
*/
if (n && SmpFrqIndex(n)<0) return -1;
L.set_out_samplerate(n);
return 0;
}
FUNC(int,lame_get_out_samplerate) (const lame_global_flags&L) {
if (!L.is_valid()) return 0;
return L.get_out_samplerate();
}
/*
* general control parameters
*/
/* collect data for an MP3 frame analzyer */
int
lame_set_analysis(lame_global_flags & gfp, int analysis)
{
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int
lame_get_analysis(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(0 <= gfp.analysis && 1 >= gfp.analysis);
return gfp.analysis;
}
return 0;
}
/* write a Xing VBR header frame */
int lame_set_bWriteVbrTag(lame_global_flags & gfp, int bWriteVbrTag)
{
if (gfp.is_valid()) {
/* 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.write_lame_tag = bWriteVbrTag;
return 0;
}
return -1;
}
int lame_get_bWriteVbrTag(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(0 <= gfp.write_lame_tag && 1 >= gfp.write_lame_tag);
return gfp.write_lame_tag;
}
return 0;
}
/* decode only, use lame/mpglib to convert mp3 to wav */
int lame_set_decode_only(lame_global_flags & gfp, int decode_only)
{
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int lame_get_decode_only(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(0 <= gfp.decode_only && 1 >= gfp.decode_only);
return gfp.decode_only;
}
return 0;
}
/* 1=encode a Vorbis .ogg file. default=0 */
int lame_set_ogg(lame_global_flags &, int)
{
return -1;
}
int lame_get_ogg(const lame_global_flags &)
{
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)
{
if (gfp.is_valid()) {
if (quality < 0) {
gfp.quality = 0;
}
else if (quality > 9) {
gfp.quality = 9;
}
else {
gfp.quality = quality;
}
return 0;
}
return -1;
}
int
lame_get_quality(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.quality;
}
return 0;
}
/* mode = STEREO, JOINT_STEREO, DUAL_CHANNEL (not supported), MONO */
int
lame_set_mode(lame_global_flags & gfp, MPEG_mode mode)
{
if (gfp.is_valid()) {
int mpg_mode = mode;
/* default: lame chooses based on compression ratio and input channels */
if (mpg_mode < 0 || MAX_INDICATOR <= mpg_mode)
return -1; /* Unknown MPEG mode! */
gfp.mode = mode;
return 0;
}
return -1;
}
MPEG_mode
lame_get_mode(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(gfp.mode < MAX_INDICATOR);
return gfp.mode;
}
return NOT_SET;
}
/* 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)
{
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int lame_get_mode_automs(const lame_global_flags & gfp) {
(void) 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) {
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int lame_get_force_ms(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
assert(0 <= gfp.force_ms && 1 >= gfp.force_ms);
return gfp.force_ms;
}
return 0;
}
/* Use free_format. */
int lame_set_free_format(lame_global_flags & gfp, int free_format) {
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int lame_get_free_format(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
assert(0 <= gfp.free_format && 1 >= gfp.free_format);
return gfp.free_format;
}
return 0;
}
/* Perform ReplayGain analysis */
int lame_set_findReplayGain(lame_global_flags & gfp, int findReplayGain) {
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int lame_get_findReplayGain(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
assert(0 <= gfp.findReplayGain && 1 >= gfp.findReplayGain);
return gfp.findReplayGain;
}
return 0;
}
/* 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) {
if (gfp.is_valid()) {
#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
}
return -1;
}
int
lame_get_decode_on_the_fly(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(0 <= gfp.decode_on_the_fly && 1 >= gfp.decode_on_the_fly);
return gfp.decode_on_the_fly;
}
return 0;
}
/* DEPRECATED: now does the same as lame_set_findReplayGain()
default = 0 (disabled) */
/* DEPRECATED: now does the same as
lame_set_decode_on_the_fly() && lame_set_findReplayGain()
default = 0 (disabled) */
/* DEPRECATED: now does the same as lame_set_decode_on_the_fly()
default = 0 (disabled) */
/* 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)
{
if (gfp.is_valid()) {
gfp.nogap_total = the_nogap_total;
return 0;
}
return -1;
}
int
lame_get_nogap_total(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.nogap_total;
}
return 0;
}
int
lame_set_nogap_currentindex(lame_global_flags & gfp, int the_nogap_index)
{
if (gfp.is_valid()) {
gfp.nogap_current = the_nogap_index;
return 0;
}
return -1;
}
int
lame_get_nogap_currentindex(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.nogap_current;
}
return 0;
}
/* message handlers */
int
lame_set_errorf(lame_global_flags & gfp, void (*func) (const char *, va_list))
{
if (gfp.is_valid()) {
gfp.report.errorf = func;
return 0;
}
return -1;
}
int
lame_set_debugf(lame_global_flags & gfp, void (*func) (const char *, va_list))
{
if (gfp.is_valid()) {
gfp.report.debugf = func;
return 0;
}
return -1;
}
int
lame_set_msgf(lame_global_flags & gfp, void (*func) (const char *, va_list))
{
if (gfp.is_valid()) {
gfp.report.msgf = func;
return 0;
}
return -1;
}
/*
* Set one of
* - brate
* - compression ratio.
*
* Default is compression ratio of 11.
*/
int
lame_set_brate(lame_global_flags & gfp, int brate)
{
if (gfp.is_valid()) {
gfp.brate = brate;
if (brate > 320) {
gfp.disable_reservoir = 1;
}
return 0;
}
return -1;
}
int
lame_get_brate(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.brate;
}
return 0;
}
int
lame_set_compression_ratio(lame_global_flags & gfp, float compression_ratio)
{
if (gfp.is_valid()) {
gfp.compression_ratio = compression_ratio;
return 0;
}
return -1;
}
float
lame_get_compression_ratio(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.compression_ratio;
}
return 0;
}
/*
* frame parameters
*/
/* Mark as copyright protected. */
int
lame_set_copyright(lame_global_flags & gfp, int copyright)
{
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int
lame_get_copyright(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(0 <= gfp.copyright && 1 >= gfp.copyright);
return gfp.copyright;
}
return 0;
}
/* Mark as original. */
int
lame_set_original(lame_global_flags & gfp, int original)
{
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int
lame_get_original(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(0 <= gfp.original && 1 >= gfp.original);
return gfp.original;
}
return 0;
}
/*
* error_protection.
* Use 2 bytes from each frame for CRC checksum.
*/
int
lame_set_error_protection(lame_global_flags & gfp, int error_protection)
{
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int
lame_get_error_protection(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(0 <= gfp.error_protection && 1 >= gfp.error_protection);
return gfp.error_protection;
}
return 0;
}
/*
* 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)
{
(void) gfp;
(void) padding_type;
return 0;
}
Padding_type lame_get_padding_type(const lame_global_flags & gfp)
{
(void) gfp;
return PAD_ADJUST;
}
/* MP3 'private extension' bit. Meaningless. */
int
lame_set_extension(lame_global_flags & gfp, int extension)
{
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int lame_get_extension(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(0 <= gfp.extension && 1 >= gfp.extension);
return gfp.extension;
}
return 0;
}
/* Enforce strict ISO compliance. */
int lame_set_strict_ISO(lame_global_flags & gfp, int val)
{
if (gfp.is_valid()) {
/* 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 (val < MDB_DEFAULT || MDB_MAXIMUM < val)
return -1;
gfp.strict_ISO = val;
return 0;
}
return -1;
}
int
lame_get_strict_ISO(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.strict_ISO;
}
return 0;
}
/********************************************************************
* quantization/noise shaping
***********************************************************************/
/* Disable the bit reservoir. For testing only. */
int lame_set_disable_reservoir(lame_global_flags & gfp, int disable_reservoir)
{
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int lame_get_disable_reservoir(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(0 <= gfp.disable_reservoir && 1 >= gfp.disable_reservoir);
return gfp.disable_reservoir;
}
return 0;
}
int lame_set_experimentalX(lame_global_flags & gfp, int experimentalX)
{
if (gfp.is_valid()) {
lame_set_quant_comp(gfp, experimentalX);
lame_set_quant_comp_short(gfp, experimentalX);
return 0;
}
return -1;
}
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)
{
if (gfp.is_valid()) {
gfp.quant_comp = quant_type;
return 0;
}
return -1;
}
int
lame_get_quant_comp(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.quant_comp;
}
return 0;
}
/* Select a different "best quantization" function. default = 0 */
int lame_set_quant_comp_short(lame_global_flags & gfp, int quant_type)
{
if (gfp.is_valid()) {
gfp.quant_comp_short = quant_type;
return 0;
}
return -1;
}
int
lame_get_quant_comp_short(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.quant_comp_short;
}
return 0;
}
/* Another experimental option. For testing only. */
int lame_set_experimentalY(lame_global_flags & gfp, int experimentalY)
{
if (gfp.is_valid()) {
gfp.experimentalY = experimentalY;
return 0;
}
return -1;
}
int
lame_get_experimentalY(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.experimentalY;
}
return 0;
}
int lame_set_experimentalZ(lame_global_flags & gfp, int experimentalZ)
{
if (gfp.is_valid()) {
gfp.experimentalZ = experimentalZ;
return 0;
}
return -1;
}
int
lame_get_experimentalZ(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.experimentalZ;
}
return 0;
}
/* Naoki's psycho acoustic model. */
int lame_set_exp_nspsytune(lame_global_flags & gfp, int exp_nspsytune)
{
if (gfp.is_valid()) {
/* default = 0 (disabled) */
gfp.exp_nspsytune = exp_nspsytune;
return 0;
}
return -1;
}
int
lame_get_exp_nspsytune(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.exp_nspsytune;
}
return 0;
}
/********************************************************************
* VBR control
***********************************************************************/
/* Types of VBR. default = vbr_off = CBR */
int lame_set_VBR(lame_global_flags & gfp, vbr_mode VBR)
{
if (gfp.is_valid()) {
int vbr_q = VBR;
if (0 > vbr_q || vbr_max_indicator <= vbr_q)
return -1; /* Unknown VBR mode! */
gfp.VBR = VBR;
return 0;
}
return -1;
}
vbr_mode lame_get_VBR(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(gfp.VBR < vbr_max_indicator);
return gfp.VBR;
}
return vbr_off;
}
/*
* VBR quality level.
* 0 = highest
* 9 = lowest
*/
int lame_set_VBR_q(lame_global_flags & gfp, int VBR_q)
{
if (gfp.is_valid()) {
int ret = 0;
if (0 > VBR_q) {
ret = -1; /* Unknown VBR quality level! */
VBR_q = 0;
}
if (9 < VBR_q) {
ret = -1;
VBR_q = 9;
}
gfp.VBR_q = VBR_q;
gfp.VBR_q_frac = 0;
return ret;
}
return -1;
}
int lame_get_VBR_q(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(0 <= gfp.VBR_q && 10 > gfp.VBR_q);
return gfp.VBR_q;
}
return 0;
}
int
lame_set_VBR_quality(lame_global_flags & gfp, float VBR_q)
{
if (gfp.is_valid()) {
int ret = 0;
if (0 > VBR_q) {
ret = -1; /* Unknown VBR quality level! */
VBR_q = 0;
}
if (9.999 < VBR_q) {
ret = -1;
VBR_q = 9.999;
}
gfp.VBR_q = (int) VBR_q;
gfp.VBR_q_frac = VBR_q - gfp.VBR_q;
return ret;
}
return -1;
}
float lame_get_VBR_quality(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.VBR_q + gfp.VBR_q_frac;
}
return 0;
}
/* Ignored except for VBR = vbr_abr (ABR mode) */
int
lame_set_VBR_mean_bitrate_kbps(lame_global_flags & gfp, int VBR_mean_bitrate_kbps)
{
if (gfp.is_valid()) {
gfp.VBR_mean_bitrate_kbps = VBR_mean_bitrate_kbps;
return 0;
}
return -1;
}
int lame_get_VBR_mean_bitrate_kbps(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.VBR_mean_bitrate_kbps;
}
return 0;
}
int
lame_set_VBR_min_bitrate_kbps(lame_global_flags & gfp, int VBR_min_bitrate_kbps)
{
if (gfp.is_valid()) {
gfp.VBR_min_bitrate_kbps = VBR_min_bitrate_kbps;
return 0;
}
return -1;
}
int lame_get_VBR_min_bitrate_kbps(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.VBR_min_bitrate_kbps;
}
return 0;
}
int lame_set_VBR_max_bitrate_kbps(lame_global_flags & gfp, int VBR_max_bitrate_kbps)
{
if (gfp.is_valid()) {
gfp.VBR_max_bitrate_kbps = VBR_max_bitrate_kbps;
return 0;
}
return -1;
}
int
lame_get_VBR_max_bitrate_kbps(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.VBR_max_bitrate_kbps;
}
return 0;
}
/*
* 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)
{
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int lame_get_VBR_hard_min(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
assert(0 <= gfp.VBR_hard_min && 1 >= gfp.VBR_hard_min);
return gfp.VBR_hard_min;
}
return 0;
}
/********************************************************************
* Filtering control
***********************************************************************/
/*
* Freqency in Hz to apply lowpass.
* 0 = default = lame chooses
* -1 = disabled
*/
int
lame_set_lowpassfreq(lame_global_flags & gfp, int lowpassfreq)
{
if (gfp.is_valid()) {
gfp.lowpassfreq = lowpassfreq;
return 0;
}
return -1;
}
int
lame_get_lowpassfreq(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.lowpassfreq;
}
return 0;
}
/*
* Width of transition band (in Hz).
* default = one polyphase filter band
*/
int
lame_set_lowpasswidth(lame_global_flags & gfp, int lowpasswidth)
{
if (gfp.is_valid()) {
gfp.lowpasswidth = lowpasswidth;
return 0;
}
return -1;
}
int lame_get_lowpasswidth(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.lowpasswidth;
}
return 0;
}
/*
* Frequency in Hz to apply highpass.
* 0 = default = lame chooses
* -1 = disabled
*/
int lame_set_highpassfreq(lame_global_flags & gfp, int highpassfreq)
{
if (gfp.is_valid()) {
gfp.highpassfreq = highpassfreq;
return 0;
}
return -1;
}
int lame_get_highpassfreq(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.highpassfreq;
}
return 0;
}
/*
* Width of transition band (in Hz).
* default = one polyphase filter band
*/
int lame_set_highpasswidth(lame_global_flags & gfp, int highpasswidth)
{
if (gfp.is_valid()) {
gfp.highpasswidth = highpasswidth;
return 0;
}
return -1;
}
int lame_get_highpasswidth(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.highpasswidth;
}
return 0;
}
/*
* psycho acoustics and other arguments which you should not change
* unless you know what you are doing
*/
/* Adjust masking values. */
int lame_set_maskingadjust(lame_global_flags & gfp, float adjust)
{
if (gfp.is_valid()) {
gfp.maskingadjust = adjust;
return 0;
}
return -1;
}
float lame_get_maskingadjust(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.maskingadjust;
}
return 0;
}
int lame_set_maskingadjust_short(lame_global_flags & gfp, float adjust)
{
if (gfp.is_valid()) {
gfp.maskingadjust_short = adjust;
return 0;
}
return -1;
}
float lame_get_maskingadjust_short(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
return gfp.maskingadjust_short;
}
return 0;
}
/* Only use ATH for masking. */
int lame_set_ATHonly(lame_global_flags & gfp, int ATHonly) {
if (gfp.is_valid()) {
gfp.ATHonly = ATHonly;
return 0;
}
return -1;
}
int lame_get_ATHonly(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return gfp.ATHonly;
}
return 0;
}
/* Only use ATH for short blocks. */
int lame_set_ATHshort(lame_global_flags & gfp, int ATHshort) {
if (gfp.is_valid()) {
gfp.ATHshort = ATHshort;
return 0;
}
return -1;
}
int lame_get_ATHshort(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return gfp.ATHshort;
}
return 0;
}
/* Disable ATH. */
int lame_set_noATH(lame_global_flags & gfp, int noATH) {
if (gfp.is_valid()) {
gfp.noATH = noATH;
return 0;
}
return -1;
}
int lame_get_noATH(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return gfp.noATH;
}
return 0;
}
/* Select ATH formula. */
int lame_set_ATHtype(lame_global_flags & gfp, int ATHtype) {
if (gfp.is_valid()) {
/* XXX: ATHtype should be converted to an enum. */
gfp.ATHtype = ATHtype;
return 0;
}
return -1;
}
int lame_get_ATHtype(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return gfp.ATHtype;
}
return 0;
}
/* Select ATH formula 4 shape. */
int lame_set_ATHcurve(lame_global_flags & gfp, float ATHcurve) {
if (gfp.is_valid()) {
gfp.ATHcurve = ATHcurve;
return 0;
}
return -1;
}
float lame_get_ATHcurve(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return gfp.ATHcurve;
}
return 0;
}
/* Lower ATH by this many db. */
int lame_set_ATHlower(lame_global_flags & gfp, float ATHlower) {
if (gfp.is_valid()) {
gfp.ATH_lower_db = ATHlower;
return 0;
}
return -1;
}
float lame_get_ATHlower(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return gfp.ATH_lower_db;
}
return 0;
}
/* Select ATH adaptive adjustment scheme. */
int lame_set_athaa_type(lame_global_flags & gfp, int athaa_type) {
if (gfp.is_valid()) {
gfp.athaa_type = athaa_type;
return 0;
}
return -1;
}
int lame_get_athaa_type(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return gfp.athaa_type;
}
return 0;
}
/* Select the loudness approximation used by the ATH adaptive auto-leveling. */
int lame_set_athaa_loudapprox(lame_global_flags & gfp, int athaa_loudapprox) {
(void) gfp;
(void) athaa_loudapprox;
return 0;
}
int lame_get_athaa_loudapprox(const lame_global_flags & gfp) {
(void) 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) {
if (gfp.is_valid()) {
gfp.athaa_sensitivity = athaa_sensitivity;
return 0;
}
return -1;
}
float lame_get_athaa_sensitivity(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return gfp.athaa_sensitivity;
}
return 0;
}
/* Predictability limit (ISO tonality formula) */
int lame_set_cwlimit(lame_global_flags & gfp, int cwlimit) {
(void) gfp;
(void) cwlimit;
return 0;
}
int lame_get_cwlimit(const lame_global_flags & gfp) {
(void) gfp;
return 0;
}
/*
* 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) {
if (gfp.is_valid()) {
gfp.short_blocks = allow_diff_short ? short_block_allowed : short_block_coupled;
return 0;
}
return -1;
}
int lame_get_allow_diff_short(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
if (gfp.short_blocks == short_block_allowed)
return 1; /* short blocks allowed to differ */
else
return 0; /* not set, dispensed, forced or coupled */
}
return 0;
}
/* Use temporal masking effect */
int lame_set_useTemporal(lame_global_flags & gfp, int useTemporal) {
if (gfp.is_valid()) {
/* 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 && useTemporal <= 1) {
gfp.useTemporal = useTemporal;
return 0;
}
}
return -1;
}
int lame_get_useTemporal(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
assert(0 <= gfp.useTemporal && 1 >= gfp.useTemporal);
return gfp.useTemporal;
}
return 0;
}
/* Use inter-channel masking effect */
int lame_set_interChRatio(lame_global_flags & gfp, float ratio) {
if (gfp.is_valid()) {
/* default = 0.0 (no inter-channel maskin) */
if (0 <= ratio && ratio <= 1.0) {
gfp.interChRatio = ratio;
return 0;
}
}
return -1;
}
float lame_get_interChRatio(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
assert((0 <= gfp.interChRatio && gfp.interChRatio <= 1.0) || EQ(gfp.interChRatio, -1.0f));
return gfp.interChRatio;
}
return 0;
}
/* Use pseudo substep shaping method */
int lame_set_substep(lame_global_flags & gfp, int method) {
if (gfp.is_valid()) {
/* default = 0.0 (no substep noise shaping) */
if (0 <= method && method <= 7) {
gfp.substep_shaping = method;
return 0;
}
}
return -1;
}
int lame_get_substep(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
assert(0 <= gfp.substep_shaping && gfp.substep_shaping <= 7);
return gfp.substep_shaping;
}
return 0;
}
/* scalefactors scale */
int lame_set_sfscale(lame_global_flags & gfp, int val) {
if (gfp.is_valid()) {
gfp.noise_shaping = (val != 0) ? 2 : 1;
return 0;
}
return -1;
}
int lame_get_sfscale(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return (gfp.noise_shaping == 2) ? 1 : 0;
}
return 0;
}
/* subblock gain */
int lame_set_subblock_gain(lame_global_flags & gfp, int sbgain) {
if (gfp.is_valid()) {
gfp.subblock_gain = sbgain;
return 0;
}
return -1;
}
int lame_get_subblock_gain(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return gfp.subblock_gain;
}
return 0;
}
/* Disable short blocks. */
int lame_set_no_short_blocks(lame_global_flags & gfp, int no_short_blocks) {
if (gfp.is_valid()) {
/* 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 && no_short_blocks <= 1) {
gfp.short_blocks = no_short_blocks ? short_block_dispensed : short_block_allowed;
return 0;
}
}
return -1;
}
int lame_get_no_short_blocks(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
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;
}
}
return -1;
}
/* Force short blocks. */
int lame_set_force_short_blocks(lame_global_flags & gfp, int short_blocks) {
if (gfp.is_valid()) {
/* 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;
}
return -1;
}
int lame_get_force_short_blocks(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
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;
}
}
return -1;
}
int lame_set_short_threshold_lrm(lame_global_flags & gfp, float lrm) {
if (gfp.is_valid()) {
gfp.attackthre = lrm;
return 0;
}
return -1;
}
float lame_get_short_threshold_lrm(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return gfp.attackthre;
}
return 0;
}
int lame_set_short_threshold_s(lame_global_flags & gfp, float s) {
if (gfp.is_valid()) {
gfp.attackthre_s = s;
return 0;
}
return -1;
}
float lame_get_short_threshold_s(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
return gfp.attackthre_s;
}
return 0;
}
int lame_set_short_threshold(lame_global_flags & gfp, float lrm, float s) {
if (gfp.is_valid()) {
lame_set_short_threshold_lrm(gfp, lrm);
lame_set_short_threshold_s(gfp, s);
return 0;
}
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) {
if (gfp.is_valid()) {
/* XXX: emphasis should be converted to an enum */
if (0 <= emphasis && emphasis < 4) {
gfp.emphasis = emphasis;
return 0;
}
}
return -1;
}
int lame_get_emphasis(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
assert(0 <= gfp.emphasis && gfp.emphasis < 4);
return gfp.emphasis;
}
return 0;
}
/***************************************************************/
/* 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) {
if (gfp.is_valid()) {
lame_internal_flags const & gfc = *gfp.internal_flags;
if (gfc.is_valid()) {
return gfc.cfg.version;
}
}
return 0;
}
/* Encoder delay. */
int lame_get_encoder_delay(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
lame_internal_flags const *const gfc = gfp.internal_flags;
if (gfc->is_valid()) {
return gfc->ov_enc.encoder_delay;
}
}
return 0;
}
/* padding added to the end of the input */
int
lame_get_encoder_padding(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
lame_internal_flags const *const gfc = gfp.internal_flags;
if (gfc->is_valid()) {
return gfc->ov_enc.encoder_padding;
}
}
return 0;
}
/* Size of MPEG frame. */
int lame_get_framesize(const lame_global_flags & gfp) {
if (!gfp.is_valid()) return 0;
lame_internal_flags const & gfc = *gfp.internal_flags;
if (!gfc.is_valid()) return 0;
SessionConfig_t const & cfg = gfc.cfg;
return 576 * cfg.mode_gr;
}
/* Number of frames encoded so far. */
int lame_get_frameNum(const lame_global_flags & gfp)
{
if (gfp.is_valid()) {
lame_internal_flags const *const gfc = gfp.internal_flags;
if (gfc->is_valid()) {
return gfc->ov_enc.frame_number;
}
}
return 0;
}
int lame_get_mf_samples_to_encode(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
lame_internal_flags const *const gfc = gfp.internal_flags;
if (gfc->is_valid()) {
return gfc->sv_enc.mf_samples_to_encode;
}
}
return 0;
}
int lame_get_size_mp3buffer(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
lame_internal_flags const & gfc = *gfp.internal_flags;
if (gfc.is_valid()) {
int size;
compute_flushbits(gfc, &size);
return size;
}
}
return 0;
}
int lame_get_RadioGain(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
lame_internal_flags const *const gfc = gfp.internal_flags;
if (gfc->is_valid()) {
return gfc->ov_rpg.RadioGain;
}
}
return 0;
}
int lame_get_AudiophileGain(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
lame_internal_flags const *const gfc = gfp.internal_flags;
if (gfc->is_valid()) {
return 0;
}
}
return 0;
}
float lame_get_PeakSample(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
lame_internal_flags const *const gfc = gfp.internal_flags;
if (gfc->is_valid()) {
return (float) gfc->ov_rpg.PeakSample;
}
}
return 0;
}
int lame_get_noclipGainChange(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
lame_internal_flags const *const gfc = gfp.internal_flags;
if (gfc->is_valid()) {
return gfc->ov_rpg.noclipGainChange;
}
}
return 0;
}
float lame_get_noclipScale(const lame_global_flags & gfp) {
if (gfp.is_valid()) {
lame_internal_flags const *const gfc = gfp.internal_flags;
if (gfc->is_valid()) {
return gfc->ov_rpg.noclipScale;
}
}
return 0;
}
/*
* 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) {
if (gfp.is_valid()) {
lame_internal_flags const *const gfc = gfp.internal_flags;
if (gfc->is_valid()) {
SessionConfig_t const *const cfg = &gfc->cfg;
unsigned long const pcm_samples_per_frame = 576 * cfg->mode_gr;
unsigned long pcm_samples_to_encode = gfp.num_samples;
unsigned long end_padding = 0;
int frames = 0;
if (pcm_samples_to_encode == (0ul-1ul))
return 0; /* unknown */
/* estimate based on user set num_samples: */
if (cfg->samplerate_in != cfg->samplerate_out) {
/* resampling, estimate new samples_to_encode */
double resampled_samples_to_encode = 0.0, frames_f = 0.0;
if (cfg->samplerate_in > 0) {
resampled_samples_to_encode = pcm_samples_to_encode;
resampled_samples_to_encode *= cfg->samplerate_out;
resampled_samples_to_encode /= cfg->samplerate_in;
}
if (resampled_samples_to_encode <= 0.0)
return 0; /* unlikely to happen, so what, no estimate! */
frames_f = floor(resampled_samples_to_encode / pcm_samples_per_frame);
if (frames_f >= (INT_MAX-2))
return 0; /* overflow, happens eventually, no estimate! */
frames = frames_f;
resampled_samples_to_encode -= frames * pcm_samples_per_frame;
pcm_samples_to_encode = ceil(resampled_samples_to_encode);
}
else {
frames = pcm_samples_to_encode / pcm_samples_per_frame;
pcm_samples_to_encode -= frames * pcm_samples_per_frame;
}
pcm_samples_to_encode += 576ul;
end_padding = pcm_samples_per_frame - (pcm_samples_to_encode % pcm_samples_per_frame);
if (end_padding < 576ul) {
end_padding += pcm_samples_per_frame;
}
pcm_samples_to_encode += end_padding;
frames += (pcm_samples_to_encode / pcm_samples_per_frame);
/* check to see if we underestimated totalframes */
/* if (totalframes < gfp.frameNum) */
/* totalframes = gfp.frameNum; */
return frames;
}
}
return 0;
}
int lame_set_preset(lame_global_flags & gfp, int preset) {
if (gfp.is_valid()) {
gfp.preset = preset;
return apply_preset(gfp, preset, 1);
}
return -1;
}
int lame_set_asm_optimizations(lame_global_flags & gfp, int optim, int mode) {
if (gfp.is_valid()) {
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;
}
}
return -1;
}
void lame_set_write_id3tag_automatic(lame_global_flags & gfp, int v) {
if (gfp.is_valid()) {
gfp.write_id3tag_automatic = v;
}
}
int lame_get_write_id3tag_automatic(lame_global_flags const &gfp) {
if (gfp.is_valid()) {
return gfp.write_id3tag_automatic;
}
return 1;
}
/*
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) {
if (gfp.is_valid()) {
gfp.tune_value_a = val;
gfp.tune = 1;
}
}
/* Custom msfix hack */
void lame_set_msfix(lame_global_flags & gfp, double msfix) {
if (gfp.is_valid()) gfp.msfix = msfix;
}
float lame_get_msfix(const lame_global_flags & gfp) {
if (gfp.is_valid()) return gfp.msfix;
return 0;
}
int lame_set_preset_expopts(lame_global_flags &, int) {
return 0;
}
int lame_set_preset_notune(lame_global_flags &, int) {
return 0;
}
static int calc_maximum_input_samples_for_buffer_size(lame_internal_flags const& gfc, size_t buffer_size) {
SessionConfig_t const & cfg = gfc.cfg;
int const pcm_samples_per_frame = 576 * cfg.mode_gr;
int frames_per_buffer = 0, input_samples_per_buffer = 0;
int kbps = 320;
if (cfg.samplerate_out < 16000)
kbps = 64;
else if (cfg.samplerate_out < 32000)
kbps = 160;
else
kbps = 320;
if (cfg.free_format)
kbps = cfg.avg_bitrate;
else if (cfg.vbr == vbr_off) {
kbps = cfg.avg_bitrate;
}
{
int const pad = 1;
int const bpf = ((cfg.version + 1) * 72000 * kbps / cfg.samplerate_out + pad);
frames_per_buffer = int(buffer_size / bpf);
}
{
double ratio = (double) cfg.samplerate_in / cfg.samplerate_out;
input_samples_per_buffer = pcm_samples_per_frame * frames_per_buffer * ratio;
}
return input_samples_per_buffer;
}
int lame_get_maximum_number_of_samples(lame_global_flags & gfp, size_t buffer_size) {
if (!gfp.is_valid()) return LAME_GENERICERROR;
lame_internal_flags const & gfc = *gfp.internal_flags;
if (!gfc.is_valid()) return LAME_GENERICERROR;
return calc_maximum_input_samples_for_buffer_size(gfc, buffer_size);
}
| Vorgefundene Kodierung: UTF-8 | 0
|