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; }
int short_help(const lame_global_flags * gfp, FILE * const fp, const char *ProgramName) { /* print short syntax help */ lame_version_print(fp); fprintf(fp, "usage: %s [options] <infile> [outfile]\n" "\n" " <infile> and/or <outfile> can be \"-\", which means stdin/stdout.\n" "\n" "RECOMMENDED:\n" " lame -V2 input.wav output.mp3\n" "\n", ProgramName); fprintf(fp, "OPTIONS:\n" " -b bitrate set the bitrate, default 128 kbps\n" " -h higher quality, but a little slower. Recommended.\n" " -f fast mode (lower quality)\n" " -V n quality setting for VBR. default n=%i\n" " 0=high quality,bigger files. 9=smaller files\n", lame_get_VBR_q(gfp)); fprintf(fp, " --preset type type must be \"medium\", \"standard\", \"extreme\", \"insane\",\n" " or a value for an average desired bitrate and depending\n" " on the value specified, appropriate quality settings will\n" " be used.\n" " \"--preset help\" gives more info on these\n" "\n"); fprintf(fp, #if defined(WIN32) " --priority type sets the process priority\n" " 0,1 = Low priority\n" " 2 = normal priority\n" " 3,4 = High priority\n" "\n" #endif #if defined(__OS2__) " --priority type sets the process priority\n" " 0 = Low priority\n" " 1 = Medium priority\n" " 2 = Regular priority\n" " 3 = High priority\n" " 4 = Maximum priority\n" "\n" #endif " --longhelp full list of options\n" "\n" " --license print License information\n\n" ); 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, 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 long_help(const lame_global_flags * gfp, FILE * const fp, const char *ProgramName, int lessmode) { /* print long syntax help */ lame_version_print(fp); fprintf(fp, "usage: %s [options] <infile> [outfile]\n" "\n" " <infile> and/or <outfile> can be \"-\", which means stdin/stdout.\n" "\n" "RECOMMENDED:\n" " lame -V2 input.wav output.mp3\n" "\n", ProgramName); fprintf(fp, "OPTIONS:\n" " Input options:\n" " --scale <arg> scale input (multiply PCM data) by <arg>\n" " --scale-l <arg> scale channel 0 (left) input (multiply PCM data) by <arg>\n" " --scale-r <arg> scale channel 1 (right) input (multiply PCM data) by <arg>\n" #if (defined HAVE_MPGLIB || defined AMIGA_MPEGA) " --mp1input input file is a MPEG Layer I file\n" " --mp2input input file is a MPEG Layer II file\n" " --mp3input input file is a MPEG Layer III file\n" #endif " --nogap <file1> <file2> <...>\n" " gapless encoding for a set of contiguous files\n" " --nogapout <dir>\n" " output dir for gapless encoding (must precede --nogap)\n" " --nogaptags allow the use of VBR tags in gapless encoding\n" ); fprintf(fp, "\n" " Input options for RAW PCM:\n" " -r input is raw pcm\n" " -x force byte-swapping of input\n" " -s sfreq sampling frequency of input file (kHz) - default 44.1 kHz\n" " --bitwidth w input bit width is w (default 16)\n" " --signed input is signed (default)\n" " --unsigned input is unsigned\n" " --little-endian input is little-endian (default)\n" " --big-endian input is big-endian\n" ); wait_for(fp, lessmode); fprintf(fp, " Operational options:\n" " -a downmix from stereo to mono file for mono encoding\n" " -m <mode> (j)oint, (s)imple, (f)orce, (d)dual-mono, (m)ono\n" " default is (j) or (s) depending on bitrate\n" " joint = joins the best possible of MS and LR stereo\n" " simple = force LR stereo on all frames\n" " force = force MS stereo on all frames.\n" " --preset type type must be \"medium\", \"standard\", \"extreme\", \"insane\",\n" " or a value for an average desired bitrate and depending\n" " on the value specified, appropriate quality settings will\n" " be used.\n" " \"--preset help\" gives more info on these\n" " --comp <arg> choose bitrate to achive a compression ratio of <arg>\n"); fprintf(fp, " --replaygain-fast compute RG fast but slightly inaccurately (default)\n" #ifdef DECODE_ON_THE_FLY " --replaygain-accurate compute RG more accurately and find the peak sample\n" #endif " --noreplaygain disable ReplayGain analysis\n" #ifdef DECODE_ON_THE_FLY " --clipdetect enable --replaygain-accurate and print a message whether\n" " clipping occurs and how far the waveform is from full scale\n" #endif ); fprintf(fp, " --flush flush output stream as soon as possible\n" " --freeformat produce a free format bitstream\n" " --decode input=mp3 file, output=wav\n" " -t disable writing wav header when using --decode\n"); wait_for(fp, lessmode); fprintf(fp, " Verbosity:\n" " --disptime <arg>print progress report every arg seconds\n" " -S don't print progress report, VBR histograms\n" " --nohist disable VBR histogram display\n" " --silent don't print anything on screen\n" " --quiet don't print anything on screen\n" " --brief print more useful information\n" " --verbose print a lot of useful information\n" "\n"); fprintf(fp, " Noise shaping & psycho acoustic algorithms:\n" " -q <arg> <arg> = 0...9. Default -q 5 \n" " -q 0: Highest quality, very slow \n" " -q 9: Poor quality, but fast \n" " -h Same as -q 2. Recommended.\n" " -f Same as -q 7. Fast, ok quality\n"); wait_for(fp, lessmode); fprintf(fp, " CBR (constant bitrate, the default) options:\n" " -b <bitrate> set the bitrate in kbps, default 128 kbps\n" " --cbr enforce use of constant bitrate\n" "\n" " ABR options:\n" " --abr <bitrate> specify average bitrate desired (instead of quality)\n" "\n"); fprintf(fp, " VBR options:\n" " -V n quality setting for VBR. default n=%i\n" " 0=high quality,bigger files. 9=smaller files\n" " -v the same as -V 4\n" " --vbr-old use old variable bitrate (VBR) routine\n" " --vbr-new use new variable bitrate (VBR) routine (default)\n" , lame_get_VBR_q(gfp)); fprintf(fp, " -b <bitrate> specify minimum allowed bitrate, default 32 kbps\n" " -B <bitrate> specify maximum allowed bitrate, default 320 kbps\n" " -F strictly enforce the -b option, for use with players that\n" " do not support low bitrate mp3\n" " -t disable writing LAME Tag\n" " -T enable and force writing LAME Tag\n"); wait_for(fp, lessmode); DEV_HELP(fprintf(fp, " ATH related:\n" " --noath turns ATH down to a flat noise floor\n" " --athshort ignore GPSYCHO for short blocks, use ATH only\n" " --athonly ignore GPSYCHO completely, use ATH only\n" " --athtype n selects between different ATH types [0-4]\n" " --athlower x lowers ATH by x dB\n"); fprintf(fp, " --athaa-type n ATH auto adjust: 0 'no' else 'loudness based'\n" /** OBSOLETE " --athaa-loudapprox n n=1 total energy or n=2 equal loudness curve\n"*/ " --athaa-sensitivity x activation offset in -/+ dB for ATH auto-adjustment\n" "\n"); )
bool ACMStream::open(const AEncodeProperties & the_Properties) { bool bResult = false; // Init the MP3 Stream // Init the global flags structure gfp = lame_init(); // Set input sample frequency lame_set_in_samplerate( gfp, my_SamplesPerSec ); // Set output sample frequency lame_set_out_samplerate( gfp, my_OutBytesPerSec ); lame_set_num_channels( gfp, my_Channels ); if (my_Channels == 1) lame_set_mode( gfp, MONO ); else lame_set_mode( gfp, (MPEG_mode_e)the_Properties.GetChannelModeValue()) ; /// \todo Get the mode from the default configuration // lame_set_VBR( gfp, vbr_off ); /// \note VBR not supported for the moment lame_set_VBR( gfp, my_VBRMode ); /// \note VBR not supported for the moment if (my_VBRMode == vbr_abr) { lame_set_VBR_q( gfp, 1 ); lame_set_VBR_mean_bitrate_kbps( gfp, (my_AvgBytesPerSec * 8 + 500) / 1000 ); if (24000 > lame_get_in_samplerate( gfp )) { // For MPEG-II lame_set_VBR_min_bitrate_kbps( gfp, 8); lame_set_VBR_max_bitrate_kbps( gfp, 160); } else { // For MPEG-I lame_set_VBR_min_bitrate_kbps( gfp, 32); lame_set_VBR_max_bitrate_kbps( gfp, 320); } } // Set bitrate lame_set_brate( gfp, my_AvgBytesPerSec * 8 / 1000 ); /// \todo Get the mode from the default configuration // Set copyright flag? lame_set_copyright( gfp, the_Properties.GetCopyrightMode()?1:0 ); // Do we have to tag it as non original lame_set_original( gfp, the_Properties.GetOriginalMode()?1:0 ); // Add CRC? lame_set_error_protection( gfp, the_Properties.GetCRCMode()?1:0 ); // Set private bit? lame_set_extension( gfp, the_Properties.GetPrivateMode()?1:0 ); // INFO tag support not possible in ACM - it requires rewinding // output stream to the beginning after encoding is finished. lame_set_bWriteVbrTag( gfp, 0 ); if (0 == lame_init_params( gfp )) { //LAME encoding call will accept any number of samples. if ( 0 == lame_get_version( gfp ) ) { // For MPEG-II, only 576 samples per frame per channel my_SamplesPerBlock = 576 * lame_get_num_channels( gfp ); } else { // For MPEG-I, 1152 samples per frame per channel my_SamplesPerBlock = 1152 * lame_get_num_channels( gfp ); } } my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "version =%d",lame_get_version( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Layer =3"); switch ( lame_get_mode( gfp ) ) { case STEREO: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "mode =Stereo" ); break; case JOINT_STEREO: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "mode =Joint-Stereo" ); break; case DUAL_CHANNEL: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "mode =Forced Stereo" ); break; case MONO: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "mode =Mono" ); break; case NOT_SET: /* FALLTROUGH */ default: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "mode =Error (unknown)" ); break; } my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "sampling frequency =%.1f kHz", lame_get_in_samplerate( gfp ) /1000.0 ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "bitrate =%d kbps", lame_get_brate( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Vbr Min bitrate =%d kbps", lame_get_VBR_min_bitrate_kbps( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Vbr Max bitrate =%d kbps", lame_get_VBR_max_bitrate_kbps( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Quality Setting =%d", lame_get_quality( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Low pass frequency =%d", lame_get_lowpassfreq( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Low pass width =%d", lame_get_lowpasswidth( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "High pass frequency =%d", lame_get_highpassfreq( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "High pass width =%d", lame_get_highpasswidth( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "No Short Blocks =%d", lame_get_no_short_blocks( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "de-emphasis =%d", lame_get_emphasis( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "private flag =%d", lame_get_extension( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "copyright flag =%d", lame_get_copyright( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "original flag =%d", lame_get_original( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "CRC =%s", lame_get_error_protection( gfp ) ? "on" : "off" ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Fast mode =%s", ( lame_get_quality( gfp ) )? "enabled" : "disabled" ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Force mid/side stereo =%s", ( lame_get_force_ms( gfp ) )?"enabled":"disabled" ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Padding Type =%d", lame_get_padding_type( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Disable Resorvoir =%d", lame_get_disable_reservoir( gfp ) ); my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "VBR =%s, VBR_q =%d, VBR method =", ( lame_get_VBR( gfp ) !=vbr_off ) ? "enabled": "disabled", lame_get_VBR_q( gfp ) ); switch ( lame_get_VBR( gfp ) ) { case vbr_off: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "vbr_off" ); break; case vbr_mt : my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "vbr_mt" ); break; case vbr_rh : my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "vbr_rh" ); break; case vbr_mtrh: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "vbr_mtrh" ); break; case vbr_abr: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "vbr_abr (average bitrate %d kbps)", lame_get_VBR_mean_bitrate_kbps( gfp ) ); break; default: my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "error, unknown VBR setting"); break; } my_debug->OutPut(DEBUG_LEVEL_FUNC_DEBUG, "Write VBR Header =%s\n", ( lame_get_bWriteVbrTag( gfp ) ) ?"Yes":"No"); #ifdef FROM_DLL beConfig.format.LHV1.dwReSampleRate = my_OutBytesPerSec; // force the user resampling #endif // FROM_DLL bResult = true; return bResult; }