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;
}
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;
}
bool KRecExport_MP3::initialize( const QString &filename ) {
kdDebug( 60005 ) << k_funcinfo << endl;
if ( !_file &&
!( bits()!=16 && channels()!=2 &&
KMessageBox::warningContinueCancel( KRecGlobal::the()->mainWidget(),
i18n( "At this time MP3-Export only supports files in stereo and 16bit." )
) == KMessageBox::Cancel
)
) {
KMessageBox::information( KRecGlobal::the()->mainWidget(),
i18n( "Please note that this plugin takes its qualitysettings from" \
" the corresponding section of the Audio CDs Control Center module" \
" configuration. Make use" \
" of the Control Center to configure these settings." ),
i18n( "Quality Configuration" ), "qualityinfo_mp3" );
_file = new QFile( filename );
if ( _file->open( IO_Raw|IO_WriteOnly ) ) {
if ( ! init_done ) {
gfp = lame_init();
setLameParameters();
if ( write_id3 ) {
id3tag_init( gfp );
id3tag_v1_only ( gfp );
id3tag_set_album ( gfp, "" );
id3tag_set_artist ( gfp, "" );
id3tag_set_title ( gfp, "" );
id3tag_set_comment( gfp, "krec" );
}
/// Set input parameters right
lame_set_in_samplerate( gfp, this->samplingRate() );
lame_set_num_channels( gfp, this->channels() );
lame_init_params( gfp );
}
if ( _file->size() >= 128 )
_file->at( _file->size() - 128 );
else
_file->at( _file->size() );
} else return false;
return true;
} else return false;
}
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;
}
/* 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;
}
lame_global_flags* simple_lame_lib_init(
JNIEnv* env,
jint inSamplerate, jint outChannel,
jint outSamplerate, jint outBitrate, jint quality,
jstring id3tagTitle, jstring id3tagArtist, jstring id3tagAlbum,
jstring id3tagYear, jstring id3tagComment) {
if (local_log) {
__android_log_print(ANDROID_LOG_VERBOSE, TAG, "Start lame init.");
}
lame_global_flags* glf = lame_init();
lame_set_in_samplerate(glf, inSamplerate);
lame_set_num_channels(glf, outChannel);
lame_set_out_samplerate(glf, outSamplerate);
lame_set_brate(glf, outBitrate);
lame_set_quality(glf, quality);
const jchar* title = NULL;
const jchar* artist = NULL;
const jchar* album = NULL;
const jchar* year = NULL;
const jchar* comment = NULL;
if (id3tagTitle) {
title = (*env)->GetStringChars(env, id3tagTitle, NULL);
}
if (id3tagArtist) {
artist = (*env)->GetStringChars(env, id3tagArtist, NULL);
}
if (id3tagAlbum) {
album = (*env)->GetStringChars(env, id3tagAlbum, NULL);
}
if (id3tagYear) {
year = (*env)->GetStringChars(env, id3tagYear, NULL);
}
if (id3tagComment) {
comment = (*env)->GetStringChars(env, id3tagComment, NULL);
}
if (title || artist || album || year || comment) {
id3tag_init(glf);
if (title) {
id3tag_set_title(glf, (const char*)title);
(*env)->ReleaseStringChars(env, id3tagTitle, title);
}
if (artist) {
id3tag_set_artist(glf, (const char*)artist);
(*env)->ReleaseStringChars(env, id3tagArtist, artist);
}
if (album) {
id3tag_set_album(glf, (const char*)album);
(*env)->ReleaseStringChars(env, id3tagAlbum, album);
}
if (year) {
id3tag_set_year(glf, (const char*)year);
(*env)->ReleaseStringChars(env, id3tagYear, year);
}
if (comment) {
id3tag_set_comment(glf, (const char*)comment);
(*env)->ReleaseStringChars(env, id3tagComment, comment);
}
}
lame_init_params(glf);
if (local_log) {
__android_log_print(ANDROID_LOG_VERBOSE, TAG, "End lame init.");
}
return glf;
}
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);
}
bool MP3Writer::begin() {
if(!is_setup) {
RX_ERROR(MP3_WRERR_NOT_SETUP);
return false;
}
if(is_started) {
return false;
}
int samplerate = 0;
MPEG_mode mode = MONO;
if(config.mode == MP3_WR_MODE_STEREO) {
mode = STEREO;
}
else {
mode = MONO;
}
samplerate = config.samplerateToInt();
lame_flags = lame_init();
if(!lame_flags) {
RX_ERROR(MP3_WRERR_LAME_INIT);
return false;
}
lame_set_num_channels(lame_flags, config.num_channels);
lame_set_in_samplerate(lame_flags, samplerate);
lame_set_brate(lame_flags, config.bitrate);
lame_set_mode(lame_flags, mode);
lame_set_quality(lame_flags, config.quality);
if(config.hasID3()) {
id3tag_init(lame_flags);
}
if(config.id3_title.size()) {
id3tag_set_title(lame_flags, config.id3_title.c_str());
}
if(config.id3_artist.size()) {
id3tag_set_artist(lame_flags, config.id3_artist.c_str());
}
if(config.id3_album.size()) {
id3tag_set_album(lame_flags, config.id3_album.c_str());
}
if(config.id3_year.size()) {
id3tag_set_year(lame_flags, config.id3_year.c_str());
}
if(config.id3_comment.size()) {
id3tag_set_comment(lame_flags, config.id3_comment.c_str());
}
if(config.id3_track.size()) {
int r = id3tag_set_track(lame_flags, config.id3_track.c_str());
if(r == -1) {
RX_ERROR(MP3_WRERR_ID3_TRACK_OOR);
}
else if(r == -2) {
RX_ERROR(MP3_WRERR_ID3_TRACK_INVALID);
}
}
if(lame_init_params(lame_flags) < 0) {
RX_ERROR(MP3_WRERR_LAME_PARAMS);
return false;
}
is_started = true;
config.cb_open(config.user);
return true;
}
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;
}
