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; }
//________________________________________________ // Init lame encoder // frequence : Impose frequency , 0 means reuse the incoming fq // mode : ADM_STEREO etc... // bitrate : Bitrate in kbps (96,192...) // return 0 : init failed // 1 : init succeeded //_______________________________________________ uint8_t AVDMProcessAudio_Lame::initLame(uint32_t frequence, uint32_t mode, uint32_t bitrate, ADM_LAME_PRESET preset) { int ret, ratio; MPEG_mode_e mmode; double dratio; myflags = lame_init(); if (myflags == NULL) return 0; // recompute output length // since we compress recompute the length in bytes double comp; comp=_instream->getLength(); comp/=2; // 16 bits sample comp/=_wavheader->channels; // We got sample comp/=_wavheader->frequency; // and no we got seconds comp*=bitrate*1000; comp/=8; // now we got bytes _length=(uint32_t) floor(comp+1); printf("Incoming : %lu bytes, fq : %lu, channel : %lu bitrate: %lu outgoing : %lu\n", _instream->getLength(),_wavheader->frequency,_wavheader->channels,bitrate,_length); //initLame(frequence,mode,bitrate); ret = lame_set_in_samplerate(myflags, _instream->getInfo()->frequency); ret = lame_set_num_channels(myflags, _instream->getInfo()->channels); if (frequence == 0) // keep same as instream frequence = _instream->getInfo()->frequency; printf("\n output frequency : %lu\n", frequence); ret = lame_set_out_samplerate(myflags, frequence); ret = lame_set_quality(myflags, 2); //max quality); if (_instream->getInfo()->channels == 2) { switch (mode) { case ADM_STEREO: mmode = STEREO; break; case ADM_JSTEREO: mmode = JOINT_STEREO; break; default: printf("\n **** unknown mode ***\n"); mmode = STEREO; break; } } else { mmode = MONO; printf("\n mono audio mp3"); } _mode=mmode; ret = lame_set_brate(myflags, bitrate); ret = lame_set_mode(myflags, mmode); // 0 stereo 1 jstero ret = lame_init_params(myflags); if (ret == -1) return 0; // update bitrate in header _wavheader->byterate = (bitrate >> 3) * 1000; // configure CBR/ABR/... _preset=preset; switch(preset) { default: case ADM_LAME_PRESET_CBR: break; case ADM_LAME_PRESET_ABR: lame_set_preset( myflags, bitrate); _wavheader->blockalign=1152; break; case ADM_LAME_PRESET_EXTREME: _wavheader->blockalign=1152; lame_set_preset( myflags, EXTREME); break; } lame_print_config(myflags); lame_print_internals(myflags); return 1; }
bool AUDMEncoder_Lame::initialize (void) { int ret; MPEG_mode_e mmode; uint32_t frequence; lameFlags = lame_init (); if (lameFlags == NULL) return false; if (_incoming->getInfo ()->channels > 2) { printf ("[Lame]Too many channels\n"); return false; } // recompute output length ret = lame_set_in_samplerate (MYFLAGS, wavheader.frequency); ret = lame_set_num_channels (MYFLAGS, wavheader.channels); frequence = wavheader.frequency; printf ("[Lame] output frequency : %"PRIu32"\n", frequence); ret = lame_set_out_samplerate (MYFLAGS, frequence); ret = lame_set_quality (MYFLAGS, 2); if (wavheader.channels == 2) { mmode = STEREO; } else { mmode = MONO; printf ("[Lame] mono audio mp3"); } ret = lame_set_brate (MYFLAGS, _config.bitrate); ret = lame_set_mode (MYFLAGS, mmode); // 0 stereo 1 jstero ret = lame_set_quality (MYFLAGS, _config.quality); // 0 stereo 1 jstero ret = lame_set_disable_reservoir (MYFLAGS, _config.disableBitReservoir); printf ("[Lame]Using quality of %d\n", lame_get_quality (MYFLAGS)); // update bitrate in header wavheader.byterate = (_config.bitrate >> 3) * 1000; #define BLOCK_SIZE 1152 // configure CBR/ABR/... switch (_config.preset) { default: case ADM_LAME_PRESET_CBR: ADM_info("Lame : CBR Mode\n"); break; case ADM_LAME_PRESET_ABR: ADM_info("Lame : ABR Mode\n"); lame_set_preset (MYFLAGS, _config.bitrate); wavheader.blockalign = BLOCK_SIZE; break; case ADM_LAME_PRESET_EXTREME: ADM_info("Lame : Extreme Mode\n"); wavheader.blockalign = BLOCK_SIZE; lame_set_preset (MYFLAGS, EXTREME); break; } ret = lame_init_params (MYFLAGS); if (ret == -1) { printf("[Lame] Init params failes %d\n",ret); return false; } lame_print_config (MYFLAGS); lame_print_internals (MYFLAGS); _chunk = BLOCK_SIZE * wavheader.channels; return true; }
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); } } }
//________________________________________________ // Init lame encoder // frequence : Impose frequency , 0 means reuse the incoming fq // mode : ADM_STEREO etc... // bitrate : Bitrate in kbps (96,192...) // return 0 : init failed // 1 : init succeeded //_______________________________________________ uint8_t AUDMEncoder_Lame::init(ADM_audioEncoderDescriptor *config) { int ret; MPEG_mode_e mmode; uint32_t frequence; LAME_encoderParam *lameConf=(LAME_encoderParam *)config->param; ADM_assert(config->paramSize==sizeof(LAME_encoderParam)); lameFlags = lame_init(); if (lameFlags == NULL) return 0; if(_incoming->getInfo()->channels>2) { printf("Too many channels\n"); return 0; } // recompute output length ret = lame_set_in_samplerate(MYFLAGS, _wavheader->frequency); ret = lame_set_num_channels(MYFLAGS, _wavheader->channels); frequence = _wavheader->frequency; printf("\n output frequency : %lu\n", frequence); ret = lame_set_out_samplerate(MYFLAGS, frequence); ret = lame_set_quality(MYFLAGS, 2); if (_wavheader->channels == 2) { switch (lameConf->mode) { case ADM_STEREO: mmode = STEREO; break; case ADM_JSTEREO: mmode = JOINT_STEREO; break; default: printf("\n **** unknown mode ***\n"); mmode = STEREO; break; } } else { mmode = MONO; printf("\n mono audio mp3"); } ret = lame_set_brate(MYFLAGS, config->bitrate); ret = lame_set_mode(MYFLAGS, mmode); // 0 stereo 1 jstero ret = lame_set_quality(MYFLAGS, lameConf->quality); // 0 stereo 1 jstero ret = lame_set_disable_reservoir(MYFLAGS,lameConf->disableReservoir); printf("[Lame]Using quality of %d\n",lame_get_quality(MYFLAGS)); ret = lame_init_params(MYFLAGS); if (ret == -1) return 0; // update bitrate in header _wavheader->byterate = (config->bitrate >> 3) * 1000; #define BLOCK_SIZE 1152 // configure CBR/ABR/... _preset=lameConf->preset; switch(_preset) { default: case ADM_LAME_PRESET_CBR: break; case ADM_LAME_PRESET_ABR: lame_set_preset( MYFLAGS, config->bitrate); _wavheader->blockalign=BLOCK_SIZE; break; case ADM_LAME_PRESET_EXTREME: _wavheader->blockalign=BLOCK_SIZE; lame_set_preset( MYFLAGS, EXTREME); break; } lame_print_config(MYFLAGS); lame_print_internals(MYFLAGS); _chunk=BLOCK_SIZE*_wavheader->channels; return 1; }
bool AudioEncoderMP3::initialize() { if(lame_flags) { STREAMER_ERROR("error: cannot initialize AudioEncoder because lame_flags has been setup already.\n"); return false; } if(settings.bitsize == AV_AUDIO_BITSIZE_UNKNOWN) { STREAMER_ERROR("error: cannot initialize AudioEncoder because the set bitsize is invalid.\n"); return false; } if(settings.in_bitsize == AV_AUDIO_BITSIZE_UNKNOWN) { settings.in_bitsize = settings.bitsize; } if(settings.mode == AV_AUDIO_MODE_UNKNOWN) { STREAMER_ERROR("error: cannot initialize AudioEncoder because the mode (mono/stereo) is invalid.\n"); return false; } if(settings.samplerate == AV_AUDIO_SAMPLERATE_UNKNOWN) { STREAMER_ERROR("error: cannot intialize the AudioEncoder because the samplerate is invalid.\n"); return false; } if(!settings.bitrate) { STREAMER_ERROR("error: cannot initialize the AudioEncoder because the bitrate was not set.\n"); return false; } if(settings.samplerate == AV_AUDIO_SAMPLERATE_44100) { samplerate = 44100; } else if(settings.samplerate == AV_AUDIO_SAMPLERATE_22050) { samplerate = 22050; } else { STREAMER_ERROR("error: invalid samplerate given for the AudioEncoder.\n"); return false; } if(settings.mode == AV_AUDIO_MODE_STEREO) { mode = STEREO; nchannels = 2; } else if(settings.mode == AV_AUDIO_MODE_MONO) { mode = MONO; nchannels = 1; STREAMER_ERROR("error: for now we only implement stereo audio.\n"); return false; } else { STREAMER_ERROR("error: invalid mode given for the AudioEncoder.\n"); return false; } if(settings.quality > 9) { STREAMER_ERROR("error: invalid quality given for the AudioEncoder, use a value between 0 (best) and 9 (worst).\n"); return false; } lame_flags = lame_init(); if(!lame_flags) { STREAMER_ERROR("error: cannot initalize lame.\n"); return false; } lame_set_num_channels(lame_flags, (mode == STEREO) ? 2 : 1); lame_set_in_samplerate(lame_flags, samplerate); lame_set_brate(lame_flags, settings.bitrate); lame_set_VBR(lame_flags, vbr_off); lame_set_mode(lame_flags, mode); lame_set_quality(lame_flags, settings.quality); if(lame_init_params(lame_flags) < 0) { STREAMER_ERROR("error: cannot initialize the lame parameters.\n"); return false; } #if !defined(NDEBUG) lame_print_config(lame_flags); lame_print_internals(lame_flags); STREAMER_VERBOSE("lame: bitrate: %d\n", lame_get_brate(lame_flags)); #endif bitrate_time_started = uv_hrtime(); bitrate_timeout = bitrate_time_started + bitrate_delay; return true; }