bool LameAudioWriter::open_private()
{
m_fid = fopen(m_fileName.toUtf8().data(), "w+");
if (!m_fid) {
return false;
}
m_lameInfo->flags = lame_init();
if (m_lameInfo->flags == 0) {
PERROR("lame_init failed.");
return false;
}
if (m_channels == 1) {
lame_set_mode(m_lameInfo->flags, MONO);
}
lame_set_num_channels(m_lameInfo->flags, m_channels);
lame_set_in_samplerate(m_lameInfo->flags, m_rate);
lame_set_out_samplerate(m_lameInfo->flags, m_rate);
if(m_method == 0) {
// Constant Bitrate
lame_set_VBR(m_lameInfo->flags, vbr_off);
lame_set_brate(m_lameInfo->flags, m_maxBitrate);
}
else if (m_method == 1) {
// Average Bitrate
lame_set_VBR(m_lameInfo->flags, vbr_abr);
lame_set_VBR_mean_bitrate_kbps(m_lameInfo->flags, m_maxBitrate);
}
else if (m_method == 2) {
// Variable Bitrate (old)
lame_set_VBR(m_lameInfo->flags, vbr_default);
lame_set_VBR_min_bitrate_kbps(m_lameInfo->flags, m_minBitrate);
lame_set_VBR_max_bitrate_kbps(m_lameInfo->flags, m_maxBitrate);
}
else if (m_method == 3) {
// Variable Bitrate (new)
lame_set_VBR(m_lameInfo->flags, vbr_default);
lame_set_VBR_min_bitrate_kbps(m_lameInfo->flags, m_minBitrate);
lame_set_VBR_max_bitrate_kbps(m_lameInfo->flags, m_maxBitrate);
}
lame_set_quality(m_lameInfo->flags, m_quality);
//
// file options
//
lame_set_copyright(m_lameInfo->flags, false);
lame_set_original(m_lameInfo->flags, true);
lame_set_strict_ISO(m_lameInfo->flags, false);
lame_set_error_protection(m_lameInfo->flags, false);
return (lame_init_params(m_lameInfo->flags ) != -1);
}
void AudioReader::exportAudioDataToMP3(const char* data)
{
QSettings settings;
emit TCMessage("Exporting MP3...");
int read, write;
FILE *pcm = fopen("TCTemp.wav", "wb");
fwrite(data,1,format.chunkSize,pcm);
fflush(pcm);
pcm = fopen("TCTemp.wav", "rb");
f = fopen(this->outfile.toLocal8Bit().constData(), "wb");
const int PCM_SIZE = 8192;
const int MP3_SIZE = 8192*2;
short int pcm_buffer[PCM_SIZE*2];
unsigned char mp3_buffer[MP3_SIZE];
lame_t lame = lame_init();
lame_set_in_samplerate(lame, format.SampleRate);
lame_set_VBR(lame, (vbr_mode)settings.value("vbr",0).toInt());
if(lame_get_VBR(lame)) {
lame_set_VBR_min_bitrate_kbps(lame,settings.value("min",128).toInt());
lame_set_VBR_max_bitrate_kbps(lame,settings.value("max",192).toInt());
}
else
{
lame_set_brate(lame,settings.value("min",128).toInt());
}
lame_set_num_channels(lame,(int)format.Channels);
lame_set_quality(lame,0);
if(format.Channels==1)lame_set_mode(lame,MONO);
else lame_set_mode(lame,STEREO);
lame_init_params(lame);
do {
if(!knock->running)break;
read = fread(pcm_buffer, 2*byte_size, PCM_SIZE, pcm);
fflush(f);
if (read == 0)
write = lame_encode_flush(lame, mp3_buffer, MP3_SIZE);
else
write = lame_encode_buffer_interleaved(lame, pcm_buffer, read, mp3_buffer, MP3_SIZE);
fwrite(mp3_buffer, write, 1, f);
fflush(f);
} while (read != 0);
lame_close(lame);
fclose(pcm);
if(unlink("TCTemp.wav")!=0) {
emit TCColor("color: red;");
emit TCMessage(QString("Error while removing TCTemp.wav"));
}
}
//////////////////////////////////////////////////////////////////////
// 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;
}
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;
}
void lame_encoder_impl_internal::set_vbr_min_bitrate_kbps(int _Bitrate)
{
int lameRet = lame_set_VBR_min_bitrate_kbps(m_Lame.get(), _Bitrate);
DT_LAME_CHECK_ERR(lameRet);
}
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;
}
