static void gst_mpg123_audio_dec_flush (GstAudioDecoder * dec, gboolean hard) { int error; GstMpg123AudioDec *mpg123_decoder; hard = hard; GST_LOG_OBJECT (dec, "Flushing decoder"); mpg123_decoder = GST_MPG123_AUDIO_DEC (dec); g_assert (mpg123_decoder->handle != NULL); /* Flush by reopening the feed */ mpg123_close (mpg123_decoder->handle); error = mpg123_open_feed (mpg123_decoder->handle); if (G_UNLIKELY (error != MPG123_OK)) { GST_ELEMENT_ERROR (dec, LIBRARY, INIT, (NULL), ("Error while reopening mpg123 feed: %s", mpg123_plain_strerror (error))); mpg123_close (mpg123_decoder->handle); mpg123_delete (mpg123_decoder->handle); mpg123_decoder->handle = NULL; } mpg123_decoder->has_next_audioinfo = FALSE; /* opening/closing feeds do not affect the format defined by the * mpg123_format() call that was made in gst_mpg123_audio_dec_set_format(), * and since the up/downstream caps are not expected to change here, no * mpg123_format() calls are done */ }
Mpg123Decoder::Mpg123Decoder(Data *data, const std::string &ext, int bufferSize) : Decoder(data, ext, bufferSize) , handle(0) , channels(MPG123_STEREO) { data_size = data->getSize(); data_offset = 0; int ret; if (!inited) { ret = mpg123_init(); if (ret != MPG123_OK) throw love::Exception("Could not initialize mpg123."); inited = (ret == MPG123_OK); } //Intialize the handle handle = mpg123_new(NULL, &ret); if (handle == NULL) throw love::Exception("Could not create handle."); ret = mpg123_open_feed(handle); if (ret != MPG123_OK) throw love::Exception("Could not open feed."); ret = feed(16384); if (ret != MPG123_OK && ret != MPG123_DONE) throw love::Exception("Could not feed!"); }
/***************************************************************************** * MPG123Open *****************************************************************************/ static int MPG123Open( decoder_t *p_dec ) { decoder_sys_t *p_sys = p_dec->p_sys; /* Create our mpg123 handle */ if( ( p_sys->p_handle = mpg123_new( NULL, NULL ) ) == NULL ) { msg_Err( p_dec, "mpg123 error: can't create handle" ); return VLC_EGENERIC; } /* Open a new bitstream */ if( mpg123_open_feed( p_sys->p_handle ) != MPG123_OK ) { msg_Err( p_dec, "mpg123 error: can't open feed" ); mpg123_delete( p_sys->p_handle ); return VLC_EGENERIC; } /* Disable resync stream after error */ mpg123_param( p_sys->p_handle, MPG123_ADD_FLAGS, MPG123_NO_RESYNC, 0 ); /* Setup output format */ mpg123_format_none( p_sys->p_handle ); int i_ret = MPG123_OK; if( p_dec->fmt_in.audio.i_rate != 0 ) { i_ret = mpg123_format( p_sys->p_handle, p_dec->fmt_in.audio.i_rate, MPG123_MONO | MPG123_STEREO, MPG123_ENC_FLOAT_32 ); } else { /* The rate from the input is unknown. Tell mpg123 to accept all rates * to avoid conversion on their side */ static const long mp3_rates[] = { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, }; for( size_t i = 0; i < sizeof(mp3_rates) / sizeof(*mp3_rates) && i_ret == MPG123_OK; ++i ) { i_ret = mpg123_format( p_sys->p_handle, mp3_rates[i], MPG123_MONO | MPG123_STEREO, MPG123_ENC_FLOAT_32 ); } } if( i_ret != MPG123_OK ) { msg_Err( p_dec, "mpg123 error: %s", mpg123_strerror( p_sys->p_handle ) ); mpg123_close( p_sys->p_handle ); mpg123_delete( p_sys->p_handle ); return VLC_EGENERIC; } p_sys->b_opened = true; return VLC_SUCCESS; }
void play_stream(char *stream_uri) { ch = curl_easy_init(); if (ch) { curl_easy_setopt(ch, CURLOPT_URL, stream_uri); curl_easy_setopt(ch, CURLOPT_FOLLOWLOCATION, 1L); curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, write_callback); curl_easy_setopt(ch, CURLOPT_PROGRESSFUNCTION, progress_callback); curl_easy_setopt(ch, CURLOPT_NOPROGRESS, 0L); // make curl use the progress_callback mh = mpg123_new(NULL, NULL); if (mh) { mpg123_open_feed(mh); curl_easy_perform(ch); curl_easy_cleanup(ch); mpg123_close(mh); mpg123_delete(mh); ao_close(device); playback_stop = 0; } } }
bool nuiAudioDecoderPrivate::Init() { int err = MPG123_OK; if (sMpg123Counter == 0) { // init mpg123 library err = mpg123_init(); if (err != MPG123_OK) return false; sMpg123Counter++; } // new handle mpHandle = mpg123_new(NULL, &err); if (!mpHandle) return false; // open decoder and prepare for direct feeding err = mpg123_open_feed(mpHandle); if (err != MPG123_OK) { mpg123_delete(mpHandle); mpHandle = NULL; return false; } return true; }
int main(int argc, char *argv[]){ if(argc < 2) return 0; ao_initialize(); mpg123_init(); mh = mpg123_new(NULL, NULL); mpg123_open_feed(mh); CURL *curl = curl_easy_init(); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, play_stream); curl_easy_setopt(curl, CURLOPT_URL, argv[1]); curl_easy_perform(curl); curl_easy_cleanup(curl); mpg123_close(mh); mpg123_delete(mh); mpg123_exit(); ao_close(dev); ao_shutdown(); return 0; }
bool MP3InputStream::initialize(FilePtr file) { m_file = file; m_seekable = m_file->seek(0, File::END); m_file->seek(0, File::BEGIN); m_eof = false; mh = mpg123_new(NULL,NULL); if (mpg123_open_feed(mh) != MPG123_OK) { return false; } m_input_position = 0; m_input_length = 0; m_decode_buffer = new u8[4608]; // as I have no reason to set a specific value, I used the one from MPaudec if (!m_decode_buffer) return false; m_first_frame = true; if (m_seekable) { // Scan the file to determine the length. mpg123_scan(mh); } // this should fill in the audio format if it isn't set already return decodeFrame(); }
/** Init native decoder by initializing libmpg123 and Java callbacks. */ jint Java_com_denisigo_netradioplayer_Decoder_initNative(JNIEnv* env, jobject thiz){ int ret; // Init mpg123 decoder mpg123_init(); mpg123_handle* hnd = mpg123_new(NULL, &ret); if(hnd == NULL) { LOGE("Unable to create mpg123 handle: %s\n", mpg123_plain_strerror(ret)); return 0; } // Set mpg123 to feed mode since we're providing data ourseves ret = mpg123_open_feed(hnd); if(ret != MPG123_OK) { LOGE("Unable open feed: %s\n", mpg123_plain_strerror(ret)); return 0; } // Init Java callback jclass thisClass = (*env)->GetObjectClass(env, thiz); method_onNewFormatCallback = (*env)->GetMethodID(env, thisClass, "onNewFormatCallback", "(III)V"); return (jint) hnd; }
static gboolean gst_mpg123_audio_dec_start (GstAudioDecoder * dec) { GstMpg123AudioDec *mpg123_decoder; int error; mpg123_decoder = GST_MPG123_AUDIO_DEC (dec); error = 0; mpg123_decoder->handle = mpg123_new (NULL, &error); mpg123_decoder->has_next_audioinfo = FALSE; mpg123_decoder->frame_offset = 0; /* Initially, the mpg123 handle comes with a set of default formats * supported. This clears this set. This is necessary, since only one * format shall be supported (see set_format for more). */ mpg123_format_none (mpg123_decoder->handle); /* Built-in mpg123 support for gapless decoding is disabled for now, * since it does not work well with seeking */ mpg123_param (mpg123_decoder->handle, MPG123_REMOVE_FLAGS, MPG123_GAPLESS, 0); /* Tells mpg123 to use a small read-ahead buffer for better MPEG sync; * essential for MP3 radio streams */ mpg123_param (mpg123_decoder->handle, MPG123_ADD_FLAGS, MPG123_SEEKBUFFER, 0); /* Sets the resync limit to the end of the stream (otherwise mpg123 may give * up on decoding prematurely, especially with mp3 web radios) */ mpg123_param (mpg123_decoder->handle, MPG123_RESYNC_LIMIT, -1, 0); #if MPG123_API_VERSION >= 36 /* The precise API version where MPG123_AUTO_RESAMPLE appeared is * somewhere between 29 and 36 */ /* Don't let mpg123 resample output */ mpg123_param (mpg123_decoder->handle, MPG123_REMOVE_FLAGS, MPG123_AUTO_RESAMPLE, 0); #endif /* Don't let mpg123 print messages to stdout/stderr */ mpg123_param (mpg123_decoder->handle, MPG123_ADD_FLAGS, MPG123_QUIET, 0); /* Open in feed mode (= encoded data is fed manually into the handle). */ error = mpg123_open_feed (mpg123_decoder->handle); if (G_UNLIKELY (error != MPG123_OK)) { GST_ELEMENT_ERROR (dec, LIBRARY, INIT, (NULL), ("%s", mpg123_strerror (mpg123_decoder->handle))); mpg123_close (mpg123_decoder->handle); mpg123_delete (mpg123_decoder->handle); mpg123_decoder->handle = NULL; return FALSE; } GST_INFO_OBJECT (dec, "mpg123 decoder started"); return TRUE; }
/*********************************************************************** * MPEG3_StreamOpen * */ static LRESULT MPEG3_StreamOpen(PACMDRVSTREAMINSTANCE adsi) { AcmMpeg3Data* aad; int err; assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC)); if (MPEG3_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF || MPEG3_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE; aad = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmMpeg3Data)); if (aad == 0) return MMSYSERR_NOMEM; adsi->dwDriver = (DWORD_PTR)aad; if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM) { goto theEnd; } else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 && adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM) { /* resampling or mono <=> stereo not available * MPEG3 algo only define 16 bit per sample output */ if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec || adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels || adsi->pwfxDst->wBitsPerSample != 16) goto theEnd; aad->convert = mp3_horse; aad->mh = mpg123_new(NULL,&err); mpg123_open_feed(aad->mh); } /* no encoding yet else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEGLAYER3) */ else goto theEnd; MPEG3_Reset(adsi, aad); return MMSYSERR_NOERROR; theEnd: HeapFree(GetProcessHeap(), 0, aad); adsi->dwDriver = 0L; return MMSYSERR_NOTSUPPORTED; }
void fm_player_play(fm_player_t *pl) { if (pl->status == FM_PLAYER_STOP) { mpg123_open_feed(pl->mh); pl->status = FM_PLAYER_PLAY; pl->info.file_size = 0; pl->info.samples = 0; pthread_create(&pl->tid_dl, NULL, download_thread, pl); pthread_create(&pl->tid_play, NULL, play_thread, pl); } else if (pl->status == FM_PLAYER_PAUSE) { pthread_mutex_lock(&pl->mutex_status); pl->status = FM_PLAYER_PLAY; pthread_mutex_unlock(&pl->mutex_status); pthread_cond_signal(&pl->cond_play); } }
static int control(struct dec_audio *da, int cmd, void *arg) { struct ad_mpg123_context *con = da->priv; switch (cmd) { case ADCTRL_RESET: mpg123_close(con->handle); if (mpg123_open_feed(con->handle) != MPG123_OK) { MP_ERR(da, "mpg123 failed to reopen stream: %s\n", mpg123_strerror(con->handle)); return CONTROL_FALSE; } return CONTROL_TRUE; } return CONTROL_UNKNOWN; }
/* Now we really start accessing some data and determining file format. * Format now is allowed to change on-the-fly. Here is the only point * that has MPlayer react to errors. We have to pray that exceptional * erros in other places simply cannot occur. */ static int init(struct dec_audio *da, const char *decoder) { if (!preinit(da)) return 0; struct ad_mpg123_context *con = da->priv; int ret; ret = mpg123_open_feed(con->handle); if (ret != MPG123_OK) goto fail; for (int n = 0; ; n++) { if (feed_new_packet(da) < 0) { ret = MPG123_NEED_MORE; goto fail; } size_t got_now = 0; ret = mpg123_decode_frame(con->handle, NULL, NULL, &got_now); if (ret == MPG123_OK || ret == MPG123_NEW_FORMAT) { ret = set_format(da); if (ret == MPG123_OK) break; } if (ret != MPG123_NEED_MORE) goto fail; // max. 16 retries (randomly chosen number) if (n > 16) { ret = MPG123_NEED_MORE; goto fail; } } return 1; fail: if (ret == MPG123_NEED_MORE) { MP_ERR(da, "Could not find mp3 stream.\n"); } else { MP_ERR(da, "mpg123 init error: %s\n", mpg123_strerror(con->handle)); } uninit(da); return 0; }
static uint8_t * ReadMP3(Sound_t * Sound, const uint8_t * InData, size_t FileSize){ mpg123_handle *mh; if(mpg123_init() != MPG123_OK || (mh = mpg123_new(NULL, NULL)) == NULL){ mpg123_exit(); return NULL; } long rate; int channels, encoding; unsigned samples; size_t OutSize; uint8_t * OutData; if(mpg123_format_none(mh) != MPG123_OK || mpg123_format(mh, 44100, MPG123_MONO | MPG123_STEREO, MPG123_ENC_SIGNED_16) != MPG123_OK || mpg123_open_feed(mh) != MPG123_OK || mpg123_feed(mh, InData, FileSize) != MPG123_OK || mpg123_set_filesize(mh, FileSize) != MPG123_OK || mpg123_getformat(mh, &rate, &channels, &encoding) != MPG123_OK || (samples = mpg123_length(mh)) == 0 || (OutData = (uint8_t*) malloc(OutSize = samples * channels * 2)) == NULL ){ mpg123_close(mh); mpg123_delete(mh); mpg123_exit(); return NULL; } size_t decoded; mpg123_read(mh, OutData, OutSize, &decoded); mpg123_close(mh); mpg123_delete(mh); mpg123_exit(); if(decoded != OutSize){ free(OutData); return NULL; } Sound->Channels = channels; Sound->SamplingRate = rate; Sound->BitDepth = 16; Sound->Duration = samples; Sound->Data = OutData; return OutData; }
void *play_url(void *urll) { char *url = (char *) urll; ao_initialize(); mpg123_init(); mh = mpg123_new(NULL, NULL); mpg123_open_feed(mh); CURL *curl = curl_easy_init(); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, play_stream); curl_easy_setopt(curl, CURLOPT_URL, url); CURLcode res = curl_easy_perform(curl); if (res != CURLE_OK) log_err("curl_easy_perform failed: %s", curl_easy_strerror(res)); curl_easy_cleanup(curl); return NULL; }
void MP3InputStream::reset() { ADR_GUARD("MP3InputStream::reset"); m_file->seek(0, File::BEGIN); m_eof = false; m_buffer.clear(); if (m_seekable) mpg123_seek(mh, 0, SEEK_SET); else { mpg123_close(mh); mpg123_open_feed(mh); } m_input_position = 0; m_input_length = 0; m_position = 0; }
JNIEXPORT jlong JNICALL Java_com_axelby_mp3decoders_MPG123_openStream (JNIEnv *env, jclass c) { // init mpg123 handle int err = MPG123_OK; mpg123_handle *mh = mpg123_new(NULL, &err); if (err != MPG123_OK) { __android_log_print(ANDROID_LOG_INFO, "podax-jni", "mpg123_new error: %s", mpg123_plain_strerror(err)); return 0; } // set handle up as stream err = mpg123_open_feed(mh); if (err != MPG123_OK) { __android_log_print(ANDROID_LOG_INFO, "podax-jni", "mpg123_open_feed error: %s", mpg123_plain_strerror(err)); return 0; } MP3File* stream = mp3file_init(mh); return (jlong)stream; }
static gboolean gst_mpg123_audio_dec_start (GstAudioDecoder * dec) { GstMpg123AudioDec *mpg123_decoder; int error; mpg123_decoder = GST_MPG123_AUDIO_DEC (dec); error = 0; mpg123_decoder->handle = mpg123_new (NULL, &error); mpg123_decoder->has_next_audioinfo = FALSE; mpg123_decoder->frame_offset = 0; /* Initially, the mpg123 handle comes with a set of default formats supported. This clears this set. This is necessary, since only one format shall be supported (see set_format for more). */ mpg123_format_none (mpg123_decoder->handle); mpg123_param (mpg123_decoder->handle, MPG123_REMOVE_FLAGS, MPG123_GAPLESS, 0); /* Built-in mpg123 support for gapless decoding is disabled for now, since it does not work well with seeking */ mpg123_param (mpg123_decoder->handle, MPG123_ADD_FLAGS, MPG123_SEEKBUFFER, 0); /* Tells mpg123 to use a small read-ahead buffer for better MPEG sync; essential for MP3 radio streams */ mpg123_param (mpg123_decoder->handle, MPG123_RESYNC_LIMIT, -1, 0); /* Sets the resync limit to the end of the stream (e.g. don't give up prematurely) */ /* Open in feed mode (= encoded data is fed manually into the handle). */ error = mpg123_open_feed (mpg123_decoder->handle); if (G_UNLIKELY (error != MPG123_OK)) { GstElement *element = GST_ELEMENT (dec); GST_ELEMENT_ERROR (element, STREAM, DECODE, (NULL), ("Error opening mpg123 feed: %s", mpg123_plain_strerror (error))); mpg123_close (mpg123_decoder->handle); mpg123_delete (mpg123_decoder->handle); mpg123_decoder->handle = NULL; return FALSE; } GST_DEBUG_OBJECT (dec, "mpg123 decoder started"); return TRUE; }
int in_mp3_init(plugin_obj *obj) { int r; NEW_PLUGIN_OBJ(obj); assert(obj != NULL); if (mpg123_init() != MPG123_OK) return REPLAY_ERR; obj->data = mpg123_new(NULL, &r); if (obj->data == NULL) return REPLAY_ERR; if (mpg123_open_feed(obj->data) != MPG123_OK) return REPLAY_ERR; assert(obj->data != NULL); return REPLAY_OK; }
void UMP3Decoder::Init(const uint8*& Buffer, const uint8* BufferEnd) { int encoding; int channels; long samplerate; mpg123_init(); Handle = mpg123_new(NULL, &ErrorHandle); BlockBufferSize = mpg123_outblock(Handle); mpg123_open_feed(Handle); mpg123_feed(Handle, Buffer, BufferEnd - Buffer); mpg123_getformat(Handle, &samplerate, &channels, &encoding); uint32 bytesPerSample = mpg123_encsize(encoding); BitsPerSample = bytesPerSample * 8; Channels = channels; Samplerate = samplerate; UE_LOG(MP3ImporterLog, Display, TEXT("Initialized: Samplerate: %u, Channels: %u"), Samplerate, Channels); }
static void gst_mpg123_audio_dec_flush (GstAudioDecoder * dec, gboolean hard) { int error; GstMpg123AudioDec *mpg123_decoder; hard = hard; GST_DEBUG_OBJECT (dec, "Flushing decoder"); mpg123_decoder = GST_MPG123_AUDIO_DEC (dec); if (G_UNLIKELY (mpg123_decoder->handle == NULL)) { GstElement *element = GST_ELEMENT (dec); GST_ELEMENT_ERROR (element, STREAM, DECODE, (NULL), ("mpg123 handle is NULL")); return; } /* Flush by reopening the feed */ mpg123_close (mpg123_decoder->handle); error = mpg123_open_feed (mpg123_decoder->handle); if (G_UNLIKELY (error != MPG123_OK)) { GstElement *element = GST_ELEMENT (dec); GST_ELEMENT_ERROR (element, STREAM, DECODE, (NULL), ("Error reopening mpg123 feed: %s", mpg123_plain_strerror (error))); mpg123_close (mpg123_decoder->handle); mpg123_delete (mpg123_decoder->handle); mpg123_decoder->handle = NULL; } mpg123_decoder->has_next_audioinfo = FALSE; /* opening/closing feeds do not affect the format defined by the mpg123_format() call that was made in gst_mpg123_audio_dec_set_format(), and since the up/downstream caps are not expected to change here, no mpg123_format() calls are done */ }
QString InternetFormatSupport( const char* address ) { loadCURL(); if ( !CURLloaded ) return ""; mpg123_handle *mus = mpg123_new(NULL, NULL); mpg123_open_feed( mus ); URL_FILE *f = url_fopen( address ); if ( !f ) { unloadCURL(); return ""; } char *data; int _DATA_BUFF; if ( !getDataBuff( f, url_fread, _DATA_BUFF, &data ) ) { url_fclose(f); unloadCURL(); return ""; } int bread = url_fread(data+10, 1, _DATA_BUFF-10, f); mpg123_decode( mus, (const unsigned char*)data, bread, 0,0,0 ); bool loaded = getMusInfo( mus, 0,0,0,0,0, -1, "" ); mpg123_close(mus); mpg123_delete(mus); delete[] data; url_fclose(f); unloadCURL(); if ( loaded ) return plugName; else return ""; }
int _tmain(int argc, TCHAR **argv) { unsigned char buf[INBUFF]; unsigned char *audio; FILE *in; mpg123_handle *m; int ret, state; size_t inc, outc; off_t len, num; size_t bytes; off_t inoffset; size_t nrates; const long *rates; size_t i; inc = outc = 0; nrates = 0; rates = NULL; if(argc < 3) { fprintf(stderr,"Please supply in and out filenames\n"); return -1; } mpg123_init(); m = mpg123_new(NULL, &ret); if(m == NULL) { fprintf(stderr,"Unable to create mpg123 handle: %s\n", mpg123_plain_strerror(ret)); return -1; } mpg123_param(m, MPG123_VERBOSE, 4, 0); ret = mpg123_param(m, MPG123_FLAGS, MPG123_FUZZY | MPG123_SEEKBUFFER | MPG123_GAPLESS, 0); if(ret != MPG123_OK) { fprintf(stderr,"Unable to set library options: %s\n", mpg123_plain_strerror(ret)); return -1; } // Let the seek index auto-grow and contain an entry for every frame ret = mpg123_param(m, MPG123_INDEX_SIZE, -1, 0); if(ret != MPG123_OK) { fprintf(stderr,"Unable to set index size: %s\n", mpg123_plain_strerror(ret)); return -1; } // Use float output formats only ret = mpg123_format_none(m); if(ret != MPG123_OK) { fprintf(stderr,"Unable to disable all output formats: %s\n", mpg123_plain_strerror(ret)); return -1; } mpg123_rates(&rates, &nrates); for(i=0; i<nrates; i++) { ret = mpg123_format(m, rates[i], MPG123_MONO | MPG123_STEREO, MPG123_ENC_FLOAT_32); if(ret != MPG123_OK) { fprintf(stderr,"Unable to set float output formats: %s\n", mpg123_plain_strerror(ret)); return -1; } } ret = mpg123_open_feed(m); if(ret != MPG123_OK) { fprintf(stderr,"Unable open feed: %s\n", mpg123_plain_strerror(ret)); return -1; } in = _tfopen(argv[1], __T("rb")); if(in == NULL) { _ftprintf(stderr,__T("Unable to open input file %s\n"), argv[1]); return -1; } out = _tfopen(argv[2], __T("wb")); if(out == NULL) { _ftprintf(stderr,__T("Unable to open output file %s\n"), argv[2]); return -1; } while(ret = mpg123_feedseek(m, 95000, SEEK_SET, &inoffset) == MPG123_NEED_MORE) { len = fread(buf, sizeof(unsigned char), INBUFF, in); if(len <= 0) break; inc += len; state = mpg123_feed(m, buf, len); if(state == MPG123_ERR) { fprintf(stderr, "Error: %s", mpg123_strerror(m)); return -1; } } fseek(in, inoffset, SEEK_SET); while(1) { len = fread(buf, sizeof(unsigned char), INBUFF, in); if(len <= 0) break; inc += len; ret = mpg123_feed(m, buf, len); while(ret != MPG123_ERR && ret != MPG123_NEED_MORE) { ret = mpg123_decode_frame(m, &num, &audio, &bytes); if(ret == MPG123_NEW_FORMAT) { mpg123_getformat(m, &rate, &channels, &enc); initwavformat(); initwav(); fprintf(stderr, "New format: %li Hz, %i channels, encoding value %i\n", rate, channels, enc); } fwrite(audio, sizeof(unsigned char), bytes, out); outc += bytes; } if(ret == MPG123_ERR) { fprintf(stderr, "Error: %s", mpg123_strerror(m)); break; } } fprintf(stderr, "Finished read %lu, decoded %lu\n", (unsigned long)inc, (unsigned long)outc); closewav(); fclose(out); fclose(in); mpg123_delete(m); mpg123_exit(); return 0; }
VGMSTREAM * init_vgmstream_genh(STREAMFILE *streamFile) { VGMSTREAM * vgmstream = NULL; int32_t channel_count; int32_t interleave; int32_t sample_rate; int32_t loop_start; int32_t loop_end; int32_t start_offset; int32_t header_size; int32_t coef[2]; int32_t dsp_interleave_type; char filename[260]; int coding; #ifdef VGM_USE_MPEG mpeg_codec_data *data = NULL; #endif /* check extension, case insensitive */ streamFile->get_name(streamFile,filename,sizeof(filename)); if (strcasecmp("genh",filename_extension(filename))) goto fail; /* check header magic */ if (read_32bitBE(0x0,streamFile) != 0x47454e48) goto fail; /* check channel count (needed for ADP/DTK check) */ channel_count = read_32bitLE(0x4,streamFile); if (channel_count < 1) goto fail; /* check format */ /* 0 = PSX ADPCM */ /* 1 = XBOX IMA ADPCM */ /* 2 = NGC ADP/DTK ADPCM */ /* 3 = 16bit big endian PCM */ /* 4 = 16bit little endian PCM */ /* 5 = 8bit PCM */ /* 6 = SDX2 */ /* 7 = DVI IMA */ /* 8 = MPEG-1 Layer III, possibly also the MPEG-2 and 2.5 extensions */ /* 9 = IMA */ /* 10 = AICA ADPCM */ /* 11 = MS ADPCM */ /* 12 = NGC DSP */ /* 13 = 8bit unsingned PCM */ /* 14 = PSX ADPCM (bad flagged) */ /* ... others to come */ switch (read_32bitLE(0x18,streamFile)) { case 0: coding = coding_PSX; break; case 1: coding = coding_XBOX; break; case 2: coding = coding_NGC_DTK; if (channel_count != 2) goto fail; break; case 3: coding = coding_PCM16BE; break; case 4: coding = coding_PCM16LE; break; case 5: coding = coding_PCM8; break; case 6: coding = coding_SDX2; break; case 7: coding = coding_DVI_IMA; break; #ifdef VGM_USE_MPEG case 8: /* we say MPEG-1 L3 here, but later find out exactly which */ coding = coding_MPEG1_L3; break; #endif case 9: coding = coding_IMA; break; case 10: coding = coding_AICA; break; case 11: coding = coding_MSADPCM; break; case 12: coding = coding_NGC_DSP; break; case 13: coding = coding_PCM8_U_int; break; case 14: coding = coding_PSX_badflags; break; default: goto fail; } start_offset = read_32bitLE(0x1C,streamFile); header_size = read_32bitLE(0x20,streamFile); /* HACK to support old genh */ if (header_size == 0) { start_offset = 0x800; header_size = 0x800; } /* check for audio data start past header end */ if (header_size > start_offset) goto fail; interleave = read_32bitLE(0x8,streamFile); sample_rate = read_32bitLE(0xc,streamFile); loop_start = read_32bitLE(0x10,streamFile); loop_end = read_32bitLE(0x14,streamFile); coef[0] = read_32bitLE(0x24,streamFile); coef[1] = read_32bitLE(0x28,streamFile); dsp_interleave_type = read_32bitLE(0x2C,streamFile); //if (coding == coding_XBOX && channel_count != 2) goto fail; /* build the VGMSTREAM */ vgmstream = allocate_vgmstream(channel_count,(loop_start!=-1)); if (!vgmstream) goto fail; /* fill in the vital information */ vgmstream->channels = channel_count; vgmstream->sample_rate = sample_rate; vgmstream->num_samples = loop_end; vgmstream->loop_start_sample = loop_start; vgmstream->loop_end_sample = loop_end; vgmstream->loop_flag = (loop_start != -1); switch (coding) { case coding_PCM8_U_int: vgmstream->layout_type=layout_none; break; case coding_PCM16LE: case coding_PCM16BE: case coding_PCM8: case coding_SDX2: case coding_PSX: case coding_PSX_badflags: case coding_DVI_IMA: case coding_IMA: case coding_AICA: vgmstream->interleave_block_size = interleave; if (channel_count > 1) { if (coding == coding_SDX2) { coding = coding_SDX2_int; vgmstream->coding_type = coding_SDX2_int; } if(vgmstream->interleave_block_size==0xffffffff) vgmstream->layout_type=layout_none; else { vgmstream->layout_type = layout_interleave; if(coding==coding_DVI_IMA) coding=coding_INT_DVI_IMA; if(coding==coding_IMA) coding=coding_INT_IMA; } } else { vgmstream->layout_type = layout_none; } break; case coding_MSADPCM: if (channel_count != 2) goto fail; vgmstream->interleave_block_size = interleave; vgmstream->layout_type = layout_none; break; case coding_XBOX: vgmstream->layout_type = layout_none; break; case coding_NGC_DTK: vgmstream->layout_type = layout_dtk_interleave; break; case coding_NGC_DSP: if (dsp_interleave_type == 0) { vgmstream->layout_type = layout_interleave; vgmstream->interleave_block_size = interleave; } else if (dsp_interleave_type == 1) { vgmstream->layout_type = layout_interleave_byte; vgmstream->interleave_block_size = interleave; } else if (dsp_interleave_type == 2) { vgmstream->layout_type = layout_none; } break; #ifdef VGM_USE_MPEG case coding_MPEG1_L3: vgmstream->layout_type = layout_mpeg; break; #endif } vgmstream->coding_type = coding; vgmstream->meta_type = meta_GENH; /* open the file for reading by each channel */ { int i; int j; STREAMFILE * chstreamfile = NULL; for (i=0;i<channel_count;i++) { off_t chstart_offset = start_offset; switch (coding) { case coding_PSX: case coding_PSX_badflags: case coding_PCM16BE: case coding_PCM16LE: case coding_SDX2: case coding_SDX2_int: case coding_DVI_IMA: case coding_IMA: case coding_PCM8: case coding_PCM8_U_int: case coding_AICA: case coding_INT_DVI_IMA: case coding_INT_IMA: if (vgmstream->layout_type == layout_interleave) { if (interleave >= 512) { chstreamfile = streamFile->open(streamFile,filename,interleave); } else { if (!chstreamfile) chstreamfile = streamFile->open(streamFile,filename,STREAMFILE_DEFAULT_BUFFER_SIZE); } chstart_offset = start_offset+vgmstream->interleave_block_size*i; } else { chstreamfile = streamFile->open(streamFile,filename, STREAMFILE_DEFAULT_BUFFER_SIZE); } break; case coding_XBOX: case coding_MSADPCM: /* xbox's "interleave" is a lie, all channels start at same * offset */ chstreamfile = streamFile->open(streamFile,filename, STREAMFILE_DEFAULT_BUFFER_SIZE); break; case coding_NGC_DTK: if (!chstreamfile) chstreamfile = streamFile->open(streamFile,filename,32*0x400); break; case coding_NGC_DSP: if (!chstreamfile) chstreamfile = streamFile->open(streamFile,filename,STREAMFILE_DEFAULT_BUFFER_SIZE); for (j=0;j<16;j++) vgmstream->ch[i].adpcm_coef[j] = read_16bitBE(coef[i]+j*2,streamFile); chstart_offset =start_offset+vgmstream->interleave_block_size*i; break; #ifdef VGM_USE_MPEG case coding_MPEG1_L3: if (!chstreamfile) chstreamfile = streamFile->open(streamFile,filename,MPEG_BUFFER_SIZE); break; #endif } if (!chstreamfile) goto fail; vgmstream->ch[i].streamfile = chstreamfile; vgmstream->ch[i].channel_start_offset= vgmstream->ch[i].offset=chstart_offset; } } #ifdef VGM_USE_MPEG if (coding == coding_MPEG1_L3) { int rc; off_t read_offset; data = calloc(1,sizeof(mpeg_codec_data)); if (!data) goto mpeg_fail; data->m = mpg123_new(NULL,&rc); if (rc==MPG123_NOT_INITIALIZED) { if (mpg123_init()!=MPG123_OK) goto mpeg_fail; data->m = mpg123_new(NULL,&rc); if (rc!=MPG123_OK) goto mpeg_fail; } else if (rc!=MPG123_OK) { goto mpeg_fail; } mpg123_param(data->m,MPG123_REMOVE_FLAGS,MPG123_GAPLESS,0.0); if (mpg123_open_feed(data->m)!=MPG123_OK) { goto mpeg_fail; } /* check format */ read_offset=0; do { size_t bytes_done; if (read_streamfile(data->buffer, start_offset+read_offset, MPEG_BUFFER_SIZE,vgmstream->ch[0].streamfile) != MPEG_BUFFER_SIZE) goto mpeg_fail; read_offset+=1; rc = mpg123_decode(data->m,data->buffer,MPEG_BUFFER_SIZE, NULL,0,&bytes_done); if (rc != MPG123_OK && rc != MPG123_NEW_FORMAT && rc != MPG123_NEED_MORE) goto mpeg_fail; } while (rc != MPG123_NEW_FORMAT); { long rate; int channels,encoding; struct mpg123_frameinfo mi; rc = mpg123_getformat(data->m,&rate,&channels,&encoding); if (rc != MPG123_OK) goto mpeg_fail; if (rate != vgmstream->sample_rate || channels != vgmstream->channels || encoding != MPG123_ENC_SIGNED_16) goto mpeg_fail; mpg123_info(data->m,&mi); if (mi.rate != vgmstream->sample_rate) goto mpeg_fail; if (mi.version == MPG123_1_0 && mi.layer == 1) vgmstream->coding_type = coding_MPEG1_L1; else if (mi.version == MPG123_1_0 && mi.layer == 2) vgmstream->coding_type = coding_MPEG1_L2; else if (mi.version == MPG123_1_0 && mi.layer == 3) vgmstream->coding_type = coding_MPEG1_L3; else if (mi.version == MPG123_2_0 && mi.layer == 1) vgmstream->coding_type = coding_MPEG2_L1; else if (mi.version == MPG123_2_0 && mi.layer == 2) vgmstream->coding_type = coding_MPEG2_L2; else if (mi.version == MPG123_2_0 && mi.layer == 3) vgmstream->coding_type = coding_MPEG2_L3; else if (mi.version == MPG123_2_5 && mi.layer == 1) vgmstream->coding_type = coding_MPEG25_L1; else if (mi.version == MPG123_2_5 && mi.layer == 2) vgmstream->coding_type = coding_MPEG25_L2; else if (mi.version == MPG123_2_5 && mi.layer == 3) vgmstream->coding_type = coding_MPEG25_L3; else goto mpeg_fail; } /* reinit, to ignore the reading we've done so far */ mpg123_open_feed(data->m); vgmstream->codec_data = data; } #endif return vgmstream; /* clean up anything we may have opened */ #ifdef VGM_USE_MPEG mpeg_fail: if (data) { mpg123_delete(data->m); free(data); } #endif fail: if (vgmstream) close_vgmstream(vgmstream); return NULL; }
int mpa_decode_update(struct audec_state **adsp, const struct aucodec *ac, const char *fmtp) { struct audec_state *ads; int result, err=0; (void)fmtp; if (!adsp || !ac || !ac->ch) return EINVAL; ads = *adsp; #ifdef DEBUG debug("MPA dec created %s\n",fmtp); #endif if (!ads) { ads = mem_zalloc(sizeof(*ads), destructor); if (!ads) return ENOMEM; } else { memset(ads,0,sizeof(*ads)); } ads->channels = 0; ads->resampler = NULL; ads->start = 0; ads->dec = mpg123_new(NULL,&result); if (!ads->dec) { warning("MPA dec create: %s\n", mpg123_plain_strerror(result)); err = ENOMEM; goto out; } #ifdef DEBUG result = mpg123_param(ads->dec, MPG123_VERBOSE, 4, 4.); #else result = mpg123_param(ads->dec, MPG123_VERBOSE, 0, 0.); #endif if (result != MPG123_OK) { warning("MPA dec param error %s\n", mpg123_plain_strerror(result)); err = EINVAL; goto out; } result = mpg123_format_all(ads->dec); if (result != MPG123_OK) { warning("MPA dec format error %s\n", mpg123_plain_strerror(result)); err = EINVAL; goto out; } result = mpg123_open_feed(ads->dec); if (result != MPG123_OK) { warning("MPA dec open feed error %s\n", mpg123_plain_strerror(result)); err = EINVAL; goto out; } out: if (err) mem_deref(ads); else *adsp = ads; return err; }
/* This initializes libmpg123 and prepares the handle, including funky * parameters. */ static int init(struct dec_audio *da, const char *decoder) { int err; struct ad_mpg123_context *con; /* Assumption: You always call preinit + init + uninit, on every file. * But you stop at preinit in case it fails. * If that is not true, one must ensure not to call mpg123_init / exit * twice in a row. */ if (mpg123_init() != MPG123_OK) return 0; da->priv = talloc_zero(NULL, struct ad_mpg123_context); con = da->priv; /* Auto-choice of optimized decoder (first argument NULL). */ con->handle = mpg123_new(NULL, &err); if (!con->handle) goto bad_end; /* Basic settings. * Don't spill messages, enable better resync with non-seekable streams. * Give both flags individually without error checking to keep going with * old libmpg123. Generally, it is not fatal if the flags are not * honored */ mpg123_param(con->handle, MPG123_ADD_FLAGS, MPG123_QUIET, 0.0); /* Do not bail out on malformed streams at all. * MPlayer does not handle a decoder throwing the towel on crappy input. */ mpg123_param(con->handle, MPG123_RESYNC_LIMIT, -1, 0.0); /* Open decisions: Configure libmpg123 to force encoding (or stay open about * library builds that support only float or int32 output), (de)configure * gapless decoding (won't work with seeking in MPlayer, though). * Don't forget to eventually enable ReplayGain/RVA support, too. * Let's try to run with the default for now. */ /* That would produce floating point output. * You can get 32 and 24 bit ints, even 8 bit via format matrix. * If wanting a specific encoding here, configure format matrix and * make sure it is in set_format(). */ /* mpg123_param(con->handle, MPG123_ADD_FLAGS, MPG123_FORCE_FLOAT, 0.); */ /* Example for RVA choice (available since libmpg123 1.0.0): mpg123_param(con->handle, MPG123_RVA, MPG123_RVA_MIX, 0.0) */ /* Prevent funky automatic resampling. * This way, we can be sure that one frame will never produce * more than 1152 stereo samples. * Background: * Going to decode directly to the output buffer. It is important to have * MPG123_AUTO_RESAMPLE disabled for the buffer size being an all-time * limit. * We need at least 1152 samples. dec_audio.c normally guarantees this. */ mpg123_param(con->handle, MPG123_REMOVE_FLAGS, MPG123_AUTO_RESAMPLE, 0.); err = mpg123_open_feed(con->handle); if (err != MPG123_OK) goto bad_end; return 1; bad_end: if (!con->handle) { MP_ERR(da, "mpg123 preinit error: %s\n", mpg123_plain_strerror(err)); } else { MP_ERR(da, "mpg123 preinit error: %s\n", mpg123_strerror(con->handle)); } uninit(da); return 0; }
static gboolean xmms_mpg123_init (xmms_xform_t *xform) { xmms_mpg123_data_t *data; const long *rates; size_t num_rates; int encoding; off_t length; int i, result; g_return_val_if_fail (xform, FALSE); data = g_new0 (xmms_mpg123_data_t, 1); xmms_xform_private_data_set (xform, data); /* Get the total size of this stream and store it for later */ if (xmms_xform_metadata_get_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE, &result)) { data->filesize = result; } mpg123_rates (&rates, &num_rates); data->param = mpg123_new_pars (&result); g_return_val_if_fail (data->param, FALSE); /* Create a quiet (stderr) decoder with auto choosen optimization. * Stuff set here should be tunable via plugin config properties! * You can also change some things during playback... */ mpg123_par (data->param, MPG123_ADD_FLAGS, MPG123_QUIET, 0); mpg123_par (data->param, MPG123_ADD_FLAGS, MPG123_GAPLESS, 0); /* choose: MPG123_RVA_OFF, MPG123_RVA_MIX, MPG123_RVA_ALBUM * xmms2 has its own ReplayGain plugin to handle the RVA field */ mpg123_par (data->param, MPG123_RVA, MPG123_RVA_OFF, 0); /* You could choose a decoder from the list provided by * mpg123_supported_decoders () and give that as second parameter. */ data->decoder = mpg123_parnew (data->param, NULL, &result); if (data->decoder == NULL) { xmms_log_error ("%s", mpg123_plain_strerror (result)); goto bad; } /* Prepare for buffer input feeding. */ result = mpg123_open_feed (data->decoder); if (result != MPG123_OK) { goto mpg123_bad; } /* Let's always decode to signed 16bit for a start. Any mpg123-supported sample rate is accepted. */ if (MPG123_OK != mpg123_format_none (data->decoder)) { goto mpg123_bad; } for (i = 0; i < num_rates; i++) { result = mpg123_format (data->decoder, rates[i], MPG123_MONO | MPG123_STEREO, MPG123_ENC_SIGNED_16); if (result != MPG123_OK) { goto mpg123_bad; } } /* Fetch ID3v1 data from the end of file if possible */ result = xmms_id3v1_get_tags (xform); if (result < 0) { xmms_log_error ("Seeking error when reading ID3v1 tags"); goto bad; } else if (data->filesize > result) { /* Reduce the size of tag data from the filesize */ data->filesize -= result; } /* Read data from input until decoded data is available from decoder */ do { /* Parse stream and get info. */ gint ret; xmms_error_t err; ret = xmms_xform_read (xform, data->buf, BUFSIZE, &err); if (ret < 0) { xmms_log_error ("Error when trying to find beginning of stream"); goto bad; } else if (ret == 0) { /* EOF reached before format was found, handled after loop */ break; } /* With zero output size nothing is actually outputted */ result = mpg123_decode (data->decoder, data->buf, (size_t) ret, NULL, 0, NULL); } while (result == MPG123_NEED_MORE); /* Keep feeding... */ if (result != MPG123_NEW_FORMAT) { xmms_log_error ("Unable to find beginning of stream (%s)!", result == MPG123_ERR ? mpg123_strerror (data->decoder) : "unexpected EOF"); goto bad; } result = mpg123_getformat (data->decoder, &data->samplerate, &data->channels, &encoding); if (result != MPG123_OK) { goto mpg123_bad; } /* Set the filesize so it can be used for duration estimation */ if (data->filesize > 0) { mpg123_set_filesize (data->decoder, data->filesize); } /* Get duration in samples, convert to ms and save to xmms2 */ length = mpg123_length (data->decoder); if (length > 0 && !xmms_xform_metadata_get_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION, &i)) { length = (off_t) ((gfloat) length / data->samplerate * 1000); xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION, (gint) length); } XMMS_DBG ("mpg123: got stream with %li Hz %i channels, encoding %i", data->samplerate, data->channels, encoding); xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "audio/pcm", XMMS_STREAM_TYPE_FMT_FORMAT, XMMS_SAMPLE_FORMAT_S16, XMMS_STREAM_TYPE_FMT_CHANNELS, data->channels, XMMS_STREAM_TYPE_FMT_SAMPLERATE, (gint) data->samplerate, XMMS_STREAM_TYPE_END); return TRUE; mpg123_bad: xmms_log_error ("mpg123 error: %s", mpg123_strerror (data->decoder)); bad: mpg123_delete (data->decoder); mpg123_delete_pars (data->param); g_free (data); return FALSE; }
static switch_status_t shout_file_open(switch_file_handle_t *handle, const char *path) { shout_context_t *context; char *host, *file; char *username, *password, *port; char *err = NULL; const char *mpg123err = NULL; int portno = 0; if ((context = switch_core_alloc(handle->memory_pool, sizeof(*context))) == 0) { return SWITCH_STATUS_MEMERR; } if (!handle->samplerate) { handle->samplerate = 8000; } context->memory_pool = handle->memory_pool; context->samplerate = handle->samplerate; context->handle = handle; switch_thread_rwlock_create(&(context->rwlock), context->memory_pool); switch_thread_rwlock_rdlock(context->rwlock); switch_mutex_init(&context->audio_mutex, SWITCH_MUTEX_NESTED, context->memory_pool); if (switch_test_flag(handle, SWITCH_FILE_FLAG_READ)) { if (switch_buffer_create_dynamic(&context->audio_buffer, TC_BUFFER_SIZE, TC_BUFFER_SIZE * 2, 0) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n"); goto error; } context->mh = our_mpg123_new(NULL, NULL); if (mpg123_format_all(context->mh) != MPG123_OK) { MPGERROR(); } if (mpg123_param(context->mh, MPG123_FORCE_RATE, context->samplerate, 0) != MPG123_OK) { MPGERROR(); } if (handle->handler) { if (mpg123_param(context->mh, MPG123_FLAGS, MPG123_SEEKBUFFER | MPG123_MONO_MIX, 0) != MPG123_OK) { MPGERROR(); } if (mpg123_open_feed(context->mh) != MPG123_OK) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening mpg feed\n"); mpg123err = mpg123_strerror(context->mh); goto error; } context->stream_url = switch_core_sprintf(context->memory_pool, "http://%s", path); context->prebuf = handle->prebuf; launch_read_stream_thread(context); } else { handle->seekable = 1; if (mpg123_param(context->mh, MPG123_FLAGS, MPG123_MONO_MIX, 0) != MPG123_OK) { MPGERROR(); } if (mpg123_open(context->mh, path) != MPG123_OK) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening %s\n", path); mpg123err = mpg123_strerror(context->mh); goto error; } } } else if (switch_test_flag(handle, SWITCH_FILE_FLAG_WRITE)) { if (switch_test_flag(handle, SWITCH_FILE_WRITE_APPEND)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Appending to MP3 not supported.\n"); } if (!(context->gfp = lame_init())) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate lame\n"); goto error; } if (!handle->handler) { id3tag_init(context->gfp); id3tag_v2_only(context->gfp); id3tag_pad_v2(context->gfp); } context->channels = handle->channels; lame_set_brate(context->gfp, 16 * (handle->samplerate / 8000) * handle->channels); lame_set_num_channels(context->gfp, handle->channels); lame_set_in_samplerate(context->gfp, handle->samplerate); lame_set_out_samplerate(context->gfp, handle->samplerate); if (handle->channels == 2) { lame_set_mode(context->gfp, STEREO); } else { lame_set_mode(context->gfp, MONO); } lame_set_quality(context->gfp, 2); /* 2=high 5 = medium 7=low */ lame_set_errorf(context->gfp, log_error); lame_set_debugf(context->gfp, log_debug); lame_set_msgf(context->gfp, log_msg); if (handle->handler) { if (switch_buffer_create_dynamic(&context->audio_buffer, MY_BLOCK_SIZE, MY_BUF_LEN, 0) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n"); goto error; } lame_set_bWriteVbrTag(context->gfp, 0); lame_mp3_tags_fid(context->gfp, NULL); username = switch_core_strdup(handle->memory_pool, path); if (!(password = strchr(username, ':'))) { err = "invalid url"; goto error; } *password++ = '\0'; if (!(host = strchr(password, '@'))) { err = "invalid url"; goto error; } *host++ = '\0'; if ((file = strchr(host, '/'))) { *file++ = '\0'; } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid URL: %s\n", path); goto error; } if ((port = strchr(host, ':'))) { *port++ = '\0'; if (port) { portno = atoi(port); } } if (!portno) { portno = 8000; } if (!(context->shout = shout_new())) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate shout_t\n"); goto error; } if (shout_set_host(context->shout, host) != SHOUTERR_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting hostname: %s\n", shout_get_error(context->shout)); goto error; } if (shout_set_protocol(context->shout, SHOUT_PROTOCOL_HTTP) != SHOUTERR_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting protocol: %s\n", shout_get_error(context->shout)); goto error; } if (shout_set_port(context->shout, portno) != SHOUTERR_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting port: %s\n", shout_get_error(context->shout)); goto error; } if (shout_set_password(context->shout, password) != SHOUTERR_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting password: %s\n", shout_get_error(context->shout)); goto error; } if (shout_set_mount(context->shout, file) != SHOUTERR_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting mount: %s\n", shout_get_error(context->shout)); goto error; } if (shout_set_user(context->shout, username) != SHOUTERR_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting user: %s\n", shout_get_error(context->shout)); goto error; } if (shout_set_url(context->shout, "http://www.freeswitch.org") != SHOUTERR_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting name: %s\n", shout_get_error(context->shout)); goto error; } if (shout_set_description(context->shout, "FreeSWITCH mod_shout Broadcasting Module") != SHOUTERR_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting description: %s\n", shout_get_error(context->shout)); goto error; } if (shout_set_audio_info(context->shout, "bitrate", "24000") != SHOUTERR_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting bitrate: %s\n", shout_get_error(context->shout)); goto error; } if (shout_set_format(context->shout, SHOUT_FORMAT_MP3) != SHOUTERR_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting format: %s\n", shout_get_error(context->shout)); goto error; } } else { /* lame being lame and all has FILE * coded into it's API for some functions so we gotta use it */ if (!(context->fp = fopen(path, "wb+"))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening %s\n", path); goto error; } } } handle->samples = 0; handle->format = 0; handle->sections = 0; handle->speed = 0; handle->private_info = context; switch_thread_rwlock_unlock(context->rwlock); return SWITCH_STATUS_SUCCESS; error: switch_thread_rwlock_unlock(context->rwlock); if (err) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: %s\n", err); } if (mpg123err) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error from mpg123: %s\n", mpg123err); } free_context(context); return SWITCH_STATUS_GENERR; }
int _tmain(int argc, _TCHAR* argv[]) { mpg123_handle *m; int i; if (argc < 3) { fprintf(stderr, "\nI will give you the estimated and exact sample lengths of MPEG audio files.\n"); fprintf(stderr, "\nUsage: %s <mpeg audio file list>\n\n", argv[0]); return -1; } mpg123_init(); m = mpg123_new(NULL, NULL); mpg123_param(m, MPG123_RESYNC_LIMIT, -1, 0); /* New in library version 0.0.1 . */ off_t a, b; if (MPG123_OK != mpg123_open_feed(m)) { fprintf(stderr, "open feed failed"); return -1; } FILE* file = _tfopen(argv[1], TEXT("rb")); if (!file) { fprintf(stderr, "open file failed"); return -1; } _stat64i32 st = { 0 }; _tstat(argv[1], &st); if (st.st_size <= 0) { fprintf(stderr, "file size is zero"); return -1; } char* pDataBuf = new char[st.st_size]; memset(pDataBuf, 0, st.st_size); if (st.st_size != fread(pDataBuf, 1, st.st_size, file)) { fprintf(stderr, "read file error"); return -1; } if (MPG123_OK != mpg123_feed(m, (const unsigned char*)pDataBuf, st.st_size)) { fprintf(stderr, "feed failed"); return -1; } // channels; bool bSaved = false; size_t nDone = 0; int res = mpg123_decode(m, NULL, 0, NULL, 0, &nDone); if (res == MPG123_NEW_FORMAT) { long rate = 0; int channels = 0; int enc = 0; mpg123_getformat(m, &rate, &channels, &enc); if (MPG123_ENC_SIGNED_16 == enc) { int nSamples = mpg123_length(m); int nBufCount = nSamples * channels; int nBufSize = nBufCount * sizeof(short); short* pBuf = new short[nBufCount]; res = mpg123_decode(m, NULL, 0, (unsigned char*)pBuf, nBufSize, &nDone); if (res == MPG123_OK) { KWavFile file; file.Init(pBuf, nDone, rate, ""); file.Save(CT2A(argv[2])); bSaved = true; } if (pBuf) { delete[] pBuf; pBuf = NULL; } } } mpg123_tclose(m); mpg123_delete(m); mpg123_exit(); return 0; }
bool FileFormatSupport( const char *fileE ) { FILE *f = qmp_fopen( fileE, "rb" ); if ( !f ) return 0; int _DATA_BUFF; if ( !getDataBuff( f, (size_t(*)(void *, size_t, size_t, void *))fread, _DATA_BUFF, NULL ) ) { fclose(f); return false; } int TagSize = _DATA_BUFF - DATA_BUFF; bool loaded(0); mpg123_handle *mus = mpg123_new(NULL, NULL); mpg123_open_feed( mus ); fseek(f,TagSize,0); char *data = new char[DATA_BUFF]; int bread = fread( data, 1, DATA_BUFF, f ); fclose(f); mpg123_decode( mus, (const unsigned char*)data, bread, 0,0,0 ); delete[] data; loaded = getMusInfo( mus, 0,0,0,0,0, -1, "" ); mpg123_close(mus); mpg123_delete(mus); return loaded; }