EmErrorCode LameEncoder::OpenOutput(const std::string& path)
{
m_OutputFile = ::fopen(path.c_str(), "wb+");
if (m_OutputFile == nullptr)
return ErrorCode::EncoderFailedToOpen;
// init lame
m_gfp = ::lame_init();
::lame_set_quality(m_gfp, m_Quality.userVal);
::lame_set_brate(m_gfp, m_BitRate.enumedVal[m_BitRate.userChoice]);
::lame_set_mode(m_gfp, ::JOINT_STEREO);
::lame_set_findReplayGain(m_gfp, m_ReplayGain.userChoice ? 1 : 0);
::lame_set_asm_optimizations(m_gfp, MMX, 1);
::lame_set_asm_optimizations(m_gfp, SSE, 1);
if (m_MediaTag != nullptr) {
lame_set_write_id3tag_automatic(m_gfp, 1);
id3tag_init(m_gfp);
id3tag_v2_only(m_gfp);
id3tag_set_title(m_gfp, m_MediaTag->title.c_str());
id3tag_set_artist(m_gfp, m_MediaTag->artist.c_str());
id3tag_set_album(m_gfp, m_MediaTag->album.c_str());
id3tag_set_comment(m_gfp, m_MediaTag->comment.c_str());
id3tag_set_genre(m_gfp, m_MediaTag->genre.c_str());
id3tag_set_year(m_gfp, scx::NumToStr(m_MediaTag->year).c_str());
id3tag_set_track(m_gfp, scx::NumToStr(m_MediaTag->track).c_str());
}
int ret = ::lame_init_params(m_gfp);
if (ret < 0)
return ErrorCode::EncoderFailedToInit;
return ErrorCode::Ok;
}
int
lame_main(lame_t gf, int argc, char **argv)
{
char inPath[PATH_MAX + 1];
char outPath[PATH_MAX + 1];
char nogapdir[PATH_MAX + 1];
/* support for "nogap" encoding of up to 200 .wav files */
#define MAX_NOGAP 200
int nogapout = 0;
int max_nogap = MAX_NOGAP;
char nogap_inPath_[MAX_NOGAP][PATH_MAX + 1];
char *nogap_inPath[MAX_NOGAP];
int ret;
int i;
FILE *outf;
lame_set_msgf(gf, &frontend_msgf);
lame_set_errorf(gf, &frontend_errorf);
lame_set_debugf(gf, &frontend_debugf);
if (argc <= 1) {
usage(stderr, argv[0]); /* no command-line args, print usage, exit */
return 1;
}
memset(inPath, 0, sizeof(inPath));
memset(nogap_inPath_, 0, sizeof(nogap_inPath_));
for (i = 0; i < MAX_NOGAP; ++i) {
nogap_inPath[i] = &nogap_inPath_[i][0];
}
/* parse the command line arguments, setting various flags in the
* struct 'gf'. If you want to parse your own arguments,
* or call libmp3lame from a program which uses a GUI to set arguments,
* skip this call and set the values of interest in the gf struct.
* (see the file API and lame.h for documentation about these parameters)
*/
ret = parse_args(gf, argc, argv, inPath, outPath, nogap_inPath, &max_nogap);
if (ret < 0) {
return ret == -2 ? 0 : 1;
}
if (global_ui_config.update_interval < 0.)
global_ui_config.update_interval = 2.;
if (outPath[0] != '\0' && max_nogap > 0) {
strncpy(nogapdir, outPath, PATH_MAX + 1);
nogapout = 1;
}
/* initialize input file. This also sets samplerate and as much
other data on the input file as available in the headers */
if (max_nogap > 0) {
/* for nogap encoding of multiple input files, it is not possible to
* specify the output file name, only an optional output directory. */
parse_nogap_filenames(nogapout, nogap_inPath[0], outPath, nogapdir);
outf = init_files(gf, nogap_inPath[0], outPath);
}
else {
outf = init_files(gf, inPath, outPath);
}
if (outf == NULL) {
return -1;
}
/* turn off automatic writing of ID3 tag data into mp3 stream
* we have to call it before 'lame_init_params', because that
* function would spit out ID3v2 tag data.
*/
lame_set_write_id3tag_automatic(gf, 0);
/* Now that all the options are set, lame needs to analyze them and
* set some more internal options and check for problems
*/
ret = lame_init_params(gf);
if (ret < 0) {
if (ret == -1) {
display_bitrates(stderr);
}
error_printf("fatal error during initialization\n");
return ret;
}
if (global_ui_config.silent > 0) {
global_ui_config.brhist = 0; /* turn off VBR histogram */
}
if (lame_get_decode_only(gf)) {
/* decode an mp3 file to a .wav */
ret = lame_decoder(gf, outf, inPath, outPath);
}
else if (max_nogap == 0) {
/* encode a single input file */
ret = lame_encoder(gf, outf, 0, inPath, outPath);
}
else {
/* encode multiple input files using nogap option */
for (i = 0; i < max_nogap; ++i) {
int use_flush_nogap = (i != (max_nogap - 1));
if (i > 0) {
parse_nogap_filenames(nogapout, nogap_inPath[i], outPath, nogapdir);
/* note: if init_files changes anything, like
samplerate, num_channels, etc, we are screwed */
outf = init_files(gf, nogap_inPath[i], outPath);
/* reinitialize bitstream for next encoding. this is normally done
* by lame_init_params(), but we cannot call that routine twice */
lame_init_bitstream(gf);
}
lame_set_nogap_total(gf, max_nogap);
lame_set_nogap_currentindex(gf, i);
ret = lame_encoder(gf, outf, use_flush_nogap, nogap_inPath[i], outPath);
}
}
return ret;
}
int
main(int argc, char **argv)
{
int ret;
lame_global_flags *gf;
char outPath[PATH_MAX + 1];
char nogapdir[PATH_MAX + 1];
char inPath[PATH_MAX + 1];
/* add variables for encoder delay/padding */
int enc_delay = -1;
int enc_padding = -1;
/* support for "nogap" encoding of up to 200 .wav files */
#define MAX_NOGAP 200
int nogapout = 0;
int max_nogap = MAX_NOGAP;
char nogap_inPath_[MAX_NOGAP][PATH_MAX+1];
char* nogap_inPath[MAX_NOGAP];
int i;
FILE *outf;
#if macintosh
argc = ccommand(&argv);
#endif
#if 0
/* rh 061207
the following fix seems to be a workaround for a problem in the
parent process calling LAME. It would be better to fix the broken
application => code disabled.
*/
#if defined(_WIN32)
/* set affinity back to all CPUs. Fix for EAC/lame on SMP systems from
"Todd Richmond" <*****@*****.**> */
typedef BOOL(WINAPI * SPAMFunc) (HANDLE, DWORD_PTR);
SPAMFunc func;
SYSTEM_INFO si;
if ((func = (SPAMFunc) GetProcAddress(GetModuleHandleW(L"KERNEL32.DLL"),
"SetProcessAffinityMask")) != NULL) {
GetSystemInfo(&si);
func(GetCurrentProcess(), si.dwActiveProcessorMask);
}
#endif
#endif
#ifdef __EMX__
/* This gives wildcard expansion on Non-POSIX shells with OS/2 */
_wildcard(&argc, &argv);
#endif
memset(nogap_inPath_, 0, sizeof(nogap_inPath_));
for (i = 0; i < MAX_NOGAP; ++i) {
nogap_inPath[i] = &nogap_inPath_[i][0];
}
memset(inPath, 0, sizeof(inPath));
frontend_open_console();
/* initialize libmp3lame */
input_format = sf_unknown;
if (NULL == (gf = lame_init())) {
error_printf("fatal error during initialization\n");
frontend_close_console();
return 1;
}
lame_set_errorf(gf, &frontend_errorf);
lame_set_debugf(gf, &frontend_debugf);
lame_set_msgf(gf, &frontend_msgf);
if (argc <= 1) {
usage(stderr, argv[0]); /* no command-line args, print usage, exit */
lame_close(gf);
frontend_close_console();
return 1;
}
/* parse the command line arguments, setting various flags in the
* struct 'gf'. If you want to parse your own arguments,
* or call libmp3lame from a program which uses a GUI to set arguments,
* skip this call and set the values of interest in the gf struct.
* (see the file API and lame.h for documentation about these parameters)
*/
parse_args_from_string(gf, getenv("LAMEOPT"), inPath, outPath);
ret = parse_args(gf, argc, argv, inPath, outPath, nogap_inPath, &max_nogap);
if (ret < 0) {
lame_close(gf);
frontend_close_console();
return ret == -2 ? 0 : 1;
}
if (update_interval < 0.)
update_interval = 2.;
if (outPath[0] != '\0' && max_nogap > 0) {
strncpy(nogapdir, outPath, PATH_MAX + 1);
nogapout = 1;
}
/* initialize input file. This also sets samplerate and as much
other data on the input file as available in the headers */
if (max_nogap > 0) {
/* for nogap encoding of multiple input files, it is not possible to
* specify the output file name, only an optional output directory. */
parse_nogap_filenames(nogapout, nogap_inPath[0], outPath, nogapdir);
outf = init_files(gf, nogap_inPath[0], outPath, &enc_delay, &enc_padding);
}
else {
outf = init_files(gf, inPath, outPath, &enc_delay, &enc_padding);
}
if (outf == NULL) {
lame_close(gf);
frontend_close_console();
return -1;
}
/* turn off automatic writing of ID3 tag data into mp3 stream
* we have to call it before 'lame_init_params', because that
* function would spit out ID3v2 tag data.
*/
lame_set_write_id3tag_automatic(gf, 0);
/* Now that all the options are set, lame needs to analyze them and
* set some more internal options and check for problems
*/
i = lame_init_params(gf);
if (i < 0) {
if (i == -1) {
display_bitrates(stderr);
}
error_printf("fatal error during initialization\n");
lame_close(gf);
frontend_close_console();
return i;
}
if (silent > 0) {
brhist = 0; /* turn off VBR histogram */
}
if (lame_get_decode_only(gf)) {
/* decode an mp3 file to a .wav */
if (mp3_delay_set)
lame_decoder(gf, outf, mp3_delay, inPath, outPath, &enc_delay, &enc_padding);
else
lame_decoder(gf, outf, 0, inPath, outPath, &enc_delay, &enc_padding);
}
else {
if (max_nogap > 0) {
/*
* encode multiple input files using nogap option
*/
for (i = 0; i < max_nogap; ++i) {
int use_flush_nogap = (i != (max_nogap - 1));
if (i > 0) {
parse_nogap_filenames(nogapout, nogap_inPath[i], outPath, nogapdir);
/* note: if init_files changes anything, like
samplerate, num_channels, etc, we are screwed */
outf = init_files(gf, nogap_inPath[i], outPath, &enc_delay, &enc_padding);
/* reinitialize bitstream for next encoding. this is normally done
* by lame_init_params(), but we cannot call that routine twice */
lame_init_bitstream(gf);
}
brhist_init_package(gf);
lame_set_nogap_total(gf, max_nogap);
lame_set_nogap_currentindex(gf, i);
ret = lame_encoder(gf, outf, use_flush_nogap, nogap_inPath[i], outPath);
fclose(outf); /* close the output file */
close_infile(); /* close the input file */
}
}
else {
/*
* encode a single input file
*/
brhist_init_package(gf);
ret = lame_encoder(gf, outf, 0, inPath, outPath);
fclose(outf); /* close the output file */
close_infile(); /* close the input file */
}
}
lame_close(gf);
frontend_close_console();
return ret;
}
void lame_encoder_impl_internal::start()
{
lame_set_write_id3tag_automatic(m_Lame.get(), 0);
int lameRet = lame_init_params( m_Lame.get() );
DT_LAME_CHECK_ERR(lameRet);
}
int CEncoderLame::prepare(
const sp<IMediaSource>& pMediaSource_in,
const sp<IAudioSink>& pAudioSink_out,
const sp<AMessage>& pOption_in
)
{
AUTO_LOG();
if (m_pGobalFlags != NULL) {
RETURN(ALREADY_EXISTS);
}
CHECK_PTR_EXT(pMediaSource_in, BAD_VALUE);
CHECK_PTR_EXT(pAudioSink_out, BAD_VALUE);
sp<MetaData> pMeta = pMediaSource_in->getFormat();
CHECK_PTR_EXT(pMeta, BAD_VALUE);
m_pGobalFlags = lame_init();
CHECK_PTR_EXT(m_pGobalFlags, BAD_VALUE);
lame_set_errorf(m_pGobalFlags, CEncoderLame::errorf);
lame_set_debugf(m_pGobalFlags, CEncoderLame::debugf);
lame_set_msgf(m_pGobalFlags, CEncoderLame::msgf);
id3tag_init(m_pGobalFlags);
// TO DO
// pass the user option to encoder
//if (pOption_in != NULL) {
//}
int ret = OK;
bool chk = false;
int32_t iChannelNum = 0;
chk = pMeta->findInt32(kKeyChannelCount, &iChannelNum);
CHECK_IS_EXT((true == chk), UNKNOWN_ERROR);
ret = lame_set_num_channels(m_pGobalFlags, iChannelNum);
CHECK_IS_EXT((ret == OK), ret);
int32_t iSampleRate = 0;
chk = pMeta->findInt32(kKeySampleRate, &iSampleRate);
CHECK_IS_EXT((true == chk), UNKNOWN_ERROR);
ret = lame_set_in_samplerate(m_pGobalFlags, iSampleRate);
CHECK_IS_EXT((ret == OK), ret);
int32_t iBitsPerSample = 0;
chk = pMeta->findInt32(kKeyBitsPerSample, &iBitsPerSample);
CHECK_IS_EXT((true == chk), UNKNOWN_ERROR);
int32_t iDataSize = 0;
chk = pMeta->findInt32(kKeyDataSize, &iDataSize);
CHECK_IS_EXT((true == chk), UNKNOWN_ERROR);
ret = lame_set_num_samples(m_pGobalFlags, iDataSize / (iChannelNum * ((iBitsPerSample + 7) / 8)));
CHECK_IS_EXT((ret == OK), ret);
lame_set_write_id3tag_automatic(m_pGobalFlags, 0);
ret = lame_init_params(m_pGobalFlags);
CHECK_IS_EXT((ret == OK), ret);
size_t id3v2_size = lame_get_id3v2_tag(m_pGobalFlags, 0, 0);
if (id3v2_size > 0) {
unsigned char *id3v2tag = new unsigned char[id3v2_size];
if (id3v2tag != 0) {
int iTagSz = lame_get_id3v2_tag(m_pGobalFlags, id3v2tag, id3v2_size);
int iWrite = (int) pAudioSink_out->write(id3v2tag, iTagSz);
delete(id3v2tag);
CHECK_IS_EXT((iTagSz == iWrite), UNKNOWN_ERROR);
}
}
RETURN(OK);
}
static gint mp3_open(void)
{
int imp3;
gfp = lame_init();
if (gfp == NULL)
return 0;
/* setup id3 data */
id3tag_init(gfp);
if (tuple) {
/* XXX write UTF-8 even though libmp3lame does id3v2.3. --yaz */
lameid3.track_name = tuple_get_str (tuple, FIELD_TITLE, NULL);
id3tag_set_title(gfp, lameid3.track_name);
lameid3.performer = tuple_get_str (tuple, FIELD_ARTIST, NULL);
id3tag_set_artist(gfp, lameid3.performer);
lameid3.album_name = tuple_get_str (tuple, FIELD_ALBUM, NULL);
id3tag_set_album(gfp, lameid3.album_name);
lameid3.genre = tuple_get_str (tuple, FIELD_GENRE, NULL);
id3tag_set_genre(gfp, lameid3.genre);
lameid3.year = str_printf ("%d", tuple_get_int (tuple, FIELD_YEAR, NULL));
id3tag_set_year(gfp, lameid3.year);
lameid3.track_number = str_printf ("%d", tuple_get_int (tuple, FIELD_TRACK_NUMBER, NULL));
id3tag_set_track(gfp, lameid3.track_number);
if (force_v2_val) {
id3tag_add_v2(gfp);
}
if (only_v1_val) {
id3tag_v1_only(gfp);
}
if (only_v2_val) {
id3tag_v2_only(gfp);
}
}
/* input stream description */
lame_set_in_samplerate(gfp, input.frequency);
lame_set_num_channels(gfp, input.channels);
/* Maybe implement this? */
/* lame_set_scale(lame_global_flags *, float); */
lame_set_out_samplerate(gfp, out_samplerate_val);
/* general control parameters */
lame_set_bWriteVbrTag(gfp, toggle_xing_val);
lame_set_quality(gfp, algo_quality_val);
if (audio_mode_val != 4) {
AUDDBG("set mode to %d\n", audio_mode_val);
lame_set_mode(gfp, audio_mode_val);
}
lame_set_errorf(gfp, lame_debugf);
lame_set_debugf(gfp, lame_debugf);
lame_set_msgf(gfp, lame_debugf);
if (enc_toggle_val == 0 && vbr_on == 0)
lame_set_brate(gfp, bitrate_val);
else if (vbr_on == 0)
lame_set_compression_ratio(gfp, compression_val);
/* frame params */
lame_set_copyright(gfp, mark_copyright_val);
lame_set_original(gfp, mark_original_val);
lame_set_error_protection(gfp, error_protect_val);
lame_set_strict_ISO(gfp, enforce_iso_val);
if (vbr_on != 0) {
if (vbr_type == 0)
lame_set_VBR(gfp, 2);
else
lame_set_VBR(gfp, 3);
lame_set_VBR_q(gfp, vbr_quality_val);
lame_set_VBR_mean_bitrate_kbps(gfp, abr_val);
lame_set_VBR_min_bitrate_kbps(gfp, vbr_min_val);
lame_set_VBR_max_bitrate_kbps(gfp, vbr_max_val);
lame_set_VBR_hard_min(gfp, enforce_min_val);
}
/* not to write id3 tag automatically. */
lame_set_write_id3tag_automatic(gfp, 0);
if (lame_init_params(gfp) == -1)
return 0;
/* write id3v2 header */
imp3 = lame_get_id3v2_tag(gfp, encbuffer, sizeof(encbuffer));
if (imp3 > 0) {
write_output(encbuffer, imp3);
id3v2_size = imp3;
}
else {
id3v2_size = 0;
}
write_buffer = NULL;
write_buffer_size = 0;
return 1;
}
