bool ACMStream::close(LPBYTE pOutputBuffer, DWORD *pOutputSize)
{
bool bResult = false;
int nOutputSamples = 0;
nOutputSamples = lame_encode_flush( gfp, pOutputBuffer, 0 );
if ( nOutputSamples < 0 )
{
// BUFFER_TOO_SMALL
*pOutputSize = 0;
}
else
{
*pOutputSize = nOutputSamples;
bResult = true;
}
// lame will be closed in destructor
//lame_close( gfp );
return bResult;
}
/* close connection to the peer */
static void mp3streamout_disconnect(t_mp3streamout *x)
{
int err = -1;
if(x->x_lame >= 0)
{
/* ignore remaining bytes */
if ( x->x_mp3size = lame_encode_flush( x->lgfp, x->x_mp3outbuf, 0) < 0 )
{
post( "mp3streamout~ : warning : remaining encoded bytes" );
}
lame_close( x->lgfp );
x->x_lame = -1;
post("mp3streamout~: encoder stream closed");
}
if(x->x_fd >= 0) /* close socket */
{
#ifdef _WIN32
closesocket(x->x_fd);
#else
close(x->x_fd);
#endif
x->x_fd = -1;
outlet_float( x->x_obj.ob_outlet, 0 );
post("mp3streamout~: connection closed");
}
}
/*------------------------------------------------------------------------------
* Flush the data from the encoder
*----------------------------------------------------------------------------*/
void
LameLibEncoder :: flush ( void )
throw ( Exception )
{
if ( !isOpen() ) {
return;
}
// data chunk size estimate according to lame documentation
unsigned int mp3Size = 7200;
unsigned char * mp3Buf = new unsigned char[mp3Size];
int ret;
ret = lame_encode_flush( lameGlobalFlags, mp3Buf, mp3Size );
unsigned int written = sink->write( mp3Buf, ret);
delete[] mp3Buf;
// just let go data that could not be written
if ( written < (unsigned int) ret ) {
reportEvent( 2,
"couldn't write all from encoder to underlying sink",
ret - written);
}
sink->flush();
}
bool MP3Writer::end() {
if(!is_setup) {
RX_ERROR(MP3_WRERR_NOT_SETUP);
return false;
}
if(!is_started) {
RX_ERROR(MP3_WRERR_NOT_STARTED);
return false;
}
int written = lame_encode_flush(lame_flags, (unsigned char*)mp3_buffer, MP3_WRITER_BUFFER_SIZE);
if(written < 0) {
RX_ERROR(MP3_WRERR_CANNOT_FLUSH);
}
else if(config.cb_data) {
config.cb_data((const char*)mp3_buffer, written, config.user);
}
lame_close(lame_flags);
config.cb_close(config.user);
lame_flags = NULL;
is_started = false;
return true;
}
void Java_com_iliayugai_zapp_utils_CommonUtils_encodeFile(JNIEnv *env,
jobject jobj, jstring in_source_path, jstring in_target_path) {
const char *source_path, *target_path;
source_path = (*env)->GetStringUTFChars(env, in_source_path, NULL);
target_path = (*env)->GetStringUTFChars(env, in_target_path, NULL);
FILE *input_file, *output_file;
input_file = fopen(source_path, "rb");
output_file = fopen(target_path, "wb");
short input[BUFFER_SIZE];
char output[BUFFER_SIZE];
int nb_read = 0;
int nb_write = 0;
int nb_total = 0;
LOGD("Encoding started");
while (nb_read = read_samples(input_file, input)) {
nb_write = lame_encode_buffer(lame, input, input, nb_read, output,
BUFFER_SIZE);
fwrite(output, nb_write, 1, output_file);
nb_total += nb_write;
}
LOGD("Encoded %d bytes", nb_total);
nb_write = lame_encode_flush(lame, output, BUFFER_SIZE);
fwrite(output, nb_write, 1, output_file);
LOGD("Flushed %d bytes", nb_write);
fclose(input_file);
fclose(output_file);
}
int doEncodeFinish(LameConf* conf, char* encodedBytes, int encodedArrayByteSize) {
if (conf->gf==NULL) {
//throwRuntimeException(env, "not initialized");
return org_tritonus_lowlevel_lame_Lame_NOT_INITIALIZED;
}
return lame_encode_flush(conf->gf, encodedBytes, encodedArrayByteSize);
}
bool LameAudioWriter::close_private()
{
if (m_bufferSize < 7200) {
if (m_buffer) {
delete [] m_buffer;
}
m_bufferSize = 7200;
m_buffer = new char[m_bufferSize];
}
bool success = true;
int size = lame_encode_flush(m_lameInfo->flags,
(unsigned char*)m_buffer,
m_bufferSize);
if (size < 0) {
PERROR("lame_encode_buffer_flush failed.");
success = false;
}
if (size > 0 && fwrite(m_buffer, 1, size, m_fid) != (nframes_t)size) {
PERROR("writing mp3 data failed.");
success = false;
}
else {
lame_mp3_tags_fid(m_lameInfo->flags, m_fid);
}
lame_close(m_lameInfo->flags);
m_lameInfo->flags = 0;
fclose(m_fid);
m_fid = 0;
return success;
}
int main(int argc, char** argv)
{
if(argc != 2)
{
printf("Usage: %s <wav file>\n", argv[0]);
exit(0);
}
lame_global_flags *gfp;
//set params
gfp = lame_init();
lame_set_num_channels(gfp,2);
lame_set_in_samplerate(gfp,44100);
lame_set_brate(gfp,128);
lame_set_mode(gfp,1);
lame_set_quality(gfp,2);
int ret_code = lame_init_params(gfp);
if(ret_code < 0)
{
printf("ret_code < 0\n");
exit(-1);
}
//read input file
int read, write;
FILE* pcm = fopen(argv[1], "rb");
char* outPath;
outPath = strdup(argv[1]);
sprintf(outPath+strlen(argv[1])-3, "mp3");
FILE* mp3 = fopen(outPath, "wb");
short int pcm_buffer[PCM_SIZE * 2];
unsigned char mp3_buffer[MP3_SIZE];
do
{
read = fread(pcm_buffer, 2*sizeof(short int), PCM_SIZE, pcm);
if(read == 0)
write = lame_encode_flush(gfp, mp3_buffer, MP3_SIZE);
else
write = lame_encode_buffer_interleaved(gfp, pcm_buffer, read, mp3_buffer, MP3_SIZE);
fwrite(mp3_buffer, write, sizeof (unsigned char), mp3);
}
while (read != 0);
lame_close(gfp);
fclose(mp3);
fclose(pcm);
exit(0);
}
media_packet_ptr lame_encoder_impl_internal::encode(const audio_data * _AudioData)
{
static const size_t mp3TimeBase = 14112000; // Least common multiple of 44100 and 32000
const int predSamplesInLame = lame_get_mf_samples_to_encode( m_Lame.get() );
// from lame:
// The required mp3buf_size can be computed from num_samples,
// samplerate and encoding rate, but here is a worst case estimate:
// mp3buf_size in bytes = 1.25*num_samples + 7200
const size_t samplesCount = (_AudioData) ? _AudioData->get_samples_count() : 0;
const size_t bufSize = static_cast<size_t>( 1.25 * samplesCount ) + 7200 ;
uint8_t * buffer = m_Buffer.get_buffer( bufSize );
int lameRet = 0;
if (_AudioData)
{
const size_t channelsCount = _AudioData->get_channels_count();
if (channelsCount == 1)
{
lameRet = lame_encode_buffer(
m_Lame.get(),
(short*)_AudioData->get_raw_data(),
(short*)_AudioData->get_raw_data(),
_AudioData->get_samples_count(),
buffer,
bufSize);
}
else
{
lameRet = lame_encode_buffer_interleaved(
m_Lame.get(),
(short*)_AudioData->get_raw_data(),
_AudioData->get_samples_count(),
buffer,
bufSize);
}
}
else
{
lameRet = lame_encode_flush(m_Lame.get(), buffer, bufSize) ;
}
const int samplesEncoded = predSamplesInLame + samplesCount - lame_get_mf_samples_to_encode( m_Lame.get() );
m_TotalSamplesEncoded += samplesEncoded;
common_media_packet2_ptr mediaPacket = common_media_packet2_ptr( new common_media_packet2() );
mediaPacket->setter()->set_data(buffer, lameRet, bufferAllocNew);
mediaPacket->setter()->set_media_type(DT_AVMEDIA_TYPE_AUDIO);
mediaPacket->setter()->set_time_base(dt_rational_t(1, mp3TimeBase));
mediaPacket->setter()->set_duration( samplesEncoded * (mp3TimeBase / get_input_sample_rate()) );
const dt_ts_t ts = m_TotalSamplesEncoded * (mp3TimeBase / get_input_sample_rate());
mediaPacket->setter()->set_pts( ts );
mediaPacket->setter()->set_dts( ts );
return mediaPacket;
}
/***********************************************************************
* Work
***********************************************************************
*
**********************************************************************/
int enclameWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
hb_buffer_t ** buf_out )
{
hb_work_private_t * pv = w->private_data;
hb_audio_t * audio = w->audio;
hb_buffer_t * in = *buf_in;
hb_buffer_t * buf;
if ( (*buf_in)->size <= 0 )
{
/* EOF on input - send it downstream & say we're done */
buf = hb_buffer_init( pv->output_bytes );
buf->size = lame_encode_flush( pv->lame, buf->data, LAME_MAXMP3BUFFER );
buf->s.start = pv->pts;
buf->s.stop = buf->s.start + 90000 * 1152 / audio->config.out.samplerate;
buf->s.type = AUDIO_BUF;
buf->s.frametype = HB_FRAME_AUDIO;
if( buf->size <= 0 )
{
hb_buffer_close( &buf );
}
// Add the flushed data
*buf_out = buf;
// Add the eof
if ( buf )
{
buf->next = in;
}
else
{
*buf_out = in;
}
*buf_in = NULL;
return HB_WORK_DONE;
}
hb_list_add( pv->list, *buf_in );
*buf_in = NULL;
*buf_out = buf = Encode( w );
while( buf )
{
buf->next = Encode( w );
buf = buf->next;
}
return HB_WORK_OK;
}
JNIEXPORT jint JNICALL Java_org_proof_recorder_service_jni_SimpleLame_flush(
JNIEnv *env, jclass cls, jbyteArray mp3buf) {
const jsize mp3buf_size = (*env)->GetArrayLength(env, mp3buf);
jbyte* j_mp3buf = (*env)->GetByteArrayElements(env, mp3buf, NULL);
int result = lame_encode_flush(glf, j_mp3buf, mp3buf_size);
(*env)->ReleaseByteArrayElements(env, mp3buf, j_mp3buf, 0);
return result;
}
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"));
}
}
jint Java_ice_caster_android_shout_Lame_flush(
JNIEnv *env, jclass cls, jbyteArray mp3buf) {
const jsize mp3buf_size = (*env)->GetArrayLength(env, mp3buf);
jbyte* j_mp3buf = (*env)->GetByteArrayElements(env, mp3buf, NULL);
int result = lame_encode_flush(glf, j_mp3buf, mp3buf_size);
(*env)->ReleaseByteArrayElements(env, mp3buf, j_mp3buf, 0);
return result;
}
JNIEXPORT jint JNICALL Java_cn_net_xyd_videoaudiodemo_mp3lame_SimpleLame_flush(
JNIEnv *env, jclass cls, jbyteArray mp3buf) {
const jsize mp3buf_size = (*env)->GetArrayLength(env, mp3buf);
jbyte* j_mp3buf = (*env)->GetByteArrayElements(env, mp3buf, NULL);
int result = lame_encode_flush(glf, j_mp3buf, mp3buf_size);
(*env)->ReleaseByteArrayElements(env, mp3buf, j_mp3buf, 0);
return result;
}
JNIEXPORT jint JNICALL Java_com_xiong_richard_greyparrot_SimpleLame_flush(
JNIEnv *env, jclass cls, jbyteArray mp3buf) {
const jsize mp3buf_size = (*env)->GetArrayLength(env, mp3buf);
jbyte* j_mp3buf = (*env)->GetByteArrayElements(env, mp3buf, NULL);
int result = lame_encode_flush(glf, j_mp3buf, mp3buf_size);
(*env)->ReleaseByteArrayElements(env, mp3buf, j_mp3buf, 0);
return result;
}
EmErrorCode LameEncoder::FlushRest()
{
int ret = lame_encode_flush(m_gfp, m_Buffer.data(), m_Buffer.size());
if (ret >= 0) {
if ((int)::fwrite(m_Buffer.data(), 1, ret, m_OutputFile) == ret) {
::lame_mp3_tags_fid(m_gfp, m_OutputFile);
return ErrorCode::Ok;
}
}
return ErrorCode::EncoderFailedToFlush;
}
JNIEXPORT jint JNICALL Java_com_anhuioss_crowdroid_util_RecordVoiceToMp3Lame_flush(
JNIEnv *env, jclass cls, jbyteArray mp3buf) {
const jsize mp3buf_size = (*env)->GetArrayLength(env, mp3buf);
jbyte* j_mp3buf = (*env)->GetByteArrayElements(env, mp3buf, NULL);
int result = lame_encode_flush(glf, j_mp3buf, mp3buf_size);
(*env)->ReleaseByteArrayElements(env, mp3buf, j_mp3buf, 0);
return result;
}
JNIEXPORT jint JNICALL Java_com_czt_mp3recorder_util_LameUtil_flush(
JNIEnv *env, jclass cls, jbyteArray mp3buf) {
const jsize mp3buf_size = (*env)->GetArrayLength(env, mp3buf);
jbyte* j_mp3buf = (*env)->GetByteArrayElements(env, mp3buf, NULL);
int result = lame_encode_flush(lame, j_mp3buf, mp3buf_size);
(*env)->ReleaseByteArrayElements(env, mp3buf, j_mp3buf, 0);
return result;
}
int WMp3Encoder::EncodeSamples(void *pSamples, unsigned int nNumberOfSamples)
{
ASSERT_W(c_nBitBerSample == 16);
if(c_fReady == 0)
{
err(ENCODER_NOT_READY);
return 0;
}
int nOutputBytes;
short *samples = (short*) pSamples;
unsigned int nHaveSamples = nNumberOfSamples;
if(nNumberOfSamples == 0)
{
nOutputBytes = lame_encode_flush(gfp, c_pWorkingBuffer, c_nSamplesBufferSizeInBytes);
if(nOutputBytes > 0)
c_write_callback(c_pWorkingBuffer, nOutputBytes, c_user_data); // Chunk ID
return 1;
}
while(nHaveSamples)
{
unsigned int nFill = c_NumberOfInputSamples;
if(nFill > nHaveSamples)
nFill = nHaveSamples;
if ( 1 == lame_get_num_channels( gfp ) )
{
nOutputBytes = lame_encode_buffer(gfp, samples, samples, nFill, c_pWorkingBuffer, 0);
samples = &samples[nFill];
}
else
{
nOutputBytes = lame_encode_buffer_interleaved(gfp, samples, nFill, c_pWorkingBuffer, 0);
samples = &samples[nFill * 2];
}
nHaveSamples -= nFill;
if(nOutputBytes > 0)
c_write_callback(c_pWorkingBuffer, nOutputBytes, c_user_data); // Chunk ID
}
return 1;
}
jint simple_lame_lib_flush(
JNIEnv* env, lame_global_flags* glf,
jbyteArray mp3buf) {
const jsize mp3buf_size = (*env)->GetArrayLength(env, mp3buf);
jbyte* j_mp3buf = (*env)->GetByteArrayElements(env, mp3buf, NULL);
int result = lame_encode_flush(glf, j_mp3buf, mp3buf_size);
(*env)->ReleaseByteArrayElements(env, mp3buf, j_mp3buf, 0);
return result;
}
/**
\fn encode
\brief Get an encoded mp3 packet
@param dest [in] Where to write datas
@param len [out] Length of encoded datas in bytes
@param samples [out] Number of samples
@return true on success, false on error
*/
bool AUDMEncoder_Lame::encode(uint8_t *dest, uint32_t *len, uint32_t *samples)
{
int32_t nbout;
*samples = BLOCK_SIZE; //FIXME
*len = 0;
if(AudioEncoderStopped==_state)
return false;
refillBuffer (_chunk);
if(AudioEncoderNoInput==_state)
{
int left=tmptail-tmphead;
if (left < _chunk)
{
if(left)
{
nbout=send(left,dest);
tmphead=tmptail;
ADM_info("[lame]Sending last packet\n");
goto cont;
}
// Flush
_state=AudioEncoderStopped;
nbout=lame_encode_flush(MYFLAGS,dest,16*1024);
if(nbout<0)
{
ADM_warning("Error while flushing lame\n");
return false;
}
*len=nbout;
*samples=BLOCK_SIZE;
ADM_info("[Lame] Flushing, last block is %d bytes\n",nbout);
return true;
}
}
nbout=send(_chunk,dest);
tmphead += _chunk;
cont:
if (nbout < 0)
{
printf ("[Lame] Error !!! : %"PRIi32"\n", nbout);
return false;
}
*len = nbout;
if (!*len)
*samples = 0;
else
*samples=BLOCK_SIZE;
return true;
}
//
// Finsh - flush the buffered samples
//
HRESULT CEncoder::Finish()
{
CAutoLock l(&m_lock);
if (!pgf || !m_outFrameBuf || (m_outOffset >= OUT_BUFFER_MAX))
return E_FAIL;
m_outOffset += lame_encode_flush(pgf, m_outFrameBuf + m_outOffset, OUT_BUFFER_SIZE - m_outOffset);
m_bFinished = TRUE;
return S_OK;
}
void mp3_close(int64_t handle){
mp3_file* ptr = (mp3_file *) handle;
if(ptr->err != -1){
int n = lame_encode_flush(ptr->gfp, (unsigned char *) ptr->frame, ptr->length);
if(n > 0 && ptr->file){
n = fwrite(ptr->frame, n, 1, ptr->file);
}
}
if(ptr->file){
fclose(ptr->file);
}
lame_close(ptr->gfp);
ptr->dec->~CSpeexDecoder();
free(ptr);
}
void Encoder(char* src, char* dst){
//printf("Inside Encoder : %s \n",src);
//printf("Inside Encoder : %s \n",dst);
if(src == NULL || dst == NULL)
return;
int read, write;
FILE* wav;
FILE* mp3;
wav = fopen(src, "rb");
if(wav == NULL){
printf(" Unable to open the file %s \n", src);
return;
}
mp3 = fopen(dst, "wb");
if(mp3 == NULL){
printf(" Unable to open the file %s \n", dst);
return;
}
const int PCM_SIZE = 8192;
const int MP3_SIZE = 8192;
short int PCM_BUFFER[2*PCM_SIZE];
char MP3_BUFFER[MP3_SIZE];
lame_t lame = lame_init();
lame_set_in_samplerate(lame, 44100);
lame_set_VBR(lame, vbr_default);
lame_init_params(lame);
do {
read = fread(PCM_BUFFER, 2*sizeof(short int), PCM_SIZE, wav);
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, mp3);
} while (read != 0);
lame_close(lame);
fclose(wav);
fclose(mp3);
}
int32_t mp3_stream_final(int64_t handle, char** ppch){
assert(ppch);
mp3_file* ptr = (mp3_file *) handle;
if(ptr->err != -1){
int n = lame_encode_flush(ptr->gfp, (unsigned char *) ptr->frame, ptr->length);
if(n > 0 && ptr->file){
n = fwrite(ptr->frame, n, 1, ptr->file);
}
ptr->err = n;
}
*ppch = ptr->frame;
int n = ptr->err;
if(ptr->err != -1){
ptr->err = -1;
}
return n;
}
static int MP3_close(FILE* fp, struct amci_file_desc_t* fmt_desc, int options, long h_codec,
struct amci_codec_t *codec)
{
int final_samples;
unsigned char mp3buffer[7200];
DBG("MP3: close. \n");
if(options == AMCI_WRONLY) {
if (!h_codec || !((mp3_coder_state*)h_codec)->gfp) {
ERROR("no valid codec handle!\n");
return -1;
}
if ((final_samples = lame_encode_flush(((mp3_coder_state*)h_codec)->gfp,mp3buffer, 7200))) {
fwrite(mp3buffer, 1, final_samples, fp);
DBG("MP3: flushing %d bytes from MP3 encoder.\n", final_samples);
}
lame_mp3_tags_fid(((mp3_coder_state*)h_codec)->gfp,fp);
}
return 0;
}
int encode_to_file(lame_global_flags *gfp, const FMT_DATA *hdr, const short *leftPcm, const short *rightPcm,
const int iDataSize, const char *filename)
{
int numSamples = iDataSize / hdr->wBlockAlign;
int mp3BufferSize = numSamples * 5 / 4 + 7200; // worst case estimate
unsigned char *mp3Buffer = new unsigned char[mp3BufferSize];
// call to lame_encode_buffer
int mp3size = lame_encode_buffer(gfp, (short*)leftPcm, (short*)rightPcm, numSamples, mp3Buffer, mp3BufferSize);
if (!(mp3size > 0)) {
delete[] mp3Buffer;
cerr << "No data was encoded by lame_encode_buffer. Return code: " << mp3size << endl;
return EXIT_FAILURE;
}
// write to file
FILE *out = fopen(filename, "wb+");
fwrite((void*)mp3Buffer, sizeof(unsigned char), mp3size, out);
// call to lame_encode_flush
int flushSize = lame_encode_flush(gfp, mp3Buffer, mp3BufferSize);
// write flushed buffers to file
fwrite((void*)mp3Buffer, sizeof(unsigned char), flushSize, out);
// call to lame_mp3_tags_fid (might be omitted)
lame_mp3_tags_fid(gfp, out);
fclose(out);
delete[] mp3Buffer;
#ifdef __VERBOSE_
cout << "Wrote " << mp3size + flushSize << " bytes." << endl;
#endif
return EXIT_SUCCESS;
}
/* stop recording */
static void mp3write_stop(t_mp3write *x)
{
int err = -1;
if ( x->x_fd < 0 ) {
post("mp3write~: stop received but no file has been set ... ignored.");
return;
}
if ( x->x_recflag == 0 ) {
post("mp3write~: stop received but recording is stopped ... ignored.");
return;
}
/* first stop recording / buffering and so on, than do the rest */
x->x_recflag = 0;
/* flushing remaining frames and tag */
x->x_mp3size = lame_encode_flush( x->lgfp, x->x_mp3outbuf, MY_MP3_MALLOC_OUT_SIZE );
mp3write_writeframes(x); /* write mp3 to file */
x->x_recflag = 0;
post("mp3write~: stop recording, flushed %d bytes", x->x_mp3size);
}
static inline void free_context(shout_context_t *context)
{
int ret;
if (context) {
switch_mutex_lock(context->audio_mutex);
context->err++;
switch_mutex_unlock(context->audio_mutex);
if (context->stream_url) {
int sanity = 0;
while (context->thread_running) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Waiting for stream to terminate: %s\n", context->stream_url);
switch_yield(500000);
if (++sanity > 10) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Giving up waiting for stream to terminate: %s\n", context->stream_url);
break;
}
}
}
switch_thread_rwlock_wrlock(context->rwlock);
if (context->mh) {
mpg123_close(context->mh);
mpg123_delete(context->mh);
}
if (context->fp) {
unsigned char mp3buffer[8192];
int len;
int16_t blank[2048] = { 0 }, *r = NULL;
if (context->channels == 2) {
r = blank;
}
len = lame_encode_buffer(context->gfp, blank, r, sizeof(blank) / 2, mp3buffer, sizeof(mp3buffer));
if (len) {
ret = fwrite(mp3buffer, 1, len, context->fp);
}
while ((len = lame_encode_flush(context->gfp, mp3buffer, sizeof(mp3buffer))) > 0) {
ret = fwrite(mp3buffer, 1, len, context->fp);
if (ret < 0) {
break;
}
}
lame_mp3_tags_fid(context->gfp, context->fp);
fclose(context->fp);
context->fp = NULL;
}
if (context->shout) {
shout_close(context->shout);
context->shout = NULL;
}
if (context->gfp) {
lame_close(context->gfp);
context->gfp = NULL;
}
if (context->audio_buffer) {
switch_buffer_destroy(&context->audio_buffer);
}
switch_mutex_destroy(context->audio_mutex);
switch_thread_rwlock_unlock(context->rwlock);
switch_thread_rwlock_destroy(context->rwlock);
}
}
void do_broadcast(switch_stream_handle_t *stream)
{
char *path_info = switch_event_get_header(stream->param_event, "http-path-info");
char *file;
lame_global_flags *gfp = NULL;
switch_file_handle_t fh = { 0 };
unsigned char mp3buf[TC_BUFFER_SIZE] = "";
uint8_t buf[1024];
int rlen;
int is_local = 0;
uint32_t interval = 20000;
if (strstr(path_info + 7, "://")) {
file = strdup(path_info + 7);
is_local++;
} else {
file = switch_mprintf("%s/streamfiles/%s", SWITCH_GLOBAL_dirs.base_dir, path_info + 7);
}
assert(file);
if (switch_core_file_open(&fh, file, 0, 0, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
memset(&fh, 0, sizeof(fh));
stream->write_function(stream, "Content-type: text/html\r\n\r\n<h2>File not found</h2>\n");
goto end;
}
if (switch_test_flag((&fh), SWITCH_FILE_NATIVE)) {
stream->write_function(stream, "Content-type: text/html\r\n\r\n<h2>File format not supported</h2>\n");
goto end;
}
if (!(gfp = lame_init())) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate lame\n");
goto end;
}
lame_set_num_channels(gfp, fh.channels);
lame_set_in_samplerate(gfp, fh.samplerate);
lame_set_brate(gfp, 16 * (fh.samplerate / 8000) * fh.channels);
lame_set_mode(gfp, 3);
lame_set_quality(gfp, 2);
lame_set_errorf(gfp, log_error);
lame_set_debugf(gfp, log_debug);
lame_set_msgf(gfp, log_msg);
lame_set_bWriteVbrTag(gfp, 0);
lame_mp3_tags_fid(gfp, NULL);
lame_init_params(gfp);
lame_print_config(gfp);
stream->write_function(stream, "Content-type: audio/mpeg\r\n" "Content-Disposition: inline; filename=\"%s.mp3\"\r\n\r\n", path_info + 7);
if (fh.interval) {
interval = fh.interval * 1000;
}
for (;;) {
switch_size_t samples = sizeof(buf) / 2;
switch_core_file_read(&fh, buf, &samples);
if (is_local) {
switch_yield(interval);
}
if (!samples) {
break;
}
if ((rlen = lame_encode_buffer(gfp, (void *) buf, NULL, samples, mp3buf, sizeof(mp3buf))) < 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "MP3 encode error %d!\n", rlen);
goto end;
}
if (rlen) {
if (stream->raw_write_function(stream, mp3buf, rlen)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Disconnected\n");
goto end;
}
}
}
while ((rlen = lame_encode_flush(gfp, mp3buf, sizeof(mp3buf))) > 0) {
if (stream->raw_write_function(stream, mp3buf, rlen)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Disconnected\n");
goto end;
}
}
end:
if (fh.channels) {
switch_core_file_close(&fh);
}
switch_safe_free(file);
if (gfp) {
lame_close(gfp);
gfp = NULL;
}
}
