int enclameInit( hb_work_object_t * w, hb_job_t * job )
{
hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
hb_audio_t * audio = w->audio;
w->private_data = pv;
pv->job = job;
hb_log( "enclame: opening libmp3lame" );
pv->lame = lame_init();
// use ABR
lame_set_scale( pv->lame, 32768.0 );
if( audio->config.out.compression_level >= 0 )
{
lame_set_quality( pv->lame, audio->config.out.compression_level );
}
if( audio->config.out.bitrate > 0 )
{
lame_set_VBR( pv->lame, vbr_abr );
lame_set_VBR_mean_bitrate_kbps( pv->lame, audio->config.out.bitrate );
}
else if( audio->config.out.quality >= 0 )
{
lame_set_brate( pv->lame, 0 );
lame_set_VBR( pv->lame, vbr_default );
lame_set_VBR_quality( pv->lame, audio->config.out.quality );
}
lame_set_in_samplerate( pv->lame, audio->config.out.samplerate );
lame_set_out_samplerate( pv->lame, audio->config.out.samplerate );
pv->out_discrete_channels = hb_mixdown_get_discrete_channel_count( audio->config.out.mixdown );
// Lame's default encoding mode is JOINT_STEREO. This subtracts signal
// that is "common" to left and right (within some threshold) and encodes
// it separately. This improves quality at low bitrates, but hurts
// imaging (channel separation) at higher bitrates. So if the bitrate
// is suffeciently high, use regular STEREO mode.
if ( pv->out_discrete_channels == 1 )
{
lame_set_mode( pv->lame, MONO );
lame_set_num_channels( pv->lame, 1 );
}
else if ( audio->config.out.bitrate >= 128 )
{
lame_set_mode( pv->lame, STEREO );
}
lame_init_params( pv->lame );
pv->input_samples = 1152 * pv->out_discrete_channels;
pv->output_bytes = LAME_MAXMP3BUFFER;
pv->buf = malloc( pv->input_samples * sizeof( float ) );
audio->config.out.samples_per_frame = 1152;
pv->list = hb_list_init();
pv->pts = -1;
return 0;
}
void AudioReader::exportAudioDataToMP3(const char* data)
{
QSettings settings;
emit TCMessage("Exporting MP3...");
int read, write;
FILE *pcm = fopen("TCTemp.wav", "wb");
fwrite(data,1,format.chunkSize,pcm);
fflush(pcm);
pcm = fopen("TCTemp.wav", "rb");
f = fopen(this->outfile.toLocal8Bit().constData(), "wb");
const int PCM_SIZE = 8192;
const int MP3_SIZE = 8192*2;
short int pcm_buffer[PCM_SIZE*2];
unsigned char mp3_buffer[MP3_SIZE];
lame_t lame = lame_init();
lame_set_in_samplerate(lame, format.SampleRate);
lame_set_VBR(lame, (vbr_mode)settings.value("vbr",0).toInt());
if(lame_get_VBR(lame)) {
lame_set_VBR_min_bitrate_kbps(lame,settings.value("min",128).toInt());
lame_set_VBR_max_bitrate_kbps(lame,settings.value("max",192).toInt());
}
else
{
lame_set_brate(lame,settings.value("min",128).toInt());
}
lame_set_num_channels(lame,(int)format.Channels);
lame_set_quality(lame,0);
if(format.Channels==1)lame_set_mode(lame,MONO);
else lame_set_mode(lame,STEREO);
lame_init_params(lame);
do {
if(!knock->running)break;
read = fread(pcm_buffer, 2*byte_size, PCM_SIZE, pcm);
fflush(f);
if (read == 0)
write = lame_encode_flush(lame, mp3_buffer, MP3_SIZE);
else
write = lame_encode_buffer_interleaved(lame, pcm_buffer, read, mp3_buffer, MP3_SIZE);
fwrite(mp3_buffer, write, 1, f);
fflush(f);
} while (read != 0);
lame_close(lame);
fclose(pcm);
if(unlink("TCTemp.wav")!=0) {
emit TCColor("color: red;");
emit TCMessage(QString("Error while removing TCTemp.wav"));
}
}
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;
}
MP3Encoder(UINT bitRate)
{
curBitRate = bitRate;
lgf = lame_init();
if(!lgf)
CrashError(TEXT("Unable to open mp3 encoder"));
lame_set_in_samplerate(lgf, App->GetSampleRateHz());
lame_set_out_samplerate(lgf, App->GetSampleRateHz());
lame_set_num_channels(lgf, 2);
lame_set_mode(lgf, STEREO);
lame_set_disable_reservoir(lgf, TRUE); //bit reservoir has to be disabled for seamless streaming
lame_set_VBR(lgf, vbr_off);
lame_set_brate(lgf, bitRate);
lame_init_params(lgf);
outputFrameSize = lame_get_framesize(lgf); //1152 usually
dwMP3MaxSize = DWORD(1.25*double(outputFrameSize*audioBlockSize) + 7200.0);
MP3OutputBuffer.SetSize(dwMP3MaxSize+1);
MP3OutputBuffer[0] = 0x2f;
bFirstPacket = true;
Log(TEXT("------------------------------------------"));
Log(TEXT("%s"), GetInfoString().Array());
}
int main(int argc, char** argv)
{
if(argc != 2)
{
printf("Usage: %s <wav file>\n", argv[0]);
exit(0);
}
lame_global_flags *gfp;
//set params
gfp = lame_init();
lame_set_num_channels(gfp,2);
lame_set_in_samplerate(gfp,44100);
lame_set_brate(gfp,128);
lame_set_mode(gfp,1);
lame_set_quality(gfp,2);
int ret_code = lame_init_params(gfp);
if(ret_code < 0)
{
printf("ret_code < 0\n");
exit(-1);
}
//read input file
int read, write;
FILE* pcm = fopen(argv[1], "rb");
char* outPath;
outPath = strdup(argv[1]);
sprintf(outPath+strlen(argv[1])-3, "mp3");
FILE* mp3 = fopen(outPath, "wb");
short int pcm_buffer[PCM_SIZE * 2];
unsigned char mp3_buffer[MP3_SIZE];
do
{
read = fread(pcm_buffer, 2*sizeof(short int), PCM_SIZE, pcm);
if(read == 0)
write = lame_encode_flush(gfp, mp3_buffer, MP3_SIZE);
else
write = lame_encode_buffer_interleaved(gfp, pcm_buffer, read, mp3_buffer, MP3_SIZE);
fwrite(mp3_buffer, write, sizeof (unsigned char), mp3);
}
while (read != 0);
lame_close(gfp);
fclose(mp3);
fclose(pcm);
exit(0);
}
bool LameAudioWriter::open_private()
{
m_fid = fopen(m_fileName.toUtf8().data(), "w+");
if (!m_fid) {
return false;
}
m_lameInfo->flags = lame_init();
if (m_lameInfo->flags == 0) {
PERROR("lame_init failed.");
return false;
}
if (m_channels == 1) {
lame_set_mode(m_lameInfo->flags, MONO);
}
lame_set_num_channels(m_lameInfo->flags, m_channels);
lame_set_in_samplerate(m_lameInfo->flags, m_rate);
lame_set_out_samplerate(m_lameInfo->flags, m_rate);
if(m_method == 0) {
// Constant Bitrate
lame_set_VBR(m_lameInfo->flags, vbr_off);
lame_set_brate(m_lameInfo->flags, m_maxBitrate);
}
else if (m_method == 1) {
// Average Bitrate
lame_set_VBR(m_lameInfo->flags, vbr_abr);
lame_set_VBR_mean_bitrate_kbps(m_lameInfo->flags, m_maxBitrate);
}
else if (m_method == 2) {
// Variable Bitrate (old)
lame_set_VBR(m_lameInfo->flags, vbr_default);
lame_set_VBR_min_bitrate_kbps(m_lameInfo->flags, m_minBitrate);
lame_set_VBR_max_bitrate_kbps(m_lameInfo->flags, m_maxBitrate);
}
else if (m_method == 3) {
// Variable Bitrate (new)
lame_set_VBR(m_lameInfo->flags, vbr_default);
lame_set_VBR_min_bitrate_kbps(m_lameInfo->flags, m_minBitrate);
lame_set_VBR_max_bitrate_kbps(m_lameInfo->flags, m_maxBitrate);
}
lame_set_quality(m_lameInfo->flags, m_quality);
//
// file options
//
lame_set_copyright(m_lameInfo->flags, false);
lame_set_original(m_lameInfo->flags, true);
lame_set_strict_ISO(m_lameInfo->flags, false);
lame_set_error_protection(m_lameInfo->flags, false);
return (lame_init_params(m_lameInfo->flags ) != -1);
}
long MP3_create(const char* format_parameters, amci_codec_fmt_info_t* format_description) {
mp3_coder_state* coder_state;
int ret_code;
coder_state = malloc(sizeof(mp3_coder_state));
if (!coder_state) {
ERROR("no memory for allocating mp3 coder state\n");
return -1;
}
DBG("MP3: creating lame %s\n", get_lame_version());
format_description[0].id = 0;
coder_state->gfp = lame_init();
if (!coder_state->gfp) {
ERROR("initialiting lame\n");
free(coder_state);
return -1;
}
lame_set_errorf(coder_state->gfp, &no_output);
lame_set_debugf(coder_state->gfp, &no_output);
lame_set_msgf(coder_state->gfp, &no_output);
lame_set_num_channels(coder_state->gfp,1);
lame_set_in_samplerate(coder_state->gfp,8000);
lame_set_brate(coder_state->gfp,16);
lame_set_mode(coder_state->gfp,3); // mono
lame_set_quality(coder_state->gfp,2); /* 2=high 5 = medium 7=low */
id3tag_init(coder_state->gfp);
id3tag_set_title(coder_state->gfp, "mp3 voicemail by iptel.org");
ret_code = lame_init_params(coder_state->gfp);
if (ret_code < 0) {
ERROR("lame encoder init failed: return code is %d\n", ret_code);
free(coder_state);
return -1;
}
#ifdef WITH_MPG123DECODER
coder_state->mpg123_h = mpg123_new(NULL, NULL);
if (!coder_state->mpg123_h) {
ERROR("initializing mpg123 decoder instance\n");
return -1;
}
/* suppress output */
mpg123_param(coder_state->mpg123_h, MPG123_FLAGS, MPG123_QUIET /* | MPG123_FORCE_MONO */,0);
/* mpg123_param(coder_state->mpg123_h, MPG123_VERBOSE, 0, 0); */
#endif
return (long)coder_state;
}
/*
* Class: com_example_mp3encodedemo_JNIMp3Encode
* Method: init
* Signature: (III)V
*/
JNIEXPORT void JNICALL Java_com_example_soundtouchdemo_JNIMp3Encode_init
(JNIEnv *env, jobject obj, jint channel, jint sampleRate, jint brate)
{
lame = lame_init();
lame_set_num_channels(lame, channel);
lame_set_in_samplerate(lame, sampleRate);
lame_set_brate(lame, brate);
lame_set_mode(lame, 1);
lame_set_quality(lame, 2);
lame_init_params(lame);
}
/* initialize the lame library */
static void mp3streamout_tilde_lame_init(t_mp3streamout *x)
{
int ret;
x->lgfp = lame_init(); /* set default parameters for now */
#ifdef _WIN32
/* load lame_enc.dll library */
HINSTANCE dll;
dll=LoadLibrary("lame_enc.dll");
if(dll==NULL)
{
error("mp3streamout~: error loading lame_enc.dll");
closesocket(x->x_fd);
x->x_fd = -1;
outlet_float(x->x_obj.ob_outlet, 0);
post("mp3streamout~: connection closed");
return;
}
#endif
{
const char *lameVersion = get_lame_version();
logpost(NULL, 4, "mp3streamout~ : using lame version : %s", lameVersion );
}
/* setting lame parameters */
lame_set_num_channels( x->lgfp, 2);
lame_set_in_samplerate( x->lgfp, sys_getsr() );
lame_set_out_samplerate( x->lgfp, x->x_samplerate );
lame_set_brate( x->lgfp, x->x_bitrate );
lame_set_mode( x->lgfp, x->x_mp3mode );
lame_set_quality( x->lgfp, x->x_mp3quality );
lame_set_emphasis( x->lgfp, 1 );
lame_set_original( x->lgfp, 1 );
lame_set_copyright( x->lgfp, 1 ); /* viva free music societies !!! */
lame_set_disable_reservoir( x->lgfp, 0 );
//lame_set_padding_type( x->lgfp, PAD_NO ); /* deprecated in LAME */
ret = lame_init_params( x->lgfp );
if ( ret<0 )
{
post( "mp3streamout~ : error : lame params initialization returned : %d", ret );
}
else
{
x->x_lame=1;
/* magic formula copied from windows dll for MPEG-I */
x->x_lamechunk = 2*1152;
post( "mp3streamout~ : lame initialization done. (%d)", x->x_lame );
}
lame_init_bitstream( x->lgfp );
}
/* DEPRECATED */
int
lame_set_mode_automs( lame_global_flags* gfp,
int mode_automs )
{
/* default = 0 (disabled) */
/* enforce disable/enable meaning, if we need more than two values
we need to switch to an enum to have an apropriate representation
of the possible meanings of the value */
if ( 0 > mode_automs || 1 < mode_automs )
return -1;
lame_set_mode( gfp, JOINT_STEREO );
return 0;
}
void Java_mobi_cangol_mobile_utils_LameUtils_initEncoder(JNIEnv *env,
jobject jobj, jint in_num_channels, jint in_samplerate, jint in_brate,
jint in_mode, jint in_quality) {
lame = lame_init();
LOGD("Init parameters:",NULL);
lame_set_num_channels(lame, in_num_channels);
LOGD("Number of channels: %d", in_num_channels);
lame_set_in_samplerate(lame, in_samplerate);
LOGD("Sample rate: %d", in_samplerate);
lame_set_brate(lame, in_brate);
LOGD("Bitrate: %d", in_brate);
lame_set_mode(lame, in_mode);
LOGD("Mode: %d", in_mode);
lame_set_quality(lame, in_quality);
LOGD("Quality: %d", in_quality);
int res = lame_init_params(lame);
LOGD("Init returned: %d", res);
}
void Java_com_iliayugai_zapp_utils_CommonUtils_initEncoder(JNIEnv *env,
jobject jobj, jint in_num_channels, jint in_samplerate, jint in_brate,
jint in_mode, jint in_quality) {
lame = lame_init();
LOGD("Init parameters:");
lame_set_num_channels(lame, in_num_channels);
LOGD("Number of channels: %d", in_num_channels);
lame_set_in_samplerate(lame, in_samplerate);
LOGD("Sample rate: %d", in_samplerate);
lame_set_brate(lame, in_brate);
LOGD("Bitrate: %d", in_brate);
lame_set_mode(lame, in_mode);
LOGD("Mode: %d", in_mode);
lame_set_quality(lame, in_quality);
LOGD("Quality: %d", in_quality);
int res = lame_init_params(lame);
LOGD("Init returned: %d", res);
}
bool Mp3Writer::open(const QString &fn, long sr, bool s) {
bool b = AudioFileWriter::open(fn + ".mp3", sr, s);
if (!b)
return false;
lame = lame_init();
if (!lame)
return false;
bitRate = preferences.get(Pref::OutputFormatMp3Bitrate).toInt();
lame_set_in_samplerate(lame, sampleRate);
lame_set_num_channels(lame, stereo ? 2 : 1);
lame_set_out_samplerate(lame, sampleRate);
// TODO: do we need this?
lame_set_bWriteVbrTag(lame, 0);
lame_set_mode(lame, stereo ? STEREO : MONO);
lame_set_brate(lame, bitRate);
if (lame_init_params(lame) == -1)
return false;
return true;
}
int main (int argc, char **argv) {
char *url;
int brate = 32;
int c;
while ((c = getopt(argc, argv, "u:b:")) != -1)
switch (c) {
case 'u':
url = strdup(optarg);
break;
case 'b':
brate = atoi(optarg);
break;
default:
abort();
}
// libev
loop = ev_default_loop(0);
ev_signal_init(&sigint_sig, sigint_cb, SIGINT);
ev_signal_start (loop, &sigint_sig);
ev_async_init(&async, send_cb);
ev_async_start(loop, &async);
// jack
jack_status_t status;
ringbuf = jack_ringbuffer_create(buffer_size);
framebuf = malloc(buffer_samples * sizeof(jack_default_audio_sample_t));
client = jack_client_open("jack2rtmp", JackNullOption, &status);
if (client == NULL) {
fprintf(stderr, "jack server not running?\n");
return EXIT_FAILURE;
}
jack_on_shutdown(client, jack_shutdown, NULL);
jack_set_process_callback(client, jack_callback, NULL);
//jack_set_latency_callback(client, jack_latency_callback, NULL);
output_port = jack_port_register(client, "1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
//jack_port_register(client, "2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
if (jack_activate(client)) {
fprintf(stderr, "cannot activate client");
}
// lame
mp3 = lame_init();
lame_set_num_channels(mp3, 1);
lame_set_mode(mp3, MONO);
lame_set_in_samplerate(mp3, 48000);
lame_set_out_samplerate(mp3, 44100);
lame_set_quality(mp3, 2); // 0=best (very slow), 9=worst.
lame_set_brate(mp3, brate);
lame_init_params(mp3);
// rtmp
rtmp_o = RTMP_Alloc();
if (rtmp_o == NULL) {
fprintf(stderr, "RTMP_Alloc\n");
return EXIT_FAILURE;
}
RTMP_Init(rtmp_o);
RTMP_SetupURL(rtmp_o, url);
RTMP_EnableWrite(rtmp_o);
if (!RTMP_Connect(rtmp_o, NULL) || !RTMP_ConnectStream(rtmp_o, 0)) {
RTMP_Free(rtmp_o);
fprintf(stderr, "Can not connect.\n");
return EXIT_FAILURE;
} else {
fprintf(stderr, "Connected.\n");
}
/*
char *rtmp_buffer = malloc(4096);
char *rtmp_top = rtmp_buffer + RTMP_MAX_HEADER_SIZE;
char *outend = rtmp_buffer + 4096;
*rtmp_top = (uint8_t) AMF_STRING;
rtmp_top++;
rtmp_top = put_amf_string(rtmp_top, "@setDataFrame");
*rtmp_top = (uint8_t) AMF_STRING;
rtmp_top++;
rtmp_top = put_amf_string(rtmp_top, "onMetaData");
// описание объекта
*rtmp_top = (uint8_t) 8;
rtmp_top++;
rtmp_top = AMF_EncodeInt32(rtmp_top, outend, 8);
// содержимое объекта
rtmp_top = put_amf_string(rtmp_top, "duration");
rtmp_top = AMF_EncodeNumber(rtmp_top, outend, 0);
rtmp_top = put_amf_string(rtmp_top, "audiodatarate");
rtmp_top = AMF_EncodeNumber(rtmp_top, outend, brate);
rtmp_top = put_amf_string(rtmp_top, "audiosamplerate");
rtmp_top = AMF_EncodeNumber(rtmp_top, outend, 44100);
rtmp_top = put_amf_string(rtmp_top, "audiosamplesize");
rtmp_top = AMF_EncodeNumber(rtmp_top, outend, 16);
rtmp_top = put_amf_string(rtmp_top, "stereo");
rtmp_top = AMF_EncodeBoolean(rtmp_top, outend, FALSE);
rtmp_top = put_amf_string(rtmp_top, "audiocodecid");
rtmp_top = AMF_EncodeNumber(rtmp_top, outend, 2);
rtmp_top = put_amf_string(rtmp_top, "encoder");
*rtmp_top = (uint8_t) AMF_STRING;
rtmp_top++;
rtmp_top = put_amf_string(rtmp_top, "Lavf53.21.1");
rtmp_top = put_amf_string(rtmp_top, "filesize");
rtmp_top = AMF_EncodeNumber(rtmp_top, outend, 0);
// конец объекта
rtmp_top = put_amf_string(rtmp_top, "");
*rtmp_top = (uint8_t) AMF_OBJECT_END;
rtmp_top++;
rtmp_w.m_headerType = RTMP_PACKET_SIZE_LARGE;
rtmp_w.m_nChannel = 0x04; // source channel
rtmp_w.m_nBodySize = rtmp_top - rtmp_buffer - RTMP_MAX_HEADER_SIZE;
rtmp_w.m_packetType = RTMP_PACKET_TYPE_INFO;
rtmp_w.m_nInfoField2 = rtmp_o->m_stream_id;
rtmp_w.m_body = rtmp_buffer + RTMP_MAX_HEADER_SIZE;
if ( !RTMP_SendPacket(rtmp_o, &rtmp_w, TRUE) ) {
fprintf(stderr, "RTMP_SendPacket error\n");
}
free(rtmp_buffer);
*/
int off = 0;
setsockopt(RTMP_Socket(rtmp_o), SOL_TCP, TCP_NODELAY, &off, sizeof(off));
rtmp_i = TRUE;
ev_loop(loop, 0);
jack_ringbuffer_free(ringbuf);
//jack_client_close(client);
return EXIT_SUCCESS;
}
/*------------------------------------------------------------------------------
* 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;
}
void do_broadcast(switch_stream_handle_t *stream)
{
char *path_info = switch_event_get_header(stream->param_event, "http-path-info");
char *file;
lame_global_flags *gfp = NULL;
switch_file_handle_t fh = { 0 };
unsigned char mp3buf[TC_BUFFER_SIZE] = "";
uint8_t buf[1024];
int rlen;
int is_local = 0;
uint32_t interval = 20000;
if (strstr(path_info + 7, "://")) {
file = strdup(path_info + 7);
is_local++;
} else {
file = switch_mprintf("%s/streamfiles/%s", SWITCH_GLOBAL_dirs.base_dir, path_info + 7);
}
assert(file);
if (switch_core_file_open(&fh, file, 0, 0, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
memset(&fh, 0, sizeof(fh));
stream->write_function(stream, "Content-type: text/html\r\n\r\n<h2>File not found</h2>\n");
goto end;
}
if (switch_test_flag((&fh), SWITCH_FILE_NATIVE)) {
stream->write_function(stream, "Content-type: text/html\r\n\r\n<h2>File format not supported</h2>\n");
goto end;
}
if (!(gfp = lame_init())) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate lame\n");
goto end;
}
lame_set_num_channels(gfp, fh.channels);
lame_set_in_samplerate(gfp, fh.samplerate);
lame_set_brate(gfp, 16 * (fh.samplerate / 8000) * fh.channels);
lame_set_mode(gfp, 3);
lame_set_quality(gfp, 2);
lame_set_errorf(gfp, log_error);
lame_set_debugf(gfp, log_debug);
lame_set_msgf(gfp, log_msg);
lame_set_bWriteVbrTag(gfp, 0);
lame_mp3_tags_fid(gfp, NULL);
lame_init_params(gfp);
lame_print_config(gfp);
stream->write_function(stream, "Content-type: audio/mpeg\r\n" "Content-Disposition: inline; filename=\"%s.mp3\"\r\n\r\n", path_info + 7);
if (fh.interval) {
interval = fh.interval * 1000;
}
for (;;) {
switch_size_t samples = sizeof(buf) / 2;
switch_core_file_read(&fh, buf, &samples);
if (is_local) {
switch_yield(interval);
}
if (!samples) {
break;
}
if ((rlen = lame_encode_buffer(gfp, (void *) buf, NULL, samples, mp3buf, sizeof(mp3buf))) < 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "MP3 encode error %d!\n", rlen);
goto end;
}
if (rlen) {
if (stream->raw_write_function(stream, mp3buf, rlen)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Disconnected\n");
goto end;
}
}
}
while ((rlen = lame_encode_flush(gfp, mp3buf, sizeof(mp3buf))) > 0) {
if (stream->raw_write_function(stream, mp3buf, rlen)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Disconnected\n");
goto end;
}
}
end:
if (fh.channels) {
switch_core_file_close(&fh);
}
switch_safe_free(file);
if (gfp) {
lame_close(gfp);
gfp = NULL;
}
}
//////////////////////////////////////////////////////////////////////
// Init - initialized or reiniyialized encoder SDK with given input
// and output settings
//////////////////////////////////////////////////////////////////////
HRESULT CEncoder::Init()
{
CAutoLock l(&m_lock);
m_outOffset = 0;
m_outReadOffset = 0;
m_bFinished = FALSE;
m_frameCount = 0;
if (!pgf)
{
if (!m_bInpuTypeSet || !m_bOutpuTypeSet)
return E_UNEXPECTED;
// Init Lame library
// note: newer, safer interface which doesn't
// allow or require direct access to 'gf' struct is being written
// see the file 'API' included with LAME.
if (pgf = lame_init())
{
lame_set_num_channels(pgf, m_wfex.nChannels);
lame_set_in_samplerate(pgf, m_wfex.nSamplesPerSec);
lame_set_out_samplerate(pgf, m_mabsi.dwSampleRate);
if ((lame_get_out_samplerate(pgf) >= 32000) && (m_mabsi.dwBitrate < 32))
lame_set_brate(pgf, 32);
else
lame_set_brate(pgf, m_mabsi.dwBitrate);
lame_set_VBR(pgf, m_mabsi.vmVariable);
lame_set_VBR_min_bitrate_kbps(pgf, m_mabsi.dwVariableMin);
lame_set_VBR_max_bitrate_kbps(pgf, m_mabsi.dwVariableMax);
lame_set_copyright(pgf, m_mabsi.bCopyright);
lame_set_original(pgf, m_mabsi.bOriginal);
lame_set_error_protection(pgf, m_mabsi.bCRCProtect);
lame_set_bWriteVbrTag(pgf, m_mabsi.dwXingTag);
lame_set_strict_ISO(pgf, m_mabsi.dwStrictISO);
lame_set_VBR_hard_min(pgf, m_mabsi.dwEnforceVBRmin);
if (lame_get_num_channels(pgf) == 2 && !m_mabsi.bForceMono)
{
//int act_br = pgf->VBR ? pgf->VBR_min_bitrate_kbps + pgf->VBR_max_bitrate_kbps / 2 : pgf->brate;
// Disabled. It's for user's consideration now
//int rel = pgf->out_samplerate / (act_br + 1);
//pgf->mode = rel < 200 ? m_mabsi.ChMode : JOINT_STEREO;
lame_set_mode(pgf, m_mabsi.ChMode);
}
else
lame_set_mode(pgf, MONO);
if (lame_get_mode(pgf) == JOINT_STEREO)
lame_set_force_ms(pgf, m_mabsi.dwForceMS);
else
lame_set_force_ms(pgf, 0);
// pgf->mode_fixed = m_mabsi.dwModeFixed;
if (m_mabsi.dwVoiceMode != 0)
{
lame_set_lowpassfreq(pgf,12000);
///pgf->VBR_max_bitrate_kbps = 160;
}
if (m_mabsi.dwKeepAllFreq != 0)
{
///pgf->lowpassfreq = -1;
///pgf->highpassfreq = -1;
/// not available anymore
}
lame_set_quality(pgf, m_mabsi.dwQuality);
lame_set_VBR_q(pgf, m_mabsi.dwVBRq);
lame_init_params(pgf);
// encoder delay compensation
{
int const nch = lame_get_num_channels(pgf);
short * start_padd = (short *)calloc(48, nch * sizeof(short));
int out_bytes = 0;
if (nch == 2)
out_bytes = lame_encode_buffer_interleaved(pgf, start_padd, 48, m_outFrameBuf, OUT_BUFFER_SIZE);
else
out_bytes = lame_encode_buffer(pgf, start_padd, start_padd, 48, m_outFrameBuf, OUT_BUFFER_SIZE);
if (out_bytes > 0)
m_outOffset += out_bytes;
free(start_padd);
}
return S_OK;
}
return E_FAIL;
}
return S_OK;
}
/*------------------------------------------------------------------------------
* 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;
}
//core function to encide WAV to MP3, relying on LAME library
void encode(char* wavFilePath, char* mp3FilePath) {
FILE* wavFile = fopen(wavFilePath, "rb");
FILE* mp3File = fopen(mp3FilePath, "wb+");
int readPCMSampleCount;
short int pcmBuffer[PCM_BUF_SIZE];
unsigned char mp3Buffer[MP3_BUF_SIZE];
unsigned short channel;
unsigned long sampleRate;
unsigned short blockAlign;
lame_t lame = lame_init();
if((wavFile == NULL) || (mp3File == NULL)) {
printErrorMessage(FILE_IO_EXCEPTION);
return;
}
if(lame == NULL) {
printErrorMessage(LAME_API_ERROR);
return;
}
//Set number of channels
else if(fseek(wavFile, 22, SEEK_SET) != 0) {
printErrorMessage(FILE_IO_EXCEPTION);
return;
}
else if(fread(&channel, 2, 1, wavFile) < 1) {
printErrorMessage(FILE_IO_EXCEPTION);
return;
}
else {
lame_set_num_channels(lame, channel);
lame_set_mode(lame, (channel == 1) ? MONO : JOINT_STEREO);
}
//Set number of sample rate
if(fseek(wavFile, 24, SEEK_SET) != 0) {
printErrorMessage(FILE_IO_EXCEPTION);
return;
}
else if(fread(&sampleRate, 4, 1, wavFile) < 1) {
printErrorMessage(FILE_IO_EXCEPTION);
return;
}
else {
lame_set_in_samplerate(lame, sampleRate);
lame_set_out_samplerate(lame, sampleRate);
}
//Set block align (byte/sample)
if(fseek(wavFile, 32, SEEK_SET) != 0) {
printErrorMessage(FILE_IO_EXCEPTION);
return;
}
else if(fread(&blockAlign, 4, 1, wavFile) < 1) {
printErrorMessage(FILE_IO_EXCEPTION);
return;
}
//Look for data chank in the WAV file
if(fseek(wavFile, 36, SEEK_SET) != 0) {
printErrorMessage(FILE_IO_EXCEPTION);
return;
}
else {
char data[5];
data[4] = '\0';
while(fread(data, 4, 1, wavFile) == 1) {
if(strcmp(data, "data") != 0) {
//Search data chank by 1 byte
fseek(wavFile, -3, SEEK_CUR);
continue;
}
else if(fseek(wavFile, 4, SEEK_CUR)) {
//data chank was found, then skip next 4 byte(indicating data size) to proceed
printErrorMessage(FILE_IO_EXCEPTION);
return;
}
else {
//Now we are pointing the head of the PCM data, let's proceed
break;
}
}
//If data chank cannot be detected
if(feof(wavFile)) {
printErrorMessage(NOT_WAV_HEADER);
return;
}
}
//Encoding conficuration with "good" level quality
lame_set_quality(lame, 5);
lame_set_VBR(lame, vbr_default);
lame_set_VBR_q(lame, 5);
if(lame_init_params(lame) == -1) {
printErrorMessage(LAME_API_ERROR);
return;
}
//Perfoem encoding
do {
int encodedSampleCount;
readPCMSampleCount = fread(pcmBuffer, blockAlign, PCM_BUF_SIZE / blockAlign, wavFile);
if(readPCMSampleCount != 0) {
if(channel == 1) { //For monoral case
short int pcmBufferRight[PCM_BUF_SIZE];
short int pcmBufferLeft[PCM_BUF_SIZE];
int i;
for(i = 0; i < PCM_BUF_SIZE; i++) {
pcmBufferRight[i] = pcmBuffer[i];
pcmBufferLeft[i] = pcmBuffer[i];
}
encodedSampleCount = lame_encode_buffer(lame, pcmBufferLeft, pcmBufferRight, readPCMSampleCount, mp3Buffer, MP3_BUF_SIZE);
}
else { //For stereo case
encodedSampleCount = lame_encode_buffer_interleaved(lame, pcmBuffer, readPCMSampleCount, mp3Buffer, MP3_BUF_SIZE);
}
}
else {
encodedSampleCount = lame_encode_flush(lame, mp3Buffer, MP3_BUF_SIZE);
}
if(encodedSampleCount < 0) {
printErrorMessage(LAME_API_ERROR);
}
else {
fwrite(mp3Buffer, encodedSampleCount, 1, mp3File);
}
} while(readPCMSampleCount != 0);
lame_close(lame);
fclose(wavFile);
fclose(mp3File);
}
void lame_encoder_impl_internal::set_stereo_mode(lame_encoder_impl_internal::StereoMode _Mode)
{
int lameRet = lame_set_mode(m_Lame.get(), (MPEG_mode)_Mode);
DT_LAME_CHECK_ERR(lameRet);
}
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;
}
bool AUDMEncoder_Lame::initialize (void)
{
int ret;
MPEG_mode_e mmode;
uint32_t frequence;
lameFlags = lame_init ();
if (lameFlags == NULL)
return false;
if (_incoming->getInfo ()->channels > 2)
{
printf ("[Lame]Too many channels\n");
return false;
}
// recompute output length
ret = lame_set_in_samplerate (MYFLAGS, wavheader.frequency);
ret = lame_set_num_channels (MYFLAGS, wavheader.channels);
frequence = wavheader.frequency;
printf ("[Lame] output frequency : %"PRIu32"\n", frequence);
ret = lame_set_out_samplerate (MYFLAGS, frequence);
ret = lame_set_quality (MYFLAGS, 2);
if (wavheader.channels == 2)
{
mmode = STEREO;
}
else
{
mmode = MONO;
printf ("[Lame] mono audio mp3");
}
ret = lame_set_brate (MYFLAGS, _config.bitrate);
ret = lame_set_mode (MYFLAGS, mmode); // 0 stereo 1 jstero
ret = lame_set_quality (MYFLAGS, _config.quality); // 0 stereo 1 jstero
ret = lame_set_disable_reservoir (MYFLAGS, _config.disableBitReservoir);
printf ("[Lame]Using quality of %d\n", lame_get_quality (MYFLAGS));
// update bitrate in header
wavheader.byterate = (_config.bitrate >> 3) * 1000;
#define BLOCK_SIZE 1152
// configure CBR/ABR/...
switch (_config.preset)
{
default:
case ADM_LAME_PRESET_CBR:
ADM_info("Lame : CBR Mode\n");
break;
case ADM_LAME_PRESET_ABR:
ADM_info("Lame : ABR Mode\n");
lame_set_preset (MYFLAGS, _config.bitrate);
wavheader.blockalign = BLOCK_SIZE;
break;
case ADM_LAME_PRESET_EXTREME:
ADM_info("Lame : Extreme Mode\n");
wavheader.blockalign = BLOCK_SIZE;
lame_set_preset (MYFLAGS, EXTREME);
break;
}
ret = lame_init_params (MYFLAGS);
if (ret == -1)
{
printf("[Lame] Init params failes %d\n",ret);
return false;
}
lame_print_config (MYFLAGS);
lame_print_internals (MYFLAGS);
_chunk = BLOCK_SIZE * wavheader.channels;
return true;
}
bool WaveEncoder::ToMP3(const std::string &destFileName)
{
FILE *pcm = fopen(m_source.c_str(), "rb");
FILE *mp3 = fopen(destFileName.c_str(), "wb");
fseek(pcm, 0, SEEK_END);
float pcm_length = ftell(pcm);
float pcm_read = 0;
int percentage = 0;
fseek(pcm, 0, SEEK_SET);
if(pcm == 0 || mp3 == 0)
{
m_lastErrorMessage = "Failed to open output stream.";
return false;
}
int read, write;
const int PCM_SIZE = 8192;
const int MP3_SIZE = 8192;
short int pcm_buffer[PCM_SIZE*2];
unsigned char mp3_buffer[MP3_SIZE];
lame_t lame = lame_init();
lame_set_num_channels(lame, 2);
if(m_quality == 3)
{
lame_set_in_samplerate(lame, 48000);
lame_set_brate(lame, 320);
lame_set_quality(lame, 2);
}
else if(m_quality == 2)
{
lame_set_in_samplerate(lame, 48000);
lame_set_brate(lame, 192);
lame_set_quality(lame, 5);
}
else if(m_quality == 1)
{
lame_set_in_samplerate(lame, 48000);
lame_set_brate(lame, 128);
lame_set_quality(lame, 7);
}
lame_set_mode(lame, JOINT_STEREO);
lame_init_params(lame);
printf("0%%");
do
{
read = fread(pcm_buffer, 2*sizeof(short int), PCM_SIZE, pcm);
if (read == 0)
write = lame_encode_flush(lame, mp3_buffer, MP3_SIZE);
else
write = lame_encode_buffer_interleaved(lame, pcm_buffer, read, mp3_buffer, MP3_SIZE);
fwrite(mp3_buffer, write, 1, mp3);
pcm_read += PCM_SIZE * 2 * sizeof(short int);
if(percentage < 10)
printf("\b\b");
else if(percentage < 100)
printf("\b\b\b");
else printf("\b\b\b\b");
percentage = (int)(pcm_read / pcm_length * 100.f);
printf("%d%%", percentage);
} while (read != 0);
lame_close(lame);
fclose(mp3);
fclose(pcm);
return true;
}
int64_t mp3_open(const char* name, speex_info* info){
if(info == NULL){
return -1;
}
assert(info->sps == 8000 && info->bps == 16);
assert(info->mode >= 0 && info->mode <= 10);
assert(info->nr_chans == 1 || info->nr_chans == 2);
lame_global_flags* gfp = lame_init();
if(gfp == NULL){
return -1;
}
lame_set_num_channels(gfp, info->nr_chans);
lame_set_in_samplerate(gfp, info->sps);
lame_set_brate(gfp, 128);
if(info->nr_chans == 1){
lame_set_mode(gfp, MONO);
}else if(info->nr_chans == 2){
lame_set_mode(gfp, STEREO);
}
lame_set_quality(gfp, 5);
int32_t frame_len;
FILE* file = NULL;
char* obj_addr;
unsigned int bytes;
mp3_file* ptr;
int n = lame_init_params(gfp);
if(n == -1){
goto LABEL1;
}
frame_len = 1.25 * speex_frame_samples + 7200;
n = sizeof(mp3_file) + sizeof(CSpeexDecoder) + frame_len;
ptr = (mp3_file *) malloc(n);
if(ptr == NULL){
goto LABEL1;
}
bytes = speex_bytes[info->nr_chans - 1][info->mode];
obj_addr = (char *) (ptr + 1);
ptr->dec = new (obj_addr) CSpeexDecoder(bytes, info->sps, info->nr_chans, info->bps);
if(!ptr->dec->Start()){
goto LABEL0;
}
ptr->gfp = gfp;
ptr->length = frame_len;
ptr->frame = (char *) (ptr->dec + 1);
if(name){
file = fopen(name, "wb");
if(file == NULL){
goto LABEL0;
}
}
ptr->file = file;
info->bytes = bytes;
return (int64_t) ptr;
LABEL0:
ptr->dec->~CSpeexDecoder();
free(ptr);
LABEL1:
lame_close(gfp);
return -1;
}
int mp3_encode(int fd_in, int fd_out) {
lame_global_flags *gfp;
uint32_t i, j, k, count;
int16_t *b0 = 0, *b1 = 0;
unsigned char *c;
int ret;
/* calculate data size*/
k = (uint32_t) lseek(fd_in, 0, SEEK_CUR);
i = (uint32_t) lseek(fd_in, 0, SEEK_END);
lseek(fd_in, k, SEEK_SET);
i -= k;
k = 0;
gfp = lame_init();
lame_set_errorf(gfp,lame_error_handler);
lame_set_debugf(gfp,lame_error_handler);
lame_set_msgf(gfp,lame_error_handler);
lame_set_num_channels(gfp,2);
lame_set_in_samplerate(gfp,8000);
#if 0
lame_set_brate(gfp,64); /* compress 1:4 */
lame_set_mode(gfp,0); /* mode = stereo */
lame_set_quality(gfp,2); /* 2=high 5 = medium 7=low */
#else
lame_set_quality(gfp,5); /* 2=high 5 = medium 7=low */
lame_set_mode(gfp,3); /* mode = mono */
if(lame_get_VBR(gfp) == vbr_off) lame_set_VBR(gfp, vbr_default);
lame_set_VBR_quality(gfp, 7.0);
lame_set_findReplayGain(gfp, 0);
lame_set_bWriteVbrTag(gfp, 1);
lame_set_out_samplerate(gfp,11025);
/* lame_set_num_samples(gfp,i/2); */
#endif
if(lame_init_params(gfp) < 0) {
log_err("encode: failed to init lame");
return 0;
}
#define CHSZ (512*1024)
#define OCHSZ (5*(CHSZ/8)+7200)
b0 = (int16_t *) malloc(OCHSZ);
b1 = (int16_t *) malloc(CHSZ);
if(!b0 || !b1) {
log_err("encode: out of memory");
if(b0) free(b0);
if(b1) free(b1);
return 0;
}
do {
ret = 0; j = 0; count = 0;
for(c = (unsigned char*) b1; count < CHSZ; c += ret) {
j = (k + RSZ > i) ? i - k : RSZ;
ret = read(fd_in,c,j);
if(ret < 0) break;
k += ret; count += ret;
if(k == i) break;
}
if(ret < 0) break;
if(count) {
ret = lame_encode_buffer(gfp,b1,b1,count/2,(unsigned char *)b0,OCHSZ);
if(ret < 0) break;
c = (unsigned char *) b0;
count = ret;
for(j = 0; j < count; j += RSZ, c += ret) {
ret = (j + RSZ > count) ? count - j : RSZ;
write(fd_out,c,ret);
}
}
} while(k < i);
k = (uint32_t) lame_encode_flush(gfp,(unsigned char *)b0,OCHSZ);
if(k) write(fd_out,b0,k);
k = lame_get_lametag_frame(gfp,(unsigned char *)b0,OCHSZ);
if(k > 0) write(fd_out,b0,k);
lame_close(gfp);
free(b0);
free(b1);
return 1;
}
/* initialize the lame library */
static int mp3write_tilde_lame_init(t_mp3write *x)
{
time_t now;
int ret;
x->lgfp = lame_init(); /* set default parameters for now */
#ifndef UNIX
/* load lame_enc.dll library */
HINSTANCE dll;
dll=LoadLibrary("lame_enc.dll");
if(dll==NULL)
{
error("mp3write~: error loading lame_enc.dll");
closesocket(x->x_fd);
x->x_fd = -1;
post("mp3write~: connection closed");
return -1;
}
#endif
{
const char *lameVersion = get_lame_version();
post( "mp3write~ : using lame version : %s", lameVersion );
}
/* setting lame parameters */
lame_set_num_channels( x->lgfp, 2);
lame_set_in_samplerate( x->lgfp, sys_getsr() );
lame_set_out_samplerate( x->lgfp, x->x_samplerate );
lame_set_brate( x->lgfp, x->x_bitrate );
lame_set_mode( x->lgfp, x->x_mp3mode );
lame_set_quality( x->lgfp, x->x_mp3quality );
lame_set_emphasis( x->lgfp, 1 );
lame_set_original( x->lgfp, 1 );
lame_set_copyright( x->lgfp, 1 ); /* viva free music societies !!! */
lame_set_disable_reservoir( x->lgfp, 0 );
lame_set_padding_type( x->lgfp, PAD_NO );
ret = lame_init_params( x->lgfp );
if ( ret<0 ) {
post( "mp3write~ : error : lame params initialization returned : %d", ret );
return -1;
} else {
x->x_lame=1;
/* magic formula copied from windows dll for MPEG-I */
x->x_lamechunk = 2*1152;
post( "mp3write~ : lame initialization done. (%d)", x->x_lame );
}
lame_init_bitstream( x->lgfp );
/* setting tag information */
id3tag_init(x->lgfp);
id3tag_v1_only(x->lgfp);
id3tag_space_v1(x->lgfp);
id3tag_set_artist(x->lgfp, "Pd Session");
now=time(NULL);
sprintf( x->x_title, "Started at %s", ctime(&now) );
id3tag_set_title(x->lgfp, x->x_title );
return 0;
}
void do_telecast(switch_stream_handle_t *stream)
{
char *path_info = switch_event_get_header(stream->param_event, "http-path-info");
char *uuid = strdup(path_info + 4);
switch_core_session_t *tsession;
char *fname = "stream.mp3";
if ((fname = strchr(uuid, '/'))) {
*fname++ = '\0';
}
if (!(tsession = switch_core_session_locate(uuid))) {
char *ref = switch_event_get_header(stream->param_event, "http-referer");
stream->write_function(stream, "Content-type: text/html\r\n\r\n<h2>Not Found!</h2>\n" "<META http-equiv=\"refresh\" content=\"1;URL=%s\">", ref);
} else {
switch_media_bug_t *bug = NULL;
switch_buffer_t *buffer = NULL;
switch_mutex_t *mutex;
switch_channel_t *channel = switch_core_session_get_channel(tsession);
lame_global_flags *gfp = NULL;
switch_codec_implementation_t read_impl = { 0 };
switch_core_session_get_read_impl(tsession, &read_impl);
if (switch_channel_test_flag(channel, CF_PROXY_MODE)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Stepping into media path so this will work!\n");
switch_ivr_media(uuid, SMF_REBRIDGE);
}
if (!(gfp = lame_init())) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate lame\n");
goto end;
}
lame_set_num_channels(gfp, read_impl.number_of_channels);
lame_set_in_samplerate(gfp, read_impl.actual_samples_per_second);
lame_set_brate(gfp, 16 * (read_impl.actual_samples_per_second / 8000) * read_impl.number_of_channels);
lame_set_mode(gfp, 3);
lame_set_quality(gfp, 2);
lame_set_errorf(gfp, log_error);
lame_set_debugf(gfp, log_debug);
lame_set_msgf(gfp, log_msg);
lame_set_bWriteVbrTag(gfp, 0);
lame_mp3_tags_fid(gfp, NULL);
lame_init_params(gfp);
lame_print_config(gfp);
switch_mutex_init(&mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(tsession));
switch_buffer_create_dynamic(&buffer, 1024, 2048, 0);
switch_buffer_add_mutex(buffer, mutex);
if (switch_core_media_bug_add(tsession, "telecast", NULL,
telecast_callback, buffer, 0,
SMBF_READ_STREAM | SMBF_WRITE_STREAM | SMBF_READ_PING, &bug) != SWITCH_STATUS_SUCCESS) {
goto end;
}
stream->write_function(stream, "Content-type: audio/mpeg\r\n" "Content-Disposition: inline; filename=\"%s\"\r\n\r\n", fname);
while (switch_channel_ready(channel)) {
unsigned char mp3buf[TC_BUFFER_SIZE] = "";
int rlen;
uint8_t buf[1024];
switch_size_t bytes = 0;
if (switch_buffer_inuse(buffer) >= 1024) {
switch_buffer_lock(buffer);
bytes = switch_buffer_read(buffer, buf, sizeof(buf));
switch_buffer_unlock(buffer);
} else {
if (!bytes) {
switch_cond_next();
continue;
}
memset(buf, 0, bytes);
}
if ((rlen = lame_encode_buffer(gfp, (void *) buf, NULL, bytes / 2, mp3buf, sizeof(mp3buf))) < 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "MP3 encode error %d!\n", rlen);
goto end;
}
if (rlen) {
if (stream->raw_write_function(stream, mp3buf, rlen)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Disconnected\n");
goto end;
}
}
}
end:
switch_safe_free(uuid);
if (gfp) {
lame_close(gfp);
gfp = NULL;
}
if (bug) {
switch_core_media_bug_remove(tsession, &bug);
}
if (buffer) {
switch_buffer_destroy(&buffer);
}
switch_core_session_rwunlock(tsession);
}
}
//________________________________________________
// Init lame encoder
// frequence : Impose frequency , 0 means reuse the incoming fq
// mode : ADM_STEREO etc...
// bitrate : Bitrate in kbps (96,192...)
// return 0 : init failed
// 1 : init succeeded
//_______________________________________________
uint8_t AVDMProcessAudio_Lame::initLame(uint32_t frequence,
uint32_t mode,
uint32_t bitrate,
ADM_LAME_PRESET preset)
{
int ret, ratio;
MPEG_mode_e mmode;
double dratio;
myflags = lame_init();
if (myflags == NULL)
return 0;
// recompute output length
// since we compress recompute the length in bytes
double comp;
comp=_instream->getLength();
comp/=2; // 16 bits sample
comp/=_wavheader->channels; // We got sample
comp/=_wavheader->frequency; // and no we got seconds
comp*=bitrate*1000;
comp/=8; // now we got bytes
_length=(uint32_t) floor(comp+1);
printf("Incoming : %lu bytes, fq : %lu, channel : %lu bitrate: %lu outgoing : %lu\n",
_instream->getLength(),_wavheader->frequency,_wavheader->channels,bitrate,_length);
//initLame(frequence,mode,bitrate);
ret = lame_set_in_samplerate(myflags, _instream->getInfo()->frequency);
ret = lame_set_num_channels(myflags, _instream->getInfo()->channels);
if (frequence == 0) // keep same as instream
frequence = _instream->getInfo()->frequency;
printf("\n output frequency : %lu\n", frequence);
ret = lame_set_out_samplerate(myflags, frequence);
ret = lame_set_quality(myflags, 2); //max quality);
if (_instream->getInfo()->channels == 2)
{
switch (mode)
{
case ADM_STEREO:
mmode = STEREO;
break;
case ADM_JSTEREO:
mmode = JOINT_STEREO;
break;
default:
printf("\n **** unknown mode ***\n");
mmode = STEREO;
break;
}
} else
{
mmode = MONO;
printf("\n mono audio mp3");
}
_mode=mmode;
ret = lame_set_brate(myflags, bitrate);
ret = lame_set_mode(myflags, mmode); // 0 stereo 1 jstero
ret = lame_init_params(myflags);
if (ret == -1)
return 0;
// update bitrate in header
_wavheader->byterate = (bitrate >> 3) * 1000;
// configure CBR/ABR/...
_preset=preset;
switch(preset)
{
default:
case ADM_LAME_PRESET_CBR: break;
case ADM_LAME_PRESET_ABR:
lame_set_preset( myflags, bitrate);
_wavheader->blockalign=1152;
break;
case ADM_LAME_PRESET_EXTREME:
_wavheader->blockalign=1152;
lame_set_preset( myflags, EXTREME);
break;
}
lame_print_config(myflags);
lame_print_internals(myflags);
return 1;
}
static switch_status_t shout_file_open(switch_file_handle_t *handle, const char *path)
{
shout_context_t *context;
char *host, *file;
char *username, *password, *port;
char *err = NULL;
const char *mpg123err = NULL;
int portno = 0;
if ((context = switch_core_alloc(handle->memory_pool, sizeof(*context))) == 0) {
return SWITCH_STATUS_MEMERR;
}
if (!handle->samplerate) {
handle->samplerate = 8000;
}
context->memory_pool = handle->memory_pool;
context->samplerate = handle->samplerate;
context->handle = handle;
switch_thread_rwlock_create(&(context->rwlock), context->memory_pool);
switch_thread_rwlock_rdlock(context->rwlock);
switch_mutex_init(&context->audio_mutex, SWITCH_MUTEX_NESTED, context->memory_pool);
if (switch_test_flag(handle, SWITCH_FILE_FLAG_READ)) {
if (switch_buffer_create_dynamic(&context->audio_buffer, TC_BUFFER_SIZE, TC_BUFFER_SIZE * 2, 0) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n");
goto error;
}
context->mh = our_mpg123_new(NULL, NULL);
if (mpg123_format_all(context->mh) != MPG123_OK) {
MPGERROR();
}
if (mpg123_param(context->mh, MPG123_FORCE_RATE, context->samplerate, 0) != MPG123_OK) {
MPGERROR();
}
if (handle->handler) {
if (mpg123_param(context->mh, MPG123_FLAGS, MPG123_SEEKBUFFER | MPG123_MONO_MIX, 0) != MPG123_OK) {
MPGERROR();
}
if (mpg123_open_feed(context->mh) != MPG123_OK) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening mpg feed\n");
mpg123err = mpg123_strerror(context->mh);
goto error;
}
context->stream_url = switch_core_sprintf(context->memory_pool, "http://%s", path);
context->prebuf = handle->prebuf;
launch_read_stream_thread(context);
} else {
handle->seekable = 1;
if (mpg123_param(context->mh, MPG123_FLAGS, MPG123_MONO_MIX, 0) != MPG123_OK) {
MPGERROR();
}
if (mpg123_open(context->mh, path) != MPG123_OK) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening %s\n", path);
mpg123err = mpg123_strerror(context->mh);
goto error;
}
}
} else if (switch_test_flag(handle, SWITCH_FILE_FLAG_WRITE)) {
if (switch_test_flag(handle, SWITCH_FILE_WRITE_APPEND)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Appending to MP3 not supported.\n");
}
if (!(context->gfp = lame_init())) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate lame\n");
goto error;
}
if (!handle->handler) {
id3tag_init(context->gfp);
id3tag_v2_only(context->gfp);
id3tag_pad_v2(context->gfp);
}
context->channels = handle->channels;
lame_set_brate(context->gfp, 16 * (handle->samplerate / 8000) * handle->channels);
lame_set_num_channels(context->gfp, handle->channels);
lame_set_in_samplerate(context->gfp, handle->samplerate);
lame_set_out_samplerate(context->gfp, handle->samplerate);
if (handle->channels == 2) {
lame_set_mode(context->gfp, STEREO);
} else {
lame_set_mode(context->gfp, MONO);
}
lame_set_quality(context->gfp, 2); /* 2=high 5 = medium 7=low */
lame_set_errorf(context->gfp, log_error);
lame_set_debugf(context->gfp, log_debug);
lame_set_msgf(context->gfp, log_msg);
if (handle->handler) {
if (switch_buffer_create_dynamic(&context->audio_buffer, MY_BLOCK_SIZE, MY_BUF_LEN, 0) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n");
goto error;
}
lame_set_bWriteVbrTag(context->gfp, 0);
lame_mp3_tags_fid(context->gfp, NULL);
username = switch_core_strdup(handle->memory_pool, path);
if (!(password = strchr(username, ':'))) {
err = "invalid url";
goto error;
}
*password++ = '\0';
if (!(host = strchr(password, '@'))) {
err = "invalid url";
goto error;
}
*host++ = '\0';
if ((file = strchr(host, '/'))) {
*file++ = '\0';
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid URL: %s\n", path);
goto error;
}
if ((port = strchr(host, ':'))) {
*port++ = '\0';
if (port) {
portno = atoi(port);
}
}
if (!portno) {
portno = 8000;
}
if (!(context->shout = shout_new())) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate shout_t\n");
goto error;
}
if (shout_set_host(context->shout, host) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting hostname: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_protocol(context->shout, SHOUT_PROTOCOL_HTTP) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting protocol: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_port(context->shout, portno) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting port: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_password(context->shout, password) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting password: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_mount(context->shout, file) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting mount: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_user(context->shout, username) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting user: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_url(context->shout, "http://www.freeswitch.org") != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting name: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_description(context->shout, "FreeSWITCH mod_shout Broadcasting Module") != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting description: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_audio_info(context->shout, "bitrate", "24000") != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting bitrate: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_format(context->shout, SHOUT_FORMAT_MP3) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting format: %s\n", shout_get_error(context->shout));
goto error;
}
} else {
/* lame being lame and all has FILE * coded into it's API for some functions so we gotta use it */
if (!(context->fp = fopen(path, "wb+"))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening %s\n", path);
goto error;
}
}
}
handle->samples = 0;
handle->format = 0;
handle->sections = 0;
handle->speed = 0;
handle->private_info = context;
switch_thread_rwlock_unlock(context->rwlock);
return SWITCH_STATUS_SUCCESS;
error:
switch_thread_rwlock_unlock(context->rwlock);
if (err) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: %s\n", err);
}
if (mpg123err) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error from mpg123: %s\n", mpg123err);
}
free_context(context);
return SWITCH_STATUS_GENERR;
}
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;
}