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;
}
//________________________________________________
// 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;
}
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;
}
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);
}
}
}
//________________________________________________
// 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 AUDMEncoder_Lame::init(ADM_audioEncoderDescriptor *config)
{
int ret;
MPEG_mode_e mmode;
uint32_t frequence;
LAME_encoderParam *lameConf=(LAME_encoderParam *)config->param;
ADM_assert(config->paramSize==sizeof(LAME_encoderParam));
lameFlags = lame_init();
if (lameFlags == NULL)
return 0;
if(_incoming->getInfo()->channels>2)
{
printf("Too many channels\n");
return 0;
}
// recompute output length
ret = lame_set_in_samplerate(MYFLAGS, _wavheader->frequency);
ret = lame_set_num_channels(MYFLAGS, _wavheader->channels);
frequence = _wavheader->frequency;
printf("\n output frequency : %lu\n", frequence);
ret = lame_set_out_samplerate(MYFLAGS, frequence);
ret = lame_set_quality(MYFLAGS, 2);
if (_wavheader->channels == 2)
{
switch (lameConf->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");
}
ret = lame_set_brate(MYFLAGS, config->bitrate);
ret = lame_set_mode(MYFLAGS, mmode); // 0 stereo 1 jstero
ret = lame_set_quality(MYFLAGS, lameConf->quality); // 0 stereo 1 jstero
ret = lame_set_disable_reservoir(MYFLAGS,lameConf->disableReservoir);
printf("[Lame]Using quality of %d\n",lame_get_quality(MYFLAGS));
ret = lame_init_params(MYFLAGS);
if (ret == -1)
return 0;
// update bitrate in header
_wavheader->byterate = (config->bitrate >> 3) * 1000;
#define BLOCK_SIZE 1152
// configure CBR/ABR/...
_preset=lameConf->preset;
switch(_preset)
{
default:
case ADM_LAME_PRESET_CBR:
break;
case ADM_LAME_PRESET_ABR:
lame_set_preset( MYFLAGS, config->bitrate);
_wavheader->blockalign=BLOCK_SIZE;
break;
case ADM_LAME_PRESET_EXTREME:
_wavheader->blockalign=BLOCK_SIZE;
lame_set_preset( MYFLAGS, EXTREME);
break;
}
lame_print_config(MYFLAGS);
lame_print_internals(MYFLAGS);
_chunk=BLOCK_SIZE*_wavheader->channels;
return 1;
}
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;
}
