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; }