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 */ }
Mpg123Input::Mpg123Input(const QString &fileName) { handle=new Handle; QByteArray fName=QFile::encodeName(fileName); bool ok=false; int result; handle->mpg123 = mpg123_new(NULL, &result); if (handle->mpg123 && MPG123_OK==mpg123_open(handle->mpg123, fName.constData()) && MPG123_OK==mpg123_getformat(handle->mpg123, &handle->rate, &handle->channels, &handle->encoding) && MPG123_OK==mpg123_format_none(handle->mpg123) && MPG123_OK==mpg123_format(handle->mpg123, handle->rate, handle->channels, MPG123_ENC_FLOAT_32)) { mpg123_close(handle->mpg123); if (MPG123_OK==mpg123_open(handle->mpg123, fName.constData()) && MPG123_OK==mpg123_getformat(handle->mpg123, &handle->rate, &handle->channels, &handle->encoding)) { ok=true; } } if (!ok) { if (handle->mpg123) { mpg123_close(handle->mpg123); mpg123_delete(handle->mpg123); handle->mpg123 = NULL; } delete handle; handle = 0; } }
static void libmpg123_shutdown() { if(mh != NULL) { mpg123_close(mh); } mpg123_exit(); #ifdef BS_SIZE if (bs_buffer) { free(bs_buffer); bs_buffer = NULL; } #endif if (pcm_buffer) { free(pcm_buffer); pcm_buffer = NULL; } #ifdef BS_SIZE if (mp3_fd) { fs_close(mp3_fd); mp3_fd = 0; } #endif }
//------------------------------------------------------------ void ofOpenALSoundPlayer::unload(){ stop(); ofRemoveListener(ofEvents().update,this,&ofOpenALSoundPlayer::update); // Only lock the thread where necessary. { std::unique_lock<std::mutex> lock(mutex); // Delete sources before buffers. alDeleteSources(sources.size(),&sources[0]); alDeleteBuffers(buffers.size(),&buffers[0]); sources.clear(); buffers.clear(); } // Free resources and close file descriptors. #ifdef OF_USING_MPG123 if(mp3streamf){ mpg123_close(mp3streamf); mpg123_delete(mp3streamf); } mp3streamf = 0; #endif if(streamf){ sf_close(streamf); } streamf = 0; bLoadedOk = false; }
int attribute_align_arg mpg123_open_feed(mpg123_handle *mh) { if(mh == NULL) return MPG123_ERR; mpg123_close(mh); return open_feed(mh); }
int attribute_align_arg mpg123_open_fd(mpg123_handle *mh, int fd) { if(mh == NULL) return MPG123_ERR; mpg123_close(mh); return open_stream(mh, NULL, fd); }
/* plain file access, no http! */ int attribute_align_arg mpg123_open(mpg123_handle *mh, const char *path) { if(mh == NULL) return MPG123_ERR; mpg123_close(mh); return open_stream(mh, path, -1); }
void mpeg_close(int fd) { if((handle != NULL) && (fd != -1)) { if(handle->buf != NULL) { free(handle->buf); handle->buf = NULL; } if(handle->device != NULL) { ao_close(handle->device); handle->device = NULL; } if(handle->mh != NULL) { mpg123_close(handle->mh); mpg123_delete(handle->mh); handle->mh = NULL; } free(handle); handle = NULL; } }
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; }
//-------------------------------------------------------------- void ofxSoundFile::close(){ #ifdef OF_USING_SNDFILE if(sndFile){ sf_close(sndFile); sndFile = NULL; } samples_read = 0; #endif #ifdef OF_USING_LAD if ( audioDecoder ) delete audioDecoder; audioDecoder = NULL; #endif #ifdef OF_USING_MPG123 if(mp3File){ mpg123_close(mp3File); mpg123_delete(mp3File); mp3File = NULL; } #endif channels = 1; duration = 0; //in secs samplerate = 0; samples = 0; }
void MusicPlayer::play(const char *filename) { #ifdef USE_OGG stb_vorbis_close(v); stb_vorbis_alloc t; t.alloc_buffer=this->buf; t.alloc_buffer_length_in_bytes=STB_BUFSIZE; // stb_vorbis has char* pointer even though it is not really writing to buffer v = stb_vorbis_open_filename((char *)filename, &error, &t); #endif #ifdef USE_MP3 mpg123_close(mh); error = mpg123_open(mh, filename); if (!error) { error = mpg123_getformat(mh, &rate, &channels, &encoding); rate = AUDIO_FREQUENCY; channels = 2; mpg123_format_none(mh); mpg123_format(mh, rate, channels, encoding); } #endif }
/*********************************************************************** * MPEG3_StreamClose * */ static LRESULT MPEG3_StreamClose(PACMDRVSTREAMINSTANCE adsi) { mpg123_close(((AcmMpeg3Data*)adsi->dwDriver)->mh); mpg123_delete(((AcmMpeg3Data*)adsi->dwDriver)->mh); HeapFree(GetProcessHeap(), 0, (void*)adsi->dwDriver); return MMSYSERR_NOERROR; }
void CLOSE() { mpg123_close(musicfile); mpg123_delete(musicfile); if ( fd > -1 ) { close( fd ); fd = -1; } if ( Type == 2 ) { delete[] data; if ( f ) url_fclose(f); f = NULL; } if ( Type == 2 ) unloadCURL(); IsPlaying = false; pix = QImage(); id3Str.clear(); _DATA_BUFF = 0; }
int main(int argc, char **argv) { mpg123_handle *m; int i; if(argc < 2) { 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 . */ for(i = 1; i < argc; ++i) { off_t a, b; mpg123_open(m, argv[i]); a = mpg123_length(m); mpg123_scan(m); b = mpg123_length(m); mpg123_close(m); printf("File %i: estimated %li vs. scanned %li\n", i, (long)a, (long)b); } mpg123_delete(m); mpg123_exit(); return 0; }
/***************************************************************************** * 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; }
bool MPG123Decoder::seek(size_t ms_offset, bool ms, bool mayrestart) { int enc, channels; long srate; if (!mayrestart || ms_offset > 0) { if (mpg123_getformat(MPG123, &srate, &channels, &enc) == MPG123_OK) { size_t smp_offset = ms ? (size_t)((double)ms_offset / 1000. * srate) : ms_offset; if (mpg123_seek(MPG123, (off_t)smp_offset, SEEK_SET) >= 0) { Done = false; return true; } } return false; } else { // Restart the song instead of rewinding. A rewind seems to cause distortion when done repeatedly. // offset is intentionally ignored here. if (MPG123) { mpg123_close(MPG123); mpg123_delete(MPG123); MPG123 = 0; } Reader.Seek(0, FileReader::SeekSet); // Do not call open with our own reader variable, that would be catastrophic. auto reader = std::move(Reader); return open(reader); } }
int test_whence(const char* path, int scan_before) { int err = MPG123_OK; mpg123_handle* mh = NULL; off_t length, pos; mh = mpg123_new(NULL, &err ); if(mh == NULL) return -1; err = mpg123_open(mh, path ); if(err != MPG123_OK) return -1; if(scan_before) mpg123_scan(mh); pos = mpg123_seek( mh, 0, SEEK_END); if(pos < 0){ error1("seek failed: %s", mpg123_strerror(mh)); return -1; } pos = mpg123_tell(mh); length = mpg123_length(mh); /* Later: Read samples and compare different whence values with identical seek positions. */ mpg123_close(mh); mpg123_delete(mh); fprintf(stdout, "length %"OFF_P" vs. pos %"OFF_P"\n", length, pos); return (pos == length) ? 0 : -1; }
static void destroy(void* _mp3_info) { mp3_t* mp3_info = (mp3_t* ) _mp3_info; post_event(mp3_info->player_control, INTERNAL_CMD_DESTROY, -1); pthread_join(mp3_info->player_thread, NULL); aodev_close(mp3_info->ao_handle); aodev_destroy(mp3_info->ao_handle); mpg123_close(mp3_info->handle); mpg123_delete(mp3_info->handle); audio_event_fifo_destroy(mp3_info->player_control); mp3_stream_fifo_destroy(mp3_info->stream_fifo); mc_free(mp3_info->file_or_url); mc_free(mp3_info->buffer); psem_destroy(mp3_info->length_set); psem_destroy(mp3_info->stream_ready); mc_free(mp3_info); log_debug("DETROY OK"); }
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 ofOpenALSoundPlayer::mpg123ReadFile(string path,vector<short> & buffer,vector<float> & fftAuxBuffer){ int err = MPG123_OK; mpg123_handle * f = mpg123_new(NULL,&err); if(mpg123_open(f,path.c_str())!=MPG123_OK){ ofLogError("ofOpenALSoundPlayer") << "mpg123ReadFile(): couldn't read \"" << path << "\""; return false; } mpg123_enc_enum encoding; long int rate; mpg123_getformat(f,&rate,&channels,(int*)&encoding); if(encoding!=MPG123_ENC_SIGNED_16){ ofLogError("ofOpenALSoundPlayer") << "mpg123ReadFile(): " << getMpg123EncodingString(encoding) << " encoding for \"" << path << "\"" << " unsupported, expecting MPG123_ENC_SIGNED_16"; return false; } samplerate = rate; size_t done=0; size_t buffer_size = mpg123_outblock( f ); buffer.resize(buffer_size/2); while(mpg123_read(f,(unsigned char*)&buffer[buffer.size()-buffer_size/2],buffer_size,&done)!=MPG123_DONE){ buffer.resize(buffer.size()+buffer_size/2); }; buffer.resize(buffer.size()-(buffer_size/2-done/2)); mpg123_close(f); mpg123_delete(f); fftAuxBuffer.resize(buffer.size()); for(int i=0;i<(int)buffer.size();i++){ fftAuxBuffer[i] = float(buffer[i])/32565.f; } duration = float(buffer.size()/channels) / float(samplerate); return true; }
bool MPG123Decoder::seek(size_t ms_offset, bool ms, bool mayrestart) { int enc, channels; long srate; if (!mayrestart || ms_offset > 0) { if (mpg123_getformat(MPG123, &srate, &channels, &enc) == MPG123_OK) { size_t smp_offset = ms ? (size_t)((double)ms_offset / 1000. * srate) : ms_offset; if (mpg123_seek(MPG123, (off_t)smp_offset, SEEK_SET) >= 0) { Done = false; return true; } } return false; } else { // Restart the song instead of rewinding. A rewind seems to cause distortion when done repeatedly. // offset is intentionally ignored here. if (MPG123) { mpg123_close(MPG123); mpg123_delete(MPG123); MPG123 = 0; } Reader->Seek(0, SEEK_SET); return open(Reader); } }
int stream_open(stream *stream, const char *url) { fprintf(stderr, "stream_open: %s\n", url); stream->url = sdsnew(url); response *response = resolve_stream(url); if (response == NULL) { return -1; } if (stream->fd > 3 && fd_is_valid(stream->fd)) { close(stream->fd); mpg123_close(stream->mpg123); } stream->fd = response->fd; free_response(response); if (mpg123_open_fd(stream->mpg123, stream->fd) != MPG123_OK) { return -1; } return 0; }
//------------------------------------------------------------ bool ofOpenALSoundPlayer_TimelineAdditions::mpg123ReadFile(string path,vector<short> & buffer,vector<float> & fftAuxBuffer){ int err = MPG123_OK; mpg123_handle * f = mpg123_new(NULL,&err); if(mpg123_open(f,path.c_str())!=MPG123_OK){ ofLog(OF_LOG_ERROR,"ofOpenALSoundPlayer_TimelineAdditions: couldnt read " + path); return false; } int encoding; long int rate; mpg123_getformat(f,&rate,&channels,&encoding); if(encoding!=MPG123_ENC_SIGNED_16){ ofLog(OF_LOG_ERROR,"ofOpenALSoundPlayer_TimelineAdditions: unsupported encoding"); return false; } samplerate = rate; size_t done=0; size_t buffer_size = mpg123_outblock( f ); buffer.resize(buffer_size/2); while(mpg123_read(f,(unsigned char*)&buffer[buffer.size()-buffer_size/2],buffer_size,&done)!=MPG123_DONE){ buffer.resize(buffer.size()+buffer_size/2); }; buffer.resize(buffer.size()-(buffer_size/2-done/2)); mpg123_close(f); mpg123_delete(f); fftAuxBuffer.resize(buffer.size()); for(int i=0;i<(int)buffer.size();i++){ fftAuxBuffer[i] = float(buffer[i])/32565.f; } duration = float(buffer.size()/channels) / float(samplerate); return true; }
void cleanup(mpg123_handle *mh) { /* It's really to late for error checks here;-) */ mpg123_close(mh); mpg123_delete(mh); mpg123_exit(); }
int attribute_align_arg mpg123_open_handle(mpg123_handle *mh, void *handle) { struct wrap_data* ioh; if(mh == NULL) return MPG123_ERR; mpg123_close(mh); ioh = mh->wrapperdata; if(ioh != NULL && ioh->iotype == IO_HANDLE && ioh->r_h_read != NULL) { /* Wrap the custom handle into my handle. */ int err; err = MPG123_LARGENAME(mpg123_replace_reader_handle)(mh, wrap_read, wrap_lseek, wrap_io_cleanup); if(err != MPG123_OK) return MPG123_ERR; ioh->handle = handle; /* No extra error handling, keep behaviour of the original open_handle. */ return open_stream_handle(mh, ioh); } else { /* This is an error ... you need to prepare the I/O before using it. */ mh->err = MPG123_BAD_CUSTOM_IO; return MPG123_ERR; } }
int attribute_align_arg mpg123_open_fd(mpg123_handle *mh, int fd) { struct wrap_data* ioh; if(mh == NULL) return MPG123_ERR; mpg123_close(mh); ioh = mh->wrapperdata; if(ioh != NULL && ioh->iotype == IO_FD) { int err; err = MPG123_LARGENAME(mpg123_replace_reader_handle)(mh, wrap_read, wrap_lseek, wrap_io_cleanup); if(err != MPG123_OK) return MPG123_ERR; /* The above call implied mpg123_close() already */ /* Store the real file descriptor inside the handle. */ ioh->fd = fd; /* Initiate I/O operating on my handle now. */ err = open_stream_handle(mh, ioh); if(err != MPG123_OK) { wrap_io_cleanup(ioh); return MPG123_ERR; } /* All fine... */ return MPG123_OK; } else return MPG123_LARGENAME(mpg123_open_fd)(mh, fd); }
/* Reader replacement prepares the hidden handle storage for next mpg123_open_fd() or plain mpg123_open(). */ int attribute_align_arg mpg123_replace_reader(mpg123_handle *mh, ssize_t (*r_read) (int, void *, size_t), long (*r_lseek)(int, long, int) ) { struct wrap_data* ioh; if(mh == NULL) return MPG123_ERR; mpg123_close(mh); ioh = wrap_get(mh); if(ioh == NULL) return MPG123_ERR; /* If both callbacks are NULL, switch totally to internal I/O, else just use fallback for at most half of them. */ if(r_read == NULL && r_lseek == NULL) { /* Only the type is actually important to disable the code. */ ioh->iotype = 0; ioh->fd = -1; ioh->r_read = NULL; ioh->r_lseek = NULL; } else { ioh->iotype = IO_FD; ioh->fd = -1; /* On next mpg123_open_fd(), this gets a value. */ ioh->r_read = r_read != NULL ? r_read : fallback_read; ioh->r_lseek = r_lseek != NULL ? r_lseek : fallback_lseek; } /* The real reader replacement will happen while opening. */ return MPG123_OK; }
SharedPtr<Decoder> Mpg123DecoderFactory::createDecoder(SharedPtr<std::istream> file) { if(!mIsInited) return SharedPtr<Decoder>(nullptr); mpg123_handle *mpg123 = mpg123_new(0, 0); if(mpg123) { if(mpg123_replace_reader_handle(mpg123, r_read, r_lseek, 0) == MPG123_OK && mpg123_open_handle(mpg123, file.get()) == MPG123_OK) { int enc, channels; long srate; if(mpg123_getformat(mpg123, &srate, &channels, &enc) == MPG123_OK) { if((channels == 1 || channels == 2) && srate > 0 && mpg123_format_none(mpg123) == MPG123_OK && mpg123_format(mpg123, srate, channels, MPG123_ENC_SIGNED_16) == MPG123_OK) { // All OK return SharedPtr<Decoder>(new Mpg123Decoder(file, mpg123, channels, srate)); } } mpg123_close(mpg123); } mpg123_delete(mpg123); } return SharedPtr<Decoder>(nullptr); }
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; }
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; }