int CLameDecoder::Init()
{
m_lame = lame_init();
if(m_lame == NULL)
{
m_pDebug->Format("[lame_init] failed");
return -1;
}
//set lame parameters
lame_set_decode_only(m_lame, 1);
lame_set_num_samples(m_lame, MAX_U_32_NUM);
//init decoder
m_hip = hip_decode_init();
if(m_hip == NULL)
{
m_pDebug->Format("[hip_decode_init] failed");
return -1;
}
m_is = new BlockBufferInputStream();
//other internal parameters
m_nDelay = -1;
m_nPadding = -1;
m_nState = STATE_INIT;
m_nTotalSamples = 0;
return 0;
}
static void mp3_close(void)
{
if (output_file) {
int imp3, encout;
/* write remaining mp3 data */
encout = lame_encode_flush_nogap(gfp, encbuffer, LAME_MAXMP3BUFFER);
write_output(encbuffer, encout);
/* set gfp->num_samples for valid TLEN tag */
lame_set_num_samples(gfp, numsamples);
/* append v1 tag */
imp3 = lame_get_id3v1_tag(gfp, encbuffer, sizeof(encbuffer));
if (imp3 > 0)
write_output(encbuffer, imp3);
/* update v2 tag */
imp3 = lame_get_id3v2_tag(gfp, encbuffer, sizeof(encbuffer));
if (imp3 > 0) {
if (vfs_fseek(output_file, 0, SEEK_SET) != 0) {
AUDDBG("can't rewind\n");
}
else {
write_output(encbuffer, imp3);
}
}
/* update lame tag */
if (id3v2_size) {
if (vfs_fseek(output_file, id3v2_size, SEEK_SET) != 0) {
AUDDBG("fatal error: can't update LAME-tag frame!\n");
}
else {
imp3 = lame_get_lametag_frame(gfp, encbuffer, sizeof(encbuffer));
write_output(encbuffer, imp3);
}
}
}
g_free (write_buffer);
lame_close(gfp);
AUDDBG("lame_close() done\n");
free_lameid3(&lameid3);
numsamples = 0;
}
void *complete_encode_worker(void* arg)
{
int ret;
ENC_WRK_ARGS *args = (ENC_WRK_ARGS*)arg; // parse argument struct
while (true) {
#ifdef __VERBOSE_
cout << "Checking for work\n";
#endif
// determine which file to process next
bool bFoundWork = false;
int iFileIdx = -1;
pthread_mutex_lock(&mutFilesFinished);
for (int i = 0; i < args->iNumFiles; i++) {
if (!args->pbFilesFinished[i]) {
args->pbFilesFinished[i] = true; // mark as being worked on
iFileIdx = i;
bFoundWork = true;
break;
}
}
pthread_mutex_unlock(&mutFilesFinished);
if (!bFoundWork) {// done yet?
return NULL; // break
}
string sMyFile = args->pFilenames->at(iFileIdx);
string sMyFileOut = sMyFile.substr(0, sMyFile.length() - 3) + "mp3";
// start working
FMT_DATA *hdr = NULL;
short *leftPcm = NULL, *rightPcm = NULL;
// init encoding params
lame_global_flags *gfp = lame_init();
lame_set_brate(gfp, 192); // increase bitrate
lame_set_quality(gfp, 3); // increase quality level
lame_set_bWriteVbrTag(gfp, 0);
// parse wave file
#ifdef __VERBOSE_
printf("Parsing %s ...\n", sMyFile.c_str());
#endif
int iDataSize = -1;
ret = read_wave(sMyFile.c_str(), hdr, leftPcm, rightPcm, iDataSize);
if (ret != EXIT_SUCCESS) {
printf("Error in file %s. Skipping.\n", sMyFile.c_str());
continue; // see if there's more to do
}
lame_set_num_channels(gfp, hdr->wChannels);
lame_set_num_samples(gfp, iDataSize / hdr->wBlockAlign);
// check params
ret = lame_init_params(gfp);
if (ret != 0) {
cerr << "Invalid encoding parameters! Skipping file." << endl;
continue;
}
// encode to mp3
ret = encode_to_file(gfp, hdr, leftPcm, rightPcm, iDataSize, sMyFileOut.c_str());
if (ret != EXIT_SUCCESS) {
cerr << "Unable to encode mp3: " << sMyFileOut.c_str() << endl;
continue;
}
printf("[:%i][ok] .... %s\n", args->iThreadId, sMyFile.c_str());
++args->iProcessedFiles;
lame_close(gfp);
if (leftPcm != NULL) delete[] leftPcm;
if (rightPcm != NULL) delete[] rightPcm;
if (hdr != NULL) delete hdr;
}
pthread_exit((void*)0);
}
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 OutLame::apply_profile() {
if(enc_flags) lame_close(enc_flags);
enc_flags = lame_init();
lame_set_errorf(enc_flags,(void (*)(const char*, va_list))error);
lame_set_debugf(enc_flags,(void (*)(const char*, va_list))func);
lame_set_msgf(enc_flags,(void (*)(const char*, va_list))act);
lame_set_num_samples(enc_flags,OUT_CHUNK);
lame_set_num_channels(enc_flags,2); // the mixed input stream is stereo
lame_set_in_samplerate(enc_flags,SAMPLE_RATE); // the mixed input stream is 44khz
lame_set_error_protection(enc_flags,1); // 2 bytes per frame for a CRC checksum
lame_set_compression_ratio(enc_flags,0);
lame_set_quality(enc_flags,2); // 1..9 1=best 9=worst (suggested: 2, 5, 7)
// lame_set_VBR(enc_flags,vbr_abr);
/* BITRATE */
lame_set_brate(enc_flags,bps());
Shouter *ice = (Shouter*)icelist.begin();
while(ice) {
char tmp[256];
snprintf(tmp,256,"%u",bps()); ice->bps( tmp );
snprintf(tmp,256,"%u",freq()); ice->freq( tmp );
snprintf(tmp,256,"%u",channels()); ice->channels( tmp );
ice = (Shouter*)ice->next;
}
lame_set_out_samplerate(enc_flags,freq());
/* CHANNELS
mode 2 (double channel) is unsupported */
int mode;
switch( channels() ) {
/* 0,1,2,3 stereo,jstereo,dual channel,mono */
case 1: mode = 3; break;
case 2: mode = 1; break;
default: mode = 3; break;
}
lame_set_mode(enc_flags,(MPEG_mode_e)mode);
/* in case of VBR
func("reversed quality is %i, guessed bps %i",(int)fabs( 10 - quality()),bps());
lame_set_VBR_q(enc_flags,(int)fabs( 10 - quality() ));
lame_set_VBR_mean_bitrate_kbps(enc_flags,bps());
*/
/* lame chooses for us frequency filtering when values are 0 */
lame_set_lowpassfreq(enc_flags,lowpass());
lame_set_highpassfreq(enc_flags,highpass());
int res = lame_init_params(enc_flags);
if(res<0) {
error("lame_init_params failed");
lame_close(enc_flags);
enc_flags = NULL;
}
return (res<0)?false:true;
}
