int doInit(LameConf* conf) {
int result;
conf->gf=lame_init();
if (conf->gf==NULL) {
//throwRuntimeException(env, "out of memory");
return org_tritonus_lowlevel_lame_Lame_OUT_OF_MEMORY;
}
lame_set_num_channels(conf->gf, conf->channels);
lame_set_in_samplerate(conf->gf, conf->sampleRate);
if (conf->mode!=org_tritonus_lowlevel_lame_Lame_CHANNEL_MODE_AUTO) {
lame_set_mode(conf->gf, conf->mode);
}
if (conf->VBR) {
lame_set_VBR(conf->gf, vbr_default);
lame_set_VBR_q(conf->gf, conf->quality);
} else {
if (conf->bitrate!=org_tritonus_lowlevel_lame_Lame_BITRATE_AUTO) {
lame_set_brate(conf->gf, conf->bitrate);
}
}
lame_set_quality(conf->gf, conf->quality);
result=lame_init_params(conf->gf);
// return effective values
conf->sampleRate=lame_get_out_samplerate(conf->gf);
conf->bitrate=lame_get_brate(conf->gf);
conf->mode=lame_get_mode(conf->gf);
conf->VBR=lame_get_VBR(conf->gf);
conf->quality=(conf->VBR)?lame_get_VBR_q(conf->gf):lame_get_quality(conf->gf);
conf->mpegVersion=lame_get_version(conf->gf);
return result;
}
Mp3OutputStream::Mp3OutputStream() : global_fags(), bytes_per_sample(), bytes_per_second()
#ifdef Mp3OutputStream_Buffering
m_inBuffer(), m_inBufferLenght(), m_inBufferPos(),
#endif
,m_outBuffer(), m_outBufferLenght()
{
}
Mp3OutputStream::~Mp3OutputStream()
{
Close();
#ifdef Mp3OutputStream_Buffering
delete [] m_inBuffer;
#endif
delete [] m_outBuffer;
}
bool Mp3OutputStream::Initialize(int samplerate, int numchannels, int bitspersamp)
{
global_fags = lame_init();
if(global_fags == nullptr)
return false;
//lame_set_errorf(global_fags, lame_debugger);
lame_set_analysis(global_fags, 0);
lame_set_in_samplerate(global_fags, samplerate);
lame_set_bWriteVbrTag( global_fags, 0 );
lame_set_error_protection( global_fags, 0 );
lame_set_extension( global_fags, 0 );
lame_set_original( global_fags, 0 );
lame_set_VBR(global_fags, vbr_off);
lame_set_num_channels(global_fags, numchannels);
lame_set_mode( global_fags, STEREO);
lame_set_out_samplerate(global_fags, 44100);
// 9 = LQP_LOW_QUALITY
// 2 = LQP_HIGH_QUALITY:
// 0 = LQP_VERYHIGH_QUALITY
//lame_set_quality(global_fags, 0 );
//lame_set_preset( global_fags, STANDARD_FAST);
Settings& s = Global::Settings;
#ifdef STREAMER_PAYD_VERSION
lame_set_brate(global_fags, std::min(Mp3OutputStreamConstants::Presets[s.encoder_preset], 320));
#else
lame_set_brate(global_fags, 64);
#endif
if(lame_init_params(global_fags) != 0)
{
OutputDebugString(_T("lame_init_params failed"));
lame_close(global_fags);
global_fags = nullptr;
return false;
}
bytes_per_second = lame_get_brate(global_fags) / 8;
#ifdef Mp3OutputStream_Buffering
if ( 0 == lame_get_version( global_fags ) )
{
// For MPEG-II, only 576 samples per frame per channel
m_inBufferLenght = 576 * lame_get_num_channels( global_fags );
}
else
{
// For MPEG-I, 1152 samples per frame per channel
m_inBufferLenght = 1152 * lame_get_num_channels( global_fags );
}
// delete buffers
if(m_inBuffer != nullptr)
delete [] m_inBuffer;
m_inBuffer = new BYTE[m_inBufferLenght * 2];
#endif
m_outBufferLenght = static_cast<int>( ( 1.25 * ( samplerate / numchannels ) + 7200 ) * 2.0);
if(m_outBuffer != nullptr)
delete [] m_outBuffer;
m_outBuffer = new BYTE[m_outBufferLenght];
bytes_per_sample = bitspersamp / 8;
return true;
}
/*------------------------------------------------------------------------------
* Open an encoding session
*----------------------------------------------------------------------------*/
bool
LameLibEncoder :: open ( void )
throw ( Exception )
{
if ( isOpen() ) {
close();
}
lameGlobalFlags = lame_init();
// ugly lame returns -1 in a pointer on allocation errors
if ( !lameGlobalFlags || ((int)lameGlobalFlags) == -1 ) {
throw Exception( __FILE__, __LINE__,
"lame lib init error",
(int) lameGlobalFlags);
}
if ( 0 > lame_set_num_channels( lameGlobalFlags, getInChannel()) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting channels error",
getInChannel() );
}
if ( 0 > lame_set_mode( lameGlobalFlags,
getOutChannel() == 1 ? MONO : JOINT_STEREO) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting mode error",
JOINT_STEREO );
}
reportEvent( 5, "set lame mode", lame_get_mode( lameGlobalFlags));
reportEvent( 5,
"set lame channels",
lame_get_num_channels( lameGlobalFlags));
if ( 0 > lame_set_in_samplerate( lameGlobalFlags, getInSampleRate()) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting input sample rate error",
getInSampleRate() );
}
reportEvent( 5,
"set lame in sample rate",
lame_get_in_samplerate( lameGlobalFlags));
if ( 0 > lame_set_out_samplerate( lameGlobalFlags, getOutSampleRate()) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting output sample rate error",
getOutSampleRate() );
}
reportEvent( 5,
"set lame out sample rate",
lame_get_out_samplerate( lameGlobalFlags));
switch ( getOutBitrateMode() ) {
case cbr: {
if ( 0 > lame_set_brate( lameGlobalFlags, getOutBitrate()) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting output bit rate error",
getOutBitrate() );
}
reportEvent( 5,
"set lame bit rate",
lame_get_brate( lameGlobalFlags));
double d = (1.0 - getOutQuality()) * 10.0;
int q = int (d + 0.499999);
if ( 0 > lame_set_quality( lameGlobalFlags, q) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting quality error", q);
}
reportEvent( 5,
"set lame quality",
lame_get_quality( lameGlobalFlags));
} break;
case abr:
if ( 0 > lame_set_VBR( lameGlobalFlags,vbr_abr)) {
throw Exception( __FILE__, __LINE__,
"lame lib setting abr error", vbr_abr);
}
reportEvent( 5,
"set lame abr bitrate",
lame_get_VBR( lameGlobalFlags));
if ( 0 > lame_set_VBR_mean_bitrate_kbps( lameGlobalFlags,
getOutBitrate())) {
throw Exception( __FILE__, __LINE__,
"lame lib setting abr mean bitrate error",
getOutBitrate());
}
reportEvent( 5,
"set lame abr mean bitrate",
lame_get_VBR_mean_bitrate_kbps( lameGlobalFlags));
break;
case vbr: {
if ( 0 > lame_set_VBR( lameGlobalFlags, vbr_mtrh)) {
throw Exception( __FILE__, __LINE__,
"lame lib setting vbr error", vbr_mtrh );
}
reportEvent( 5,
"set lame vbr bitrate",
lame_get_VBR( lameGlobalFlags));
double d = (1.0 - getOutQuality()) * 10.0;
int q = int (d + 0.499999);
if ( 0 > lame_set_VBR_q( lameGlobalFlags, q) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting vbr quality error", q);
}
reportEvent( 5,
"set lame vbr quality",
lame_get_VBR_q( lameGlobalFlags));
} break;
}
if ( 0 > lame_set_lowpassfreq( lameGlobalFlags, lowpass) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting lowpass frequency error",
lowpass );
}
reportEvent( 5,
"set lame lowpass frequency",
lame_get_lowpassfreq( lameGlobalFlags));
if ( 0 > lame_set_highpassfreq( lameGlobalFlags, highpass) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting highpass frequency error",
lowpass );
}
reportEvent( 5,
"set lame highpass frequency",
lame_get_highpassfreq( lameGlobalFlags));
// not configurable lame settings
if ( 0 > lame_set_exp_nspsytune( lameGlobalFlags, 1) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting psycho acoustic model error");
}
reportEvent( 5,
"set lame psycho acoustic model",
lame_get_exp_nspsytune( lameGlobalFlags));
if ( 0 > lame_set_error_protection( lameGlobalFlags, 1) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting error protection error",
1 );
}
reportEvent( 5,
"set lame error protection",
lame_get_error_protection( lameGlobalFlags));
// let lame init its own params based on our settings
if ( 0 > lame_init_params( lameGlobalFlags) ) {
throw Exception( __FILE__, __LINE__,
"lame lib initializing params error" );
}
lame_print_config( lameGlobalFlags);
// open the underlying sink
if ( !sink->open() ) {
throw Exception( __FILE__, __LINE__,
"lame lib opening underlying sink error");
}
return true;
}
int
lame_encoder(lame_global_flags * gf, FILE * outf, int nogap, char *inPath,
char *outPath)
{
unsigned char mp3buffer[LAME_MAXMP3BUFFER];
int Buffer[2][1152];
int iread, imp3;
static const char *mode_names[2][4] = {
{"stereo", "j-stereo", "dual-ch", "single-ch"},
{"stereo", "force-ms", "dual-ch", "single-ch"}
};
int frames;
if (silent < 10) {
lame_print_config(gf); /* print useful information about options being used */
fprintf(stderr, "Encoding %s%s to %s\n",
strcmp(inPath, "-") ? inPath : "<stdin>",
strlen(inPath) + strlen(outPath) < 66 ? "" : "\n ",
strcmp(outPath, "-") ? outPath : "<stdout>");
fprintf(stderr,
"Encoding as %g kHz ", 1.e-3 * lame_get_out_samplerate(gf));
{
const char *appendix = "";
switch (lame_get_VBR(gf)) {
case vbr_mt:
case vbr_rh:
case vbr_mtrh:
appendix = "ca. ";
fprintf(stderr, "VBR(q=%i)", lame_get_VBR_q(gf));
break;
case vbr_abr:
fprintf(stderr, "average %d kbps",
lame_get_VBR_mean_bitrate_kbps(gf));
break;
default:
fprintf(stderr, "%3d kbps", lame_get_brate(gf));
break;
}
fprintf(stderr, " %s MPEG-%u%s Layer III (%s%gx) qval=%i\n",
mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)],
2 - lame_get_version(gf),
lame_get_out_samplerate(gf) < 16000 ? ".5" : "",
appendix,
0.1 * (int) (10. * lame_get_compression_ratio(gf) + 0.5),
lame_get_quality(gf));
}
if (silent <= -10)
lame_print_internals(gf);
fflush(stderr);
}
/* encode until we hit eof */
do {
/* read in 'iread' samples */
iread = get_audio(gf, Buffer);
frames = lame_get_frameNum(gf);
/********************** status display *****************************/
if (silent <= 0) {
if (update_interval > 0) {
timestatus_klemm(gf);
}
else {
if (0 == frames % 50) {
#ifdef BRHIST
brhist_jump_back();
#endif
timestatus(lame_get_out_samplerate(gf),
frames,
lame_get_totalframes(gf),
lame_get_framesize(gf));
#ifdef BRHIST
if (brhist)
brhist_disp(gf);
#endif
}
}
}
/* encode */
imp3 = lame_encode_buffer_int(gf, Buffer[0], Buffer[1], iread,
mp3buffer, sizeof(mp3buffer));
/* was our output buffer big enough? */
if (imp3 < 0) {
if (imp3 == -1)
fprintf(stderr, "mp3 buffer is not big enough... \n");
else
fprintf(stderr, "mp3 internal error: error code=%i\n", imp3);
return 1;
}
if (fwrite(mp3buffer, 1, imp3, outf) != imp3) {
fprintf(stderr, "Error writing mp3 output \n");
return 1;
}
} while (iread);
if (nogap)
imp3 = lame_encode_flush_nogap(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
else
imp3 = lame_encode_flush(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
if (imp3 < 0) {
if (imp3 == -1)
fprintf(stderr, "mp3 buffer is not big enough... \n");
else
fprintf(stderr, "mp3 internal error: error code=%i\n", imp3);
return 1;
}
if (silent <= 0) {
#ifdef BRHIST
brhist_jump_back();
#endif
frames = lame_get_frameNum(gf);
timestatus(lame_get_out_samplerate(gf),
frames, lame_get_totalframes(gf), lame_get_framesize(gf));
#ifdef BRHIST
if (brhist) {
brhist_disp(gf);
}
brhist_disp_total(gf);
#endif
timestatus_finish();
}
fwrite(mp3buffer, 1, imp3, outf);
return 0;
}
/*------------------------------------------------------------------------------
* Open an encoding session
*----------------------------------------------------------------------------*/
bool
LameLibEncoder :: open ( void )
throw ( Exception )
{
if ( isOpen() ) {
close();
}
lameGlobalFlags = lame_init();
// ugly lame returns -1 in a pointer on allocation errors
if ( !lameGlobalFlags || ((int)lameGlobalFlags) == -1 ) {
throw Exception( __FILE__, __LINE__,
"lame lib init error",
(int) lameGlobalFlags);
}
if ( 0 > lame_set_num_channels( lameGlobalFlags, getInChannel()) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting channels error",
getInChannel() );
}
if ( 0 > lame_set_mode( lameGlobalFlags,
getInChannel() == 1 ? MONO : JOINT_STEREO) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting mode error",
JOINT_STEREO );
}
reportEvent( 5, "set lame mode", lame_get_mode( lameGlobalFlags));
reportEvent( 5,
"set lame channels",
lame_get_num_channels( lameGlobalFlags));
if ( 0 > lame_set_in_samplerate( lameGlobalFlags, getInSampleRate()) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting input sample rate error",
getInSampleRate() );
}
reportEvent( 5,
"set lame in sample rate",
lame_get_in_samplerate( lameGlobalFlags));
if ( 0 > lame_set_out_samplerate( lameGlobalFlags, getOutSampleRate()) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting output sample rate error",
getOutSampleRate() );
}
reportEvent( 5,
"set lame out sample rate",
lame_get_out_samplerate( lameGlobalFlags));
if ( 0 > lame_set_brate( lameGlobalFlags, getOutBitrate()) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting output bit rate error",
getOutBitrate() );
}
reportEvent( 5, "set lame bit rate", lame_get_brate( lameGlobalFlags));
if ( lowpass ) {
if ( 0 > lame_set_lowpassfreq( lameGlobalFlags, lowpass) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting lowpass frequency error",
lowpass );
}
reportEvent( 5,
"set lame lowpass frequency",
lame_get_lowpassfreq( lameGlobalFlags));
}
if ( highpass ) {
if ( 0 > lame_set_highpassfreq( lameGlobalFlags, highpass) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting highpass frequency error",
lowpass );
}
reportEvent( 5,
"set lame highpass frequency",
lame_get_highpassfreq( lameGlobalFlags));
}
// not configurable lame settings
if ( 0 > lame_set_quality( lameGlobalFlags, 2) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting quality error",
2 );
}
reportEvent( 5, "set lame quality", lame_get_quality( lameGlobalFlags));
if ( 0 > lame_set_exp_nspsytune( lameGlobalFlags, 1) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting psycho acoustic model error");
}
reportEvent( 5,
"set lame psycho acoustic model",
lame_get_exp_nspsytune( lameGlobalFlags));
if ( 0 > lame_set_error_protection( lameGlobalFlags, 1) ) {
throw Exception( __FILE__, __LINE__,
"lame lib setting error protection error",
1 );
}
reportEvent( 5,
"set lame error protection",
lame_get_error_protection( lameGlobalFlags));
// let lame init its own params based on our settings
if ( 0 > lame_init_params( lameGlobalFlags) ) {
throw Exception( __FILE__, __LINE__,
"lame lib initializing params error" );
}
lame_print_config( lameGlobalFlags);
// open the underlying sink
if ( !sink->open() ) {
throw Exception( __FILE__, __LINE__,
"lame lib opening underlying sink error");
}
return true;
}
bool ACMStream::open(const AEncodeProperties & the_Properties)
{
bool bResult = false;
// Init the MP3 Stream
// Init the global flags structure
gfp = lame_init();
// Set input sample frequency
lame_set_in_samplerate( gfp, my_SamplesPerSec );
// Set output sample frequency
lame_set_out_samplerate( gfp, my_OutBytesPerSec );
lame_set_num_channels( gfp, my_Channels );
if (my_Channels == 1)
lame_set_mode( gfp, MONO );
else
lame_set_mode( gfp, (MPEG_mode_e)the_Properties.GetChannelModeValue()) ; /// \todo Get the mode from the default configuration
// lame_set_VBR( gfp, vbr_off ); /// \note VBR not supported for the moment
lame_set_VBR( gfp, my_VBRMode ); /// \note VBR not supported for the moment
if (my_VBRMode == vbr_abr)
{
lame_set_VBR_q( gfp, 1 );
lame_set_VBR_mean_bitrate_kbps( gfp, (my_AvgBytesPerSec * 8 + 500) / 1000 );
if (24000 > lame_get_in_samplerate( gfp ))
{
// For MPEG-II
lame_set_VBR_min_bitrate_kbps( gfp, 8);
lame_set_VBR_max_bitrate_kbps( gfp, 160);
}
else
{
// For MPEG-I
lame_set_VBR_min_bitrate_kbps( gfp, 32);
lame_set_VBR_max_bitrate_kbps( gfp, 320);
}
}
// Set bitrate
lame_set_brate( gfp, my_AvgBytesPerSec * 8 / 1000 );
/// \todo Get the mode from the default configuration
// Set copyright flag?
lame_set_copyright( gfp, the_Properties.GetCopyrightMode()?1:0 );
// Do we have to tag it as non original
lame_set_original( gfp, the_Properties.GetOriginalMode()?1:0 );
// Add CRC?
lame_set_error_protection( gfp, the_Properties.GetCRCMode()?1:0 );
// Set private bit?
lame_set_extension( gfp, the_Properties.GetPrivateMode()?1:0 );
// INFO tag support not possible in ACM - it requires rewinding
// output stream to the beginning after encoding is finished.
lame_set_bWriteVbrTag( gfp, 0 );
if (0 == lame_init_params( gfp ))
{
//LAME encoding call will accept any number of samples.
if ( 0 == lame_get_version( gfp ) )
{
// For MPEG-II, only 576 samples per frame per channel
my_SamplesPerBlock = 576 * lame_get_num_channels( gfp );
}
else
{
// For MPEG-I, 1152 samples per frame per channel
my_SamplesPerBlock = 1152 * lame_get_num_channels( gfp );
}
}
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "version =%d",lame_get_version( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Layer =3");
switch ( lame_get_mode( gfp ) )
{
case STEREO: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "mode =Stereo" ); break;
case JOINT_STEREO: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "mode =Joint-Stereo" ); break;
case DUAL_CHANNEL: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "mode =Forced Stereo" ); break;
case MONO: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "mode =Mono" ); break;
case NOT_SET: /* FALLTROUGH */
default: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "mode =Error (unknown)" ); break;
}
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "sampling frequency =%.1f kHz", lame_get_in_samplerate( gfp ) /1000.0 );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "bitrate =%d kbps", lame_get_brate( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Vbr Min bitrate =%d kbps", lame_get_VBR_min_bitrate_kbps( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Vbr Max bitrate =%d kbps", lame_get_VBR_max_bitrate_kbps( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Quality Setting =%d", lame_get_quality( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Low pass frequency =%d", lame_get_lowpassfreq( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Low pass width =%d", lame_get_lowpasswidth( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "High pass frequency =%d", lame_get_highpassfreq( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "High pass width =%d", lame_get_highpasswidth( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "No Short Blocks =%d", lame_get_no_short_blocks( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "de-emphasis =%d", lame_get_emphasis( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "private flag =%d", lame_get_extension( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "copyright flag =%d", lame_get_copyright( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "original flag =%d", lame_get_original( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "CRC =%s", lame_get_error_protection( gfp ) ? "on" : "off" );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Fast mode =%s", ( lame_get_quality( gfp ) )? "enabled" : "disabled" );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Force mid/side stereo =%s", ( lame_get_force_ms( gfp ) )?"enabled":"disabled" );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Padding Type =%d", lame_get_padding_type( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Disable Resorvoir =%d", lame_get_disable_reservoir( gfp ) );
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "VBR =%s, VBR_q =%d, VBR method =",
( lame_get_VBR( gfp ) !=vbr_off ) ? "enabled": "disabled",
lame_get_VBR_q( gfp ) );
switch ( lame_get_VBR( gfp ) )
{
case vbr_off: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "vbr_off" ); break;
case vbr_mt : my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "vbr_mt" ); break;
case vbr_rh : my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "vbr_rh" ); break;
case vbr_mtrh: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "vbr_mtrh" ); break;
case vbr_abr:
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "vbr_abr (average bitrate %d kbps)", lame_get_VBR_mean_bitrate_kbps( gfp ) );
break;
default:
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "error, unknown VBR setting");
break;
}
my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Write VBR Header =%s\n", ( lame_get_bWriteVbrTag( gfp ) ) ?"Yes":"No");
#ifdef FROM_DLL
beConfig.format.LHV1.dwReSampleRate = my_OutBytesPerSec; // force the user resampling
#endif // FROM_DLL
bResult = true;
return bResult;
}
int lame_encoder_impl_internal::get_bit_rate() const
{
return lame_get_brate( m_Lame.get() );
}
void
encoder_progress_begin( lame_global_flags const* gf
, char const* inPath
, char const* outPath
)
{
brhist_init_package(gf);
global_encoder_progress.time_status_init = 0;
global_encoder_progress.last_time = 0;
global_encoder_progress.last_frame_num = 0;
if (global_ui_config.silent < 9) {
char* i_file = 0;
char* o_file = 0;
#if defined( _WIN32 ) && !defined(__MINGW32__)
inPath = i_file = utf8ToLocal8Bit(inPath);
outPath = o_file = utf8ToConsole8Bit(outPath);
#endif
lame_print_config(gf); /* print useful information about options being used */
console_printf("Encoding %s%s to %s\n",
strcmp(inPath, "-") ? inPath : "<stdin>",
strlen(inPath) + strlen(outPath) < 66 ? "" : "\n ",
strcmp(outPath, "-") ? outPath : "<stdout>");
free(i_file);
free(o_file);
console_printf("Encoding as %g kHz ", 1.e-3 * lame_get_out_samplerate(gf));
{
static const char *mode_names[2][4] = {
{"stereo", "j-stereo", "dual-ch", "single-ch"},
{"stereo", "force-ms", "dual-ch", "single-ch"}
};
switch (lame_get_VBR(gf)) {
case vbr_rh:
console_printf("%s MPEG-%u%s Layer III VBR(q=%g) qval=%i\n",
mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)],
2 - lame_get_version(gf),
lame_get_out_samplerate(gf) < 16000 ? ".5" : "",
lame_get_VBR_quality(gf),
lame_get_quality(gf));
break;
case vbr_mt:
case vbr_mtrh:
console_printf("%s MPEG-%u%s Layer III VBR(q=%g)\n",
mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)],
2 - lame_get_version(gf),
lame_get_out_samplerate(gf) < 16000 ? ".5" : "",
lame_get_VBR_quality(gf));
break;
case vbr_abr:
console_printf("%s MPEG-%u%s Layer III (%gx) average %d kbps qval=%i\n",
mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)],
2 - lame_get_version(gf),
lame_get_out_samplerate(gf) < 16000 ? ".5" : "",
0.1 * (int) (10. * lame_get_compression_ratio(gf) + 0.5),
lame_get_VBR_mean_bitrate_kbps(gf),
lame_get_quality(gf));
break;
default:
console_printf("%s MPEG-%u%s Layer III (%gx) %3d kbps qval=%i\n",
mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)],
2 - lame_get_version(gf),
lame_get_out_samplerate(gf) < 16000 ? ".5" : "",
0.1 * (int) (10. * lame_get_compression_ratio(gf) + 0.5),
lame_get_brate(gf),
lame_get_quality(gf));
break;
}
}
if (global_ui_config.silent <= -10) {
lame_print_internals(gf);
}
}
}
encoder_funcs_t* init_lame( output_format_t* format, int channels, int bitrate )
{
encoder_funcs_t* funcs = NULL;
lame_opts = lame_init();
if (lame_opts==NULL) {
rotter_error("lame error: failed to initialise.");
return NULL;
}
if ( 0 > lame_set_num_channels( lame_opts, channels ) ) {
rotter_error("lame error: failed to set number of channels.");
return NULL;
}
if ( 0 > lame_set_in_samplerate( lame_opts, jack_get_sample_rate( client ) )) {
rotter_error("lame error: failed to set input samplerate.");
return NULL;
}
if ( 0 > lame_set_out_samplerate( lame_opts, jack_get_sample_rate( client ) )) {
rotter_error("lame error: failed to set output samplerate.");
return NULL;
}
if ( 0 > lame_set_brate( lame_opts, bitrate) ) {
rotter_error("lame error: failed to set bitrate.");
return NULL;
}
if ( 0 > lame_init_params( lame_opts ) ) {
rotter_error("lame error: failed to initialize parameters.");
return NULL;
}
rotter_info( "Encoding using liblame version %s.", get_lame_version() );
rotter_debug( " Input: %d Hz, %d channels",
lame_get_in_samplerate(lame_opts),
lame_get_num_channels(lame_opts));
rotter_debug( " Output: %s Layer 3, %d kbps, %s",
lame_get_version_name(lame_opts),
lame_get_brate(lame_opts),
lame_get_mode_name(lame_opts));
// Allocate memory for encoded audio
mpeg_buffer = malloc( 1.25*SAMPLES_PER_FRAME + 7200 );
if ( mpeg_buffer==NULL ) {
rotter_error( "Failed to allocate memery for encoded audio." );
return NULL;
}
// Allocate memory for callback functions
funcs = calloc( 1, sizeof(encoder_funcs_t) );
if ( funcs==NULL ) {
rotter_error( "Failed to allocate memery for encoder callback functions structure." );
return NULL;
}
funcs->file_suffix = "mp3";
funcs->open = open_mpegaudio_file;
funcs->close = close_mpegaudio_file;
funcs->write = write_lame;
funcs->deinit = deinit_lame;
return funcs;
}
bool AudioEncoderMP3::initialize() {
if(lame_flags) {
STREAMER_ERROR("error: cannot initialize AudioEncoder because lame_flags has been setup already.\n");
return false;
}
if(settings.bitsize == AV_AUDIO_BITSIZE_UNKNOWN) {
STREAMER_ERROR("error: cannot initialize AudioEncoder because the set bitsize is invalid.\n");
return false;
}
if(settings.in_bitsize == AV_AUDIO_BITSIZE_UNKNOWN) {
settings.in_bitsize = settings.bitsize;
}
if(settings.mode == AV_AUDIO_MODE_UNKNOWN) {
STREAMER_ERROR("error: cannot initialize AudioEncoder because the mode (mono/stereo) is invalid.\n");
return false;
}
if(settings.samplerate == AV_AUDIO_SAMPLERATE_UNKNOWN) {
STREAMER_ERROR("error: cannot intialize the AudioEncoder because the samplerate is invalid.\n");
return false;
}
if(!settings.bitrate) {
STREAMER_ERROR("error: cannot initialize the AudioEncoder because the bitrate was not set.\n");
return false;
}
if(settings.samplerate == AV_AUDIO_SAMPLERATE_44100) {
samplerate = 44100;
}
else if(settings.samplerate == AV_AUDIO_SAMPLERATE_22050) {
samplerate = 22050;
}
else {
STREAMER_ERROR("error: invalid samplerate given for the AudioEncoder.\n");
return false;
}
if(settings.mode == AV_AUDIO_MODE_STEREO) {
mode = STEREO;
nchannels = 2;
}
else if(settings.mode == AV_AUDIO_MODE_MONO) {
mode = MONO;
nchannels = 1;
STREAMER_ERROR("error: for now we only implement stereo audio.\n");
return false;
}
else {
STREAMER_ERROR("error: invalid mode given for the AudioEncoder.\n");
return false;
}
if(settings.quality > 9) {
STREAMER_ERROR("error: invalid quality given for the AudioEncoder, use a value between 0 (best) and 9 (worst).\n");
return false;
}
lame_flags = lame_init();
if(!lame_flags) {
STREAMER_ERROR("error: cannot initalize lame.\n");
return false;
}
lame_set_num_channels(lame_flags, (mode == STEREO) ? 2 : 1);
lame_set_in_samplerate(lame_flags, samplerate);
lame_set_brate(lame_flags, settings.bitrate);
lame_set_VBR(lame_flags, vbr_off);
lame_set_mode(lame_flags, mode);
lame_set_quality(lame_flags, settings.quality);
if(lame_init_params(lame_flags) < 0) {
STREAMER_ERROR("error: cannot initialize the lame parameters.\n");
return false;
}
#if !defined(NDEBUG)
lame_print_config(lame_flags);
lame_print_internals(lame_flags);
STREAMER_VERBOSE("lame: bitrate: %d\n", lame_get_brate(lame_flags));
#endif
bitrate_time_started = uv_hrtime();
bitrate_timeout = bitrate_time_started + bitrate_delay;
return true;
}
