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; }
static void printInputFormat(lame_t gfp) { int const v_main = 2 - lame_get_version(gfp); char const *v_ex = lame_get_out_samplerate(gfp) < 16000 ? ".5" : ""; switch (global_reader.input_format) { case sf_mp123: /* FIXME: !!! */ break; case sf_mp3: console_printf("MPEG-%u%s Layer %s", v_main, v_ex, "III"); break; case sf_mp2: console_printf("MPEG-%u%s Layer %s", v_main, v_ex, "II"); break; case sf_mp1: console_printf("MPEG-%u%s Layer %s", v_main, v_ex, "I"); break; case sf_raw: console_printf("raw PCM data"); break; case sf_wave: console_printf("Microsoft WAVE"); break; case sf_aiff: console_printf("SGI/Apple AIFF"); break; default: console_printf("unknown"); break; } }
static void progress_line(const lame_global_flags * gf, int full, int frames) { char rst[20] = "\0"; int barlen_TOT = 0, barlen_COD = 0, barlen_RST = 0; int res = 1; float time_in_sec = 0; unsigned int hour, min, sec; int fsize = lame_get_framesize(gf); int srate = lame_get_out_samplerate(gf); if (full < frames) { full = frames; } if (srate > 0) { time_in_sec = (float)(full - frames); time_in_sec *= fsize; time_in_sec /= srate; } hour = (unsigned int)(time_in_sec / 3600); time_in_sec -= hour * 3600; min = (unsigned int)(time_in_sec / 60); time_in_sec -= min * 60; sec = (unsigned int)time_in_sec; if (full != 0) { if (hour > 0) { sprintf(rst, "%*d:%02u:%02u", digits(hour), hour, min, sec); res += digits(hour) + 1 + 5; } else { sprintf(rst, "%02u:%02u", min, sec); res += 5; } /* some problems when br_hist_TOT \approx br_hist_LR: You can't see that there are still MS frames */ barlen_TOT = (full * (Console_IO.disp_width - res) + full - 1) / full; /* round up */ barlen_COD = (frames * (Console_IO.disp_width - res) + full - 1) / full; /* round up */ barlen_RST = barlen_TOT - barlen_COD; if (barlen_RST == 0) { sprintf(rst, "%.*s", res - 1, brhist.bar_coded); } } else { barlen_TOT = barlen_COD = barlen_RST = 0; } if (Console_IO.str_clreoln[0]) { /* ClearEndOfLine available */ console_printf("\n%.*s%s%.*s%s", barlen_COD, brhist.bar_coded, rst, barlen_RST, brhist.bar_space, Console_IO.str_clreoln); } else { console_printf("\n%.*s%s%.*s%*s", barlen_COD, brhist.bar_coded, rst, barlen_RST, brhist.bar_space, Console_IO.disp_width - res - barlen_TOT, ""); } brhist.hist_printed_lines++; }
void timestatus_klemm ( const lame_global_flags* const gfp ) { static double last_time = 0.; if ( silent <= 0 ) if ( lame_get_frameNum(gfp) == 0 || lame_get_frameNum(gfp) == 9 || GetRealTime () - last_time >= update_interval || GetRealTime () - last_time < 0 ) { #ifdef BRHIST brhist_jump_back(); #endif timestatus ( lame_get_out_samplerate( gfp ), lame_get_frameNum(gfp), lame_get_totalframes(gfp), lame_get_framesize(gfp) ); #ifdef BRHIST if ( brhist ) { brhist_disp ( gfp ); } #endif last_time = GetRealTime (); /* from now! disp_time seconds */ } }
////////////////////////////////////////////////////////////////////// // 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; }
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; }
int lame_decoder(lame_global_flags * gfp, FILE * outf, int skip, char *inPath, char *outPath) { short int Buffer[2][1152]; int iread; double wavsize; int i; void (*WriteFunction) (FILE * fp, char *p, int n); int tmp_num_channels = lame_get_num_channels( gfp ); if (silent < 10) fprintf(stderr, "\rinput: %s%s(%g kHz, %i channel%s, ", strcmp(inPath, "-") ? inPath : "<stdin>", strlen(inPath) > 26 ? "\n\t" : " ", lame_get_in_samplerate( gfp ) / 1.e3, tmp_num_channels, tmp_num_channels != 1 ? "s" : ""); switch (input_format) { case sf_mp3: if (skip==0) { if (enc_delay>-1) skip = enc_delay + 528+1; else skip=lame_get_encoder_delay(gfp)+528+1; }else{ /* user specified a value of skip. just add for decoder */ skip += 528+1; /* mp3 decoder has a 528 sample delay, plus user supplied "skip" */ } if (silent < 10) fprintf(stderr, "MPEG-%u%s Layer %s", 2 - lame_get_version(gfp), lame_get_out_samplerate( gfp ) < 16000 ? ".5" : "", "III"); break; case sf_mp2: skip += 240 + 1; if (silent < 10) fprintf(stderr, "MPEG-%u%s Layer %s", 2 - lame_get_version(gfp), lame_get_out_samplerate( gfp ) < 16000 ? ".5" : "", "II"); break; case sf_mp1: skip += 240 + 1; if (silent < 10) fprintf(stderr, "MPEG-%u%s Layer %s", 2 - lame_get_version(gfp), lame_get_out_samplerate( gfp ) < 16000 ? ".5" : "", "I"); break; case sf_raw: if (silent < 10) fprintf(stderr, "raw PCM data"); mp3input_data.nsamp = lame_get_num_samples( gfp ); mp3input_data.framesize = 1152; skip = 0; /* other formats have no delay *//* is += 0 not better ??? */ break; case sf_wave: if (silent < 10) fprintf(stderr, "Microsoft WAVE"); mp3input_data.nsamp = lame_get_num_samples( gfp ); mp3input_data.framesize = 1152; skip = 0; /* other formats have no delay *//* is += 0 not better ??? */ break; case sf_aiff: if (silent < 10) fprintf(stderr, "SGI/Apple AIFF"); mp3input_data.nsamp = lame_get_num_samples( gfp ); mp3input_data.framesize = 1152; skip = 0; /* other formats have no delay *//* is += 0 not better ??? */ break; default: if (silent < 10) fprintf(stderr, "unknown"); mp3input_data.nsamp = lame_get_num_samples( gfp ); mp3input_data.framesize = 1152; skip = 0; /* other formats have no delay *//* is += 0 not better ??? */ assert(0); break; } if (silent < 10) { fprintf(stderr, ")\noutput: %s%s(16 bit, Microsoft WAVE)\n", strcmp(outPath, "-") ? outPath : "<stdout>", strlen(outPath) > 45 ? "\n\t" : " "); if (skip > 0) fprintf(stderr, "skipping initial %i samples (encoder+decoder delay)\n", skip); } if ( 0 == disable_wav_header ) WriteWaveHeader(outf, 0x7FFFFFFF, lame_get_in_samplerate( gfp ), tmp_num_channels, 16); /* unknown size, so write maximum 32 bit signed value */ wavsize = -skip; WriteFunction = swapbytes ? WriteBytesSwapped : WriteBytes; mp3input_data.totalframes = mp3input_data.nsamp / mp3input_data.framesize; assert(tmp_num_channels >= 1 && tmp_num_channels <= 2); do { iread = get_audio16(gfp, Buffer); /* read in 'iread' samples */ mp3input_data.framenum += iread / mp3input_data.framesize; wavsize += iread; if (silent <= 0) decoder_progress(gfp, &mp3input_data); skip -= (i = skip < iread ? skip : iread); /* 'i' samples are to skip in this frame */ for (; i < iread; i++) { if ( disable_wav_header ) { WriteFunction(outf, (char *) &Buffer[0][i], sizeof(short)); if (tmp_num_channels == 2) WriteFunction(outf, (char *) &Buffer[1][i], sizeof(short)); } else { Write16BitsLowHigh(outf, Buffer[0][i]); if (tmp_num_channels == 2) Write16BitsLowHigh(outf, Buffer[1][i]); } } } while (iread); i = (16 / 8) * tmp_num_channels; assert(i > 0); if (wavsize <= 0) { if (silent < 10) fprintf(stderr, "WAVE file contains 0 PCM samples\n"); wavsize = 0; } else if (wavsize > 0xFFFFFFD0 / i) { if (silent < 10) fprintf(stderr, "Very huge WAVE file, can't set filesize accordingly\n"); wavsize = 0xFFFFFFD0; } else { wavsize *= i; } if ( 0 == disable_wav_header ) if (!fseek(outf, 0l, SEEK_SET)) /* if outf is seekable, rewind and adjust length */ WriteWaveHeader(outf, (int)wavsize, lame_get_in_samplerate( gfp ), tmp_num_channels, 16); fclose(outf); if (silent <= 0) decoder_progress_finish(gfp); return 0; }
/*------------------------------------------------------------------------------ * 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; }
int lame_encoder_impl_internal::get_output_sample_rate() const { return lame_get_out_samplerate(m_Lame.get()); }
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); } } }
static void timestatus(const lame_global_flags * const gfp) { timestatus_t* real_time = &global_encoder_progress.real_time; timestatus_t* proc_time = &global_encoder_progress.proc_time; int percent; double tmx, delta; int samp_rate = lame_get_out_samplerate(gfp) , frameNum = lame_get_frameNum(gfp) , totalframes = lame_get_totalframes(gfp) , framesize = lame_get_framesize(gfp) ; if (totalframes < frameNum) { totalframes = frameNum; } if (global_encoder_progress.time_status_init == 0) { real_time->last_time = GetRealTime(); proc_time->last_time = GetCPUTime(); real_time->elapsed_time = 0; proc_time->elapsed_time = 0; } /* we need rollover protection for GetCPUTime, and maybe GetRealTime(): */ tmx = GetRealTime(); delta = tmx - real_time->last_time; if (delta < 0) delta = 0; /* ignore, clock has rolled over */ real_time->elapsed_time += delta; real_time->last_time = tmx; tmx = GetCPUTime(); delta = tmx - proc_time->last_time; if (delta < 0) delta = 0; /* ignore, clock has rolled over */ proc_time->elapsed_time += delta; proc_time->last_time = tmx; if (global_encoder_progress.time_status_init == 0) { console_printf("\r" " Frame | CPU time/estim | REAL time/estim | play/CPU | ETA \n" " 0/ ( 0%%)| 0:00/ : | 0:00/ : | " SPEED_CHAR "| : \r" /* , Console_IO.str_clreoln, Console_IO.str_clreoln */ ); global_encoder_progress.time_status_init = 1; return; } ts_calc_times(real_time, samp_rate, frameNum, totalframes, framesize); ts_calc_times(proc_time, samp_rate, frameNum, totalframes, framesize); if (frameNum < totalframes) { percent = (int) (100. * frameNum / totalframes + 0.5); } else { percent = 100; } console_printf("\r%6i/%-6i", frameNum, totalframes); console_printf(percent < 100 ? " (%2d%%)|" : "(%3.3d%%)|", percent); ts_time_decompose(proc_time->elapsed_time, '/'); ts_time_decompose(proc_time->estimated_time, '|'); ts_time_decompose(real_time->elapsed_time, '/'); ts_time_decompose(real_time->estimated_time, '|'); console_printf(proc_time->speed_index <= 1. ? "%9.4f" SPEED_CHAR "|" : "%#9.5g" SPEED_CHAR "|", SPEED_MULT * proc_time->speed_index); ts_time_decompose((real_time->estimated_time - real_time->elapsed_time), ' '); }