int main(int argc, char **argv) { int ret = 0; size_t errs[2] = {0, 0}; size_t errs_ntom[2] = {0, 0}; if(argc < arg_total) { fprintf(stderr, "\nUsage: %s <decoder> <preframes> <mpeg audio file>\n\n", argv[0]); return -1; } mpg123_init(); m = mpg123_new(argv[arg_decoder], NULL); mpg123_param(m, MPG123_RESYNC_LIMIT, -1, 0); if(mpg123_param(m, MPG123_PREFRAMES, atol(argv[arg_preframes]), 0) == MPG123_OK) printf("Testing library with preframes set to %li\n", atol(argv[arg_preframes])); filename = argv[arg_file]; ret = check_seeking(errs); if(ret == 0) { printf("Now with NtoM resampling to 33333 Hz!"); mpg123_param(m, MPG123_FORCE_RATE, 33333, 0); ret = check_seeking(errs_ntom); } else fprintf(stderr, "Some failure occured! Unable to test properly!"); printf("\n"); printf("1to1 indexed seek errors: %"SIZE_P" / %"SIZE_P"\n", (size_p)errs[0],(size_p)samples); printf("1to1 non-indexed seek errors: %"SIZE_P" / %"SIZE_P"\n", (size_p)errs[1],(size_p)samples); printf("NtoM indexed seek errors: %"SIZE_P" / %"SIZE_P"\n", (size_p)errs_ntom[0],(size_p)samples); printf("NtoM non-indexed seek errors: %"SIZE_P" / %"SIZE_P"\n", (size_p)errs_ntom[1],(size_p)samples); printf("Errors in getting first sample again: %"SIZE_P"\n", first_sample_errs); printf("\n"); if(ret == 0) { if(first_sample_errs == 0 && errs[0] == 0 && errs[1] == 0 && errs_ntom[0] == 0 && errs_ntom[1] == 0) { printf("Congratulations, all seeks were accurate!\n"); printf("But be warned: Not _all_ sample offsets have been tested. This result just means that the basic mechanism of sample-accurate seeking seems to work.\n"); } else { printf("There have been some errors. For layer 3 files, this may be due to too low MPG123_PREFRAMES.\n"); ret = -1; } } else fprintf(stderr, "Some bad failure during checking!\n"); mpg123_delete(m); mpg123_exit(); return ret; }
Mpg123Decoder::Mpg123Decoder(Data *data, const std::string &ext, int bufferSize) : Decoder(data, ext, bufferSize) , decoder_file(data) , handle(0) , channels(MPG123_STEREO) , duration(-2.0) { int ret = 0; 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(nullptr, nullptr); if (handle == nullptr) throw love::Exception("Could not create decoder."); // Suppressing all mpg123 messages. mpg123_param(handle, MPG123_ADD_FLAGS, MPG123_QUIET, 0); try { ret = mpg123_replace_reader_handle(handle, &read_callback, &seek_callback, &cleanup_callback); if (ret != MPG123_OK) throw love::Exception("Could not set decoder callbacks."); ret = mpg123_open_handle(handle, &decoder_file); if (ret != MPG123_OK) throw love::Exception("Could not open decoder."); // mpg123_getformat should be able to tell us the properties of the stream's first frame. long rate = 0; ret = mpg123_getformat(handle, &rate, &channels, nullptr); if (ret == MPG123_ERR) throw love::Exception("Could not get stream information."); // I forgot what this was about. if (channels == 0) channels = 2; // Force signed 16-bit output. mpg123_param(handle, MPG123_FLAGS, (channels == 2 ? MPG123_FORCE_STEREO : MPG123_MONO_MIX), 0); mpg123_format_none(handle); mpg123_format(handle, rate, channels, MPG123_ENC_SIGNED_16); sampleRate = rate; } catch (love::Exception &) { mpg123_delete(handle); throw; } }
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; }
bool Mp3::openFromFile(const std::string& filename) { stop(); if (myBuffer) delete [] myBuffer; if(myHandle) mpg123_close(myHandle); mpg123_param(myHandle, MPG123_RESYNC_LIMIT, -1, 0); #ifndef DEBUG mpg123_param(myHandle, MPG123_ADD_FLAGS, 32 , 0); #endif if (mpg123_open(myHandle, filename.c_str()) != MPG123_OK) { std::cerr << mpg123_strerror(myHandle) << std::endl; return false; } //This should improve myDuration calculation, but generates frankenstein streams¿? //Warning: Real sample count 9505152 differs from given gapless sample count -1152. Frankenstein stream if(mpg123_scan(myHandle) != MPG123_OK) { std::cerr << "Failed when scanning " << std::endl; return false; } long rate = 0; int channels = 0, encoding = 0; if (mpg123_getformat(myHandle, &rate, &channels, &encoding) != MPG123_OK) { std::cerr << "Failed to get format information for 464480e9ee6eb73bc2b768d7e3d7865aa432fc34quot;" << filename << "464480e9ee6eb73bc2b768d7e3d7865aa432fc34quot;" << std::endl; return false; } myDuration = sf::Time(sf::milliseconds(1 + 1000*mpg123_length(myHandle)/rate)); myBufferSize = mpg123_outblock(myHandle); myBuffer = new unsigned char[myBufferSize]; if (!myBuffer) { std::cerr << "Failed to reserve memory for decoding one frame for 464480e9ee6eb73bc2b768d7e3d7865aa432fc34quot;" << filename << "464480e9ee6eb73bc2b768d7e3d7865aa432fc34quot;" << std::endl; return false; } sf::SoundStream::initialize(channels, rate); return true; }
mpg123_handle *our_mpg123_new(const char *decoder, int *error) { mpg123_handle *mh; const char *arch = "auto"; int x64 = 0; int rc = 0; const char *err = NULL; if (*globals.decoder || globals.outscale || globals.vol) { if (*globals.decoder) { arch = globals.decoder; } if ((mh = mpg123_new(arch, &rc))) { if (rc) { err = mpg123_plain_strerror(rc); } if (globals.outscale) { mpg123_param(mh, MPG123_OUTSCALE, globals.outscale, 0); } if (globals.vol) { mpg123_volume(mh, globals.vol); } } } else { #ifdef WIN32 x64++; #else if (sizeof(void *) == 4) { arch = "i586"; } else { x64++; } #endif if ((mh = mpg123_new(arch, &rc))) { if (rc) { err = mpg123_plain_strerror(rc); } if (x64) { mpg123_param(mh, MPG123_OUTSCALE, 8192, 0); } } } if (err) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error allocating mpg123 handle! %s\n", err); } return mh; }
void * in_mp3_open(char *file) { mpg123_handle *m; int channels, encoding, r; long rate; channels = encoding = 0; rate = 0; m = mpg123_new(NULL, &r); assert(m != NULL); /* verbosity */ mpg123_param(m, MPG123_VERBOSE, 1, 0); r = mpg123_open(m, file); if (r != MPG123_OK) return NULL; assert(m != NULL); assert(mpg123_getformat(m, &rate, &channels, &encoding) == MPG123_OK); mpg123_format_none(m); mpg123_format(m, rate, channels, encoding); return m; }
bool ofxSoundFile::mpg123Open(string path){ int err; mp3File = mpg123_new(NULL,&err); mpg123_param(mp3File, MPG123_ADD_FLAGS, MPG123_FORCE_FLOAT, 0.); if(mpg123_open(mp3File,path.c_str())!=MPG123_OK){ ofLogError() << "ofxSoundFile: couldnt read " + path; return false; } int encoding; long int rate; mpg123_getformat(mp3File,&rate,&channels,&encoding); if(encoding!=MPG123_ENC_SIGNED_16 && encoding != MPG123_ENC_FLOAT_32){ ofLogError() << "ofxSoundFile: unsupported encoding"; return false; } mpg123_format_none(mp3File); mpg123_format(mp3File, rate, channels, encoding); samplerate = rate; mpg123_seek(mp3File,0,SEEK_END); samples = mpg123_tell(mp3File); mpg123_seek(mp3File,0,SEEK_SET); bitDepth = 16; //TODO:get real bitdepth;. }
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::IsMp3(FILE* stream) { Mpg123Decoder decoder; // Prevent stream handle destruction mpg123_replace_reader_handle(decoder.handle.get(), custom_read, custom_seek, noop_close); // Prevent skipping of too many garbage, breaks heuristic mpg123_param(decoder.handle.get(), MPG123_RESYNC_LIMIT, 64, 0.0); if (!decoder.Open(stream)) { return false; } unsigned char buffer[1024]; int err = 0; size_t done = 0; int err_count = 0; // Read beginning of assumed MP3 file and count errors as an heuristic to detect MP3 for (int i = 0; i < 10; ++i) { err = mpg123_read(decoder.handle.get(), buffer, 1024, &done); if (err != MPG123_OK) { err_count += 1; } if (err_count >= 3) { break; } } return err_count < 3; }
VALUE rb_mpg123_new(VALUE klass, VALUE filename) { int err = MPG123_OK; mpg123_handle *mh; VALUE mpg123; long rate; int channels, encoding; Check_Type(filename, T_STRING); if ((mh = mpg123_new(NULL, &err)) == NULL) { rb_raise(rb_eStandardError, "%s", mpg123_plain_strerror(err)); } mpg123_param(mh, MPG123_ADD_FLAGS, MPG123_FORCE_FLOAT, 0.); if (mpg123_open(mh, (char*) RSTRING_PTR(filename)) != MPG123_OK || mpg123_getformat(mh, &rate, &channels, &encoding) != MPG123_OK) { rb_raise(rb_eStandardError, "%s", mpg123_strerror(mh)); } if (encoding != MPG123_ENC_FLOAT_32) { rb_raise(rb_eStandardError, "bad encoding"); } mpg123_format_none(mh); mpg123_format(mh, rate, channels, encoding); VALUE new_mpg123 = Data_Wrap_Struct(rb_cMpg123, 0, cleanup, mh); rb_iv_set(new_mpg123, "@file", filename); return new_mpg123; }
stream *stream_new() { int err; stream *stream = malloc(sizeof(struct stream)); memset(stream, 0, sizeof(struct stream)); if ((stream->mpg123 = mpg123_new(NULL, &err)) == NULL) { fprintf(stderr, "%s", mpg123_plain_strerror(err)); return NULL; } mpg123_param(stream->mpg123, MPG123_VERBOSE, 0, 0); mpg123_param(stream->mpg123, MPG123_ADD_FLAGS, MPG123_FORCE_FLOAT, 0.); return stream; }
long MP3_create(const char* format_parameters, amci_codec_fmt_info_t* format_description) { mp3_coder_state* coder_state; int ret_code; coder_state = malloc(sizeof(mp3_coder_state)); if (!coder_state) { ERROR("no memory for allocating mp3 coder state\n"); return -1; } DBG("MP3: creating lame %s\n", get_lame_version()); format_description[0].id = 0; coder_state->gfp = lame_init(); if (!coder_state->gfp) { ERROR("initialiting lame\n"); free(coder_state); return -1; } lame_set_errorf(coder_state->gfp, &no_output); lame_set_debugf(coder_state->gfp, &no_output); lame_set_msgf(coder_state->gfp, &no_output); lame_set_num_channels(coder_state->gfp,1); lame_set_in_samplerate(coder_state->gfp,8000); lame_set_brate(coder_state->gfp,16); lame_set_mode(coder_state->gfp,3); // mono lame_set_quality(coder_state->gfp,2); /* 2=high 5 = medium 7=low */ id3tag_init(coder_state->gfp); id3tag_set_title(coder_state->gfp, "mp3 voicemail by iptel.org"); ret_code = lame_init_params(coder_state->gfp); if (ret_code < 0) { ERROR("lame encoder init failed: return code is %d\n", ret_code); free(coder_state); return -1; } #ifdef WITH_MPG123DECODER coder_state->mpg123_h = mpg123_new(NULL, NULL); if (!coder_state->mpg123_h) { ERROR("initializing mpg123 decoder instance\n"); return -1; } /* suppress output */ mpg123_param(coder_state->mpg123_h, MPG123_FLAGS, MPG123_QUIET /* | MPG123_FORCE_MONO */,0); /* mpg123_param(coder_state->mpg123_h, MPG123_VERBOSE, 0, 0); */ #endif return (long)coder_state; }
int mp3Init(struct playerHandles *ph){ pthread_mutex_init(&dechandle_lock,NULL); mpg123_init(); h.m = mpg123_new(NULL, NULL); if(h.m == NULL){ fprintf(stderr,"Unable to create mpg123 handle\n"); return -1; } //mpg123_param(h.m, MPG123_VERBOSE, 0, 0); mpg123_param(h.m, MPG123_RESYNC_LIMIT, -1, 0); mpg123_param(h.m, MPG123_FLAGS, MPG123_QUIET, 0); //mpg123_open_feed(h.m); mpg123_open_fd(h.m,fileno(ph->ffd)); if(h.m == NULL) return -1; return 0; }
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; }
VALUE rb_mpg123_new(VALUE klass, VALUE filename, VALUE decideRate) { printf("Made it: 1\n"); int err = MPG123_OK; mpg123_handle *mh; printf("mh: "); printf("%d", mh); printf("\n"); VALUE mpg123; long rate; rate = decideRate; printf("rate: "); printf("%d", rate); printf("\n"); int channels, encoding; printf("Made it: 2\n"); printf("rate: "); printf("%d", rate); printf("\n"); Check_Type(filename, T_STRING); printf("Made it: 3\n"); printf("rate: "); printf("%d", rate); printf("\n"); if ((mh = mpg123_new(NULL, &err)) == NULL) { rb_raise(rb_eStandardError, "%s", mpg123_plain_strerror(err)); } printf("Made it: 4\n"); printf("rate: "); printf("%d", rate); printf("\n"); mpg123_param(mh, MPG123_ADD_FLAGS, MPG123_FORCE_FLOAT, 0.); printf("mpg123_open is: "); printf("%d", mpg123_open(mh, (char*) RSTRING_PTR(filename))); printf("\n"); printf("mh: "); printf("%d", mh); printf("\n"); printf("rate: "); printf("%d", rate); printf("\n"); printf("channels: "); printf("%d", channels); printf("\n"); printf("encoding: "); printf("%d", encoding); printf("\n"); printf("mpg123_getformat is: "); printf("%d", mpg123_getformat(mh, &rate, &channels, &encoding)); printf("\n"); printf("MPG123_OK is: "); printf("%d", MPG123_OK); printf("\n"); if (mpg123_open(mh, (char*) RSTRING_PTR(filename)) != MPG123_OK || mpg123_getformat(mh, &rate, &channels, &encoding) != MPG123_OK) { rb_raise(rb_eStandardError, "%s", mpg123_strerror(mh)); } printf("Made it: 5"); if (encoding != MPG123_ENC_FLOAT_32) { rb_raise(rb_eStandardError, "bad encoding"); } printf("Made it: 6"); mpg123_format_none(mh); mpg123_format(mh, rate, channels, encoding); printf("Made it: 7"); return Data_Wrap_Struct(rb_cMpg123, 0, cleanup, mh); }
int main(int argc, char **argv) { int err; int ret = 0; mpg123_handle *mh; mpg123_id3v2 *id3; if(argc < 2) { printf("Gimme a MPEG file name...\n"); return 0; } mpg123_init(); mh = mpg123_new(NULL, &err); if(err != MPG123_OK) goto badend; mpg123_param(mh, MPG123_ADD_FLAGS, MPG123_PLAIN_ID3TEXT, 0.); err = mpg123_open(mh, argv[1]); if(err != MPG123_OK) goto badend; err = mpg123_scan(mh); if(err != MPG123_OK) goto badend; err = mpg123_id3(mh, NULL, &id3); if(err != MPG123_OK) goto badend; if(id3 == NULL) { error("No ID3 data found."); goto badend; } print_field("artist", id3->artist); print_field("title", id3->title); print_field("album", id3->album); print_field("comment", id3->comment); goto end; badend: ret = -1; end: mpg123_delete(mh); mpg123_exit(); return ret; }
bool Mp3Decoder::open( Downloader* downloader ) { _handle = mpg123_new(NULL, NULL); if(_handle == NULL) { printf("mpg123_new failed\n"); return false; } mpg123_replace_reader_handle(_handle, g_read, NULL, NULL); int res = mpg123_param(_handle, MPG123_FLAGS, MPG123_FUZZY | MPG123_SEEKBUFFER | MPG123_GAPLESS, 0); assert(res == MPG123_OK); res = mpg123_open_handle(_handle, downloader); if(res != MPG123_OK) { printf("mpg123_open_handle failed\n"); return false; } _downloader = downloader; return afterOpen(); }
static void term_handle_key(mpg123_handle *fr, out123_handle *ao, char val) { debug1("term_handle_key: %c", val); switch(tolower(val)) { case MPG123_BACK_KEY: out123_pause(ao); out123_drop(ao); if(paused) pause_cycle=(int)(LOOP_CYCLES/mpg123_tpf(fr)); if(mpg123_seek_frame(fr, 0, SEEK_SET) < 0) error1("Seek to begin failed: %s", mpg123_strerror(fr)); framenum=0; break; case MPG123_NEXT_KEY: out123_pause(ao); out123_drop(ao); next_track(); break; case MPG123_NEXT_DIR_KEY: out123_pause(ao); out123_drop(ao); next_dir(); break; case MPG123_QUIT_KEY: debug("QUIT"); if(stopped) { stopped = 0; out123_pause(ao); /* no chance for annoying underrun warnings */ out123_drop(ao); } set_intflag(); offset = 0; break; case MPG123_PAUSE_KEY: paused=1-paused; out123_pause(ao); /* underrun awareness */ out123_drop(ao); if(paused) { /* Not really sure if that is what is wanted This jumps in audio output, but has direct reaction to pausing loop. */ out123_param_float(ao, OUT123_PRELOAD, 0.); pause_recycle(fr); } else out123_param_float(ao, OUT123_PRELOAD, param.preload); if(stopped) stopped=0; if(param.verbose) print_stat(fr, 0, ao); else fprintf(stderr, "%s", (paused) ? MPG123_PAUSED_STRING : MPG123_EMPTY_STRING); break; case MPG123_STOP_KEY: case ' ': /* TODO: Verify/ensure that there is no "chirp from the past" when seeking while stopped. */ stopped=1-stopped; if(paused) { paused=0; offset -= pause_cycle; } if(stopped) out123_pause(ao); else { if(offset) /* If position changed, old is outdated. */ out123_drop(ao); /* No out123_continue(), that's triggered by out123_play(). */ } if(param.verbose) print_stat(fr, 0, ao); else fprintf(stderr, "%s", (stopped) ? MPG123_STOPPED_STRING : MPG123_EMPTY_STRING); break; case MPG123_FINE_REWIND_KEY: seekmode(fr, ao); offset--; break; case MPG123_FINE_FORWARD_KEY: seekmode(fr, ao); offset++; break; case MPG123_REWIND_KEY: seekmode(fr, ao); offset-=10; break; case MPG123_FORWARD_KEY: seekmode(fr, ao); offset+=10; break; case MPG123_FAST_REWIND_KEY: seekmode(fr, ao); offset-=50; break; case MPG123_FAST_FORWARD_KEY: seekmode(fr, ao); offset+=50; break; case MPG123_VOL_UP_KEY: mpg123_volume_change(fr, 0.02); break; case MPG123_VOL_DOWN_KEY: mpg123_volume_change(fr, -0.02); break; case MPG123_PITCH_UP_KEY: case MPG123_PITCH_BUP_KEY: case MPG123_PITCH_DOWN_KEY: case MPG123_PITCH_BDOWN_KEY: case MPG123_PITCH_ZERO_KEY: { double new_pitch = param.pitch; switch(val) /* Not tolower here! */ { case MPG123_PITCH_UP_KEY: new_pitch += MPG123_PITCH_VAL; break; case MPG123_PITCH_BUP_KEY: new_pitch += MPG123_PITCH_BVAL; break; case MPG123_PITCH_DOWN_KEY: new_pitch -= MPG123_PITCH_VAL; break; case MPG123_PITCH_BDOWN_KEY: new_pitch -= MPG123_PITCH_BVAL; break; case MPG123_PITCH_ZERO_KEY: new_pitch = 0.0; break; } set_pitch(fr, ao, new_pitch); fprintf(stderr, "New pitch: %f\n", param.pitch); } break; case MPG123_VERBOSE_KEY: param.verbose++; if(param.verbose > VERBOSE_MAX) { param.verbose = 0; clear_stat(); } mpg123_param(fr, MPG123_VERBOSE, param.verbose, 0); break; case MPG123_RVA_KEY: if(++param.rva > MPG123_RVA_MAX) param.rva = 0; if(param.verbose) fprintf(stderr, "\n"); mpg123_param(fr, MPG123_RVA, param.rva, 0); mpg123_volume_change(fr, 0.); break; case MPG123_PREV_KEY: out123_pause(ao); out123_drop(ao); prev_track(); break; case MPG123_PREV_DIR_KEY: out123_pause(ao); out123_drop(ao); prev_dir(); break; case MPG123_PLAYLIST_KEY: fprintf(stderr, "%s\nPlaylist (\">\" indicates current track):\n", param.verbose ? "\n" : ""); print_playlist(stderr, 1); fprintf(stderr, "\n"); break; case MPG123_TAG_KEY: fprintf(stderr, "%s\n", param.verbose ? "\n" : ""); print_id3_tag(fr, param.long_id3, stderr); fprintf(stderr, "\n"); break; case MPG123_MPEG_KEY: if(param.verbose) print_stat(fr,0,ao); /* Make sure that we are talking about the correct frame. */ fprintf(stderr, "\n"); if(param.verbose > 1) print_header(fr); else print_header_compact(fr); fprintf(stderr, "\n"); break; case MPG123_HELP_KEY: { /* This is more than the one-liner before, but it's less spaghetti. */ int i; fprintf(stderr,"\n\n -= terminal control keys =-\n"); for(i=0; i<(sizeof(term_help)/sizeof(struct keydef)); ++i) { if(term_help[i].key2) fprintf(stderr, "[%c] or [%c]", term_help[i].key, term_help[i].key2); else fprintf(stderr, "[%c]", term_help[i].key); fprintf(stderr, "\t%s\n", term_help[i].desc); } fprintf(stderr, "\nAlso, the number row (starting at 1, ending at 0) gives you jump points into the current track at 10%% intervals.\n"); fprintf(stderr, "\n"); } break; case MPG123_FRAME_INDEX_KEY: case MPG123_VARIOUS_INFO_KEY: if(param.verbose) fprintf(stderr, "\n"); switch(val) /* because of tolower() ... */ { case MPG123_FRAME_INDEX_KEY: print_index(fr); { long accurate; if(mpg123_getstate(fr, MPG123_ACCURATE, &accurate, NULL) == MPG123_OK) fprintf(stderr, "Accurate position: %s\n", (accurate == 0 ? "no" : "yes")); else error1("Unable to get state: %s", mpg123_strerror(fr)); } break; case MPG123_VARIOUS_INFO_KEY: { const char* curdec = mpg123_current_decoder(fr); if(curdec == NULL) fprintf(stderr, "Cannot get decoder info!\n"); else fprintf(stderr, "Active decoder: %s\n", curdec); } } break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': { off_t len; int num; num = val == '0' ? 10 : val - '0'; --num; /* from 0 to 9 */ /* Do not swith to seekmode() here, as we are jumping once to a specific position. Dropping buffer contents is enough and there is no race filling the buffer or waiting for more incremental seek orders. */ len = mpg123_length(fr); out123_pause(ao); out123_drop(ao); if(len > 0) mpg123_seek(fr, (off_t)( (num/10.)*len ), SEEK_SET); } break; case MPG123_BOOKMARK_KEY: continue_msg("BOOKMARK"); break; default: ; } }
int main(int argc, char **argv) { int i, result; mpg123_handle* m; #if defined(WANT_WIN32_UNICODE) win32_cmdline_utf8(&argc,&argv); #endif progname = argv[0]; while ((result = getlopt(argc, argv, opts))) switch (result) { case GLO_UNKNOWN: fprintf (stderr, "%s: Unknown option \"%s\".\n", progname, loptarg); usage(1); case GLO_NOARG: fprintf (stderr, "%s: Missing argument for option \"%s\".\n", progname, loptarg); usage(1); } #ifdef WIN32 fprintf(stderr, "WARNING: This tool is not yet adapted to run on Windows (file I/O, unicode arguments)!\n"); #endif if(loptind >= argc) usage(1); mpg123_init(); m = mpg123_new(NULL, NULL); mpg123_param(m, MPG123_ADD_FLAGS, MPG123_PICTURE, 0.); for(i=loptind; i < argc; ++i) { mpg123_id3v1 *v1; mpg123_id3v2 *v2; int meta; if(mpg123_open(m, argv[i]) != MPG123_OK) { fprintf(stderr, "Cannot open %s: %s\n", argv[i], mpg123_strerror(m)); continue; } mpg123_scan(m); meta = mpg123_meta_check(m); if(meta & MPG123_ID3 && mpg123_id3(m, &v1, &v2) == MPG123_OK) { printf("FILE: %s\n", argv[i]); printf("\n==== ID3v1 ====\n"); if(v1 != NULL) print_v1(v1); printf("\n==== ID3v2 ====\n"); if(v2 != NULL) print_v2(v2); printf("\n==== ID3v2 Raw frames ====\n"); if(v2 != NULL) { print_raw_v2(v2); if(param.store_pics) store_pictures(argv[i], v2); } } else printf("Nothing found for %s.\n", argv[i]); mpg123_close(m); } mpg123_delete(m); mpg123_exit(); if(errors) error1("Encountered %i errors along the way.", errors); return errors != 0; #if defined(WANT_WIN32_UNICODE) win32_cmdline_utf8_free(argc,argv); #endif }
int mp3decode_reg(struct xlplayer *xlplayer) { static pthread_once_t once_control = PTHREAD_ONCE_INIT; struct mp3decode_vars *self; struct chapter *chapter; int fd, rv; long rate; int channels, encoding; int src_error; pthread_once(&once_control, decoder_library_init); if (!decoder_library_ok) { fprintf(stderr, "mp3decode_reg: decoder library is not ok\n"); goto rej; } if (!(self = xlplayer->dec_data = calloc(1, sizeof (struct mp3decode_vars)))) { fprintf(stderr, "mp3decode_reg: malloc failure\n"); goto rej; } if (!(self->mh = mpg123_new(NULL, NULL))) { fprintf(stderr, "mp3decode_reg: handle not okay"); goto rej_; } #ifdef MPG123_AUTO_RESAMPLE if (mpg123_param(self->mh, MPG123_REMOVE_FLAGS, MPG123_AUTO_RESAMPLE, 0.0) != MPG123_OK) { fprintf(stderr, "mpgdecode_reg: failed to turn off auto resampling\n"); goto rej_; } #endif if (mpg123_param(self->mh, MPG123_ADD_FLAGS, MPG123_FORCE_STEREO, 0.0) != MPG123_OK) { fprintf(stderr, "mpgdecode_reg: failed to set flags"); goto rej_; } if (mpg123_format_none(self->mh) != MPG123_OK) { fprintf(stderr, "mp3decode_reg: failed to clear output formats"); goto rej_; } /* all the permitted mp3 sample rates are enabled * forced stereo is in effect so no need to add mono formats */ mpg123_format(self->mh, 48000, MPG123_STEREO, MPG123_ENC_FLOAT_32); mpg123_format(self->mh, 44100, MPG123_STEREO, MPG123_ENC_FLOAT_32); mpg123_format(self->mh, 32000, MPG123_STEREO, MPG123_ENC_FLOAT_32); mpg123_format(self->mh, 24000, MPG123_STEREO, MPG123_ENC_FLOAT_32); mpg123_format(self->mh, 22050, MPG123_STEREO, MPG123_ENC_FLOAT_32); mpg123_format(self->mh, 16000, MPG123_STEREO, MPG123_ENC_FLOAT_32); mpg123_format(self->mh, 12000, MPG123_STEREO, MPG123_ENC_FLOAT_32); mpg123_format(self->mh, 11025, MPG123_STEREO, MPG123_ENC_FLOAT_32); mpg123_format(self->mh, 8000, MPG123_STEREO, MPG123_ENC_FLOAT_32); if (!(self->fp = fopen(xlplayer->pathname, "r"))) { fprintf(stderr, "mp3decode_reg: failed to open %s\n", xlplayer->pathname); goto rej_; } mp3_tag_read(&self->taginfo, self->fp); lseek(fd = fileno(self->fp), 0, SEEK_SET); if ((rv = mpg123_open_fd(self->mh, fd)) != MPG123_OK) { fprintf(stderr, "mp3decode_reg: mpg123_open_fd failed with return value %d\n", rv); goto rej__; } if (mpg123_getformat(self->mh, &rate, &channels, &encoding) != MPG123_OK || channels != 2) { fprintf(stderr, "mp3decode_reg: mpg123_getformat returned unexpected value\n"); goto rej___; } if (rate != xlplayer->samplerate) { fprintf(stderr, "mp3decode_reg: configuring resampler\n"); xlplayer->src_state = src_new(xlplayer->rsqual, channels, &src_error); if (src_error) { fprintf(stderr, "mp3decode_reg: src_new reports %s\n", src_strerror(src_error)); goto rej___; } xlplayer->src_data.src_ratio = (double)xlplayer->samplerate / (double)rate; xlplayer->src_data.end_of_input = 0; size_t output_frames = (size_t)(xlplayer->src_data.src_ratio * 1.1 * 1152); xlplayer->src_data.output_frames = (long)output_frames; if (!(xlplayer->src_data.data_out = malloc(output_frames * 2 * sizeof (float)))) { fprintf(stderr, "mp3decode_reg: malloc failure\n"); goto rej____; } self->resample = TRUE; } xlplayer->dec_init = mp3decode_init; xlplayer->dec_play = mp3decode_play; xlplayer->dec_eject = mp3decode_eject; if ((chapter = mp3_tag_chapter_scan(&self->taginfo, xlplayer->play_progress_ms + 70))) { self->current_chapter = chapter; xlplayer_set_dynamic_metadata(xlplayer, dynamic_metadata_form[chapter->title.encoding], chapter->artist.text, chapter->title.text, chapter->album.text, 0); } if (xlplayer->seek_s) if (mpg123_seek(self->mh, (off_t)rate * xlplayer->seek_s, SEEK_SET) < 0) { fprintf(stderr, "mp3decode_init: seek failed\n"); mp3decode_eject(xlplayer); xlplayer->playmode = PM_STOPPED; xlplayer->command = CMD_COMPLETE; } return ACCEPTED; rej____: xlplayer->src_state = src_delete(xlplayer->src_state); rej___: mpg123_delete(self->mh); rej__: mp3_tag_cleanup(&self->taginfo); fclose(self->fp); rej_: free(self); rej: return REJECTED; }
int main(int argc, char *argv[]) { SNDFILE* sndfile = NULL; SF_INFO sfinfo; mpg123_handle *mh = NULL; unsigned char* buffer = NULL; size_t buffer_size = 0; size_t done = 0; int channels = 0, encoding = 0; long rate = 0; int err = MPG123_OK; off_t samples = 0; if (argc<3) usage(); printf( "Input file: %s\n", argv[1]); printf( "Output file: %s\n", argv[2]); err = mpg123_init(); if(err != MPG123_OK || (mh = mpg123_new(NULL, &err)) == NULL) { fprintf(stderr, "Basic setup goes wrong: %s", mpg123_plain_strerror(err)); cleanup(mh); return -1; } /* Simple hack to enable floating point output. */ if(argc >= 4 && !strcmp(argv[3], "f32")) mpg123_param(mh, MPG123_ADD_FLAGS, MPG123_FORCE_FLOAT, 0.); /* Let mpg123 work with the file, that excludes MPG123_NEED_MORE messages. */ if( mpg123_open(mh, argv[1]) != MPG123_OK /* Peek into track and get first output format. */ || mpg123_getformat(mh, &rate, &channels, &encoding) != MPG123_OK ) { fprintf( stderr, "Trouble with mpg123: %s\n", mpg123_strerror(mh) ); cleanup(mh); return -1; } if(encoding != MPG123_ENC_SIGNED_16 && encoding != MPG123_ENC_FLOAT_32) { /* Signed 16 is the default output format anyways; it would actually by only different if we forced it. So this check is here just for this explanation. */ cleanup(mh); fprintf(stderr, "Bad encoding: 0x%x!\n", encoding); return -2; } /* Ensure that this output format will not change (it could, when we allow it). */ mpg123_format_none(mh); mpg123_format(mh, rate, channels, encoding); bzero(&sfinfo, sizeof(sfinfo) ); sfinfo.samplerate = rate; sfinfo.channels = channels; sfinfo.format = SF_FORMAT_WAV|(encoding == MPG123_ENC_SIGNED_16 ? SF_FORMAT_PCM_16 : SF_FORMAT_FLOAT); printf("Creating WAV with %i channels and %liHz.\n", channels, rate); sndfile = sf_open(argv[2], SFM_WRITE, &sfinfo); if(sndfile == NULL){ fprintf(stderr, "Cannot open output file!\n"); cleanup(mh); return -2; } /* Buffer could be almost any size here, mpg123_outblock() is just some recommendation. Important, especially for sndfile writing, is that the size is a multiple of sample size. */ buffer_size = argc >= 5 ? atol(argv[4]) : mpg123_outblock(mh); buffer = malloc( buffer_size ); do { sf_count_t more_samples; err = mpg123_read( mh, buffer, buffer_size, &done ); more_samples = encoding == MPG123_ENC_SIGNED_16 ? sf_write_short(sndfile, (short*)buffer, done/sizeof(short)) : sf_write_float(sndfile, (float*)buffer, done/sizeof(float)); if(more_samples < 0 || more_samples*mpg123_encsize(encoding) != done) { fprintf(stderr, "Warning: Written number of samples does not match the byte count we got from libmpg123: %li != %li\n", (long)(more_samples*mpg123_encsize(encoding)), (long)done); } samples += more_samples; /* We are not in feeder mode, so MPG123_OK, MPG123_ERR and MPG123_NEW_FORMAT are the only possibilities. We do not handle a new format, MPG123_DONE is the end... so abort on anything not MPG123_OK. */ } while (err==MPG123_OK); if(err != MPG123_DONE) fprintf( stderr, "Warning: Decoding ended prematurely because: %s\n", err == MPG123_ERR ? mpg123_strerror(mh) : mpg123_plain_strerror(err) ); sf_close( sndfile ); samples /= channels; printf("%li samples written.\n", (long)samples); cleanup(mh); return 0; }
/* This initializes libmpg123 and prepares the handle, including funky * parameters. */ static int preinit(sh_audio_t *sh) { int err, flag; 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; sh->context = malloc(sizeof(struct ad_mpg123_context)); con = sh->context; /* Auto-choice of optimized decoder (first argument NULL). */ con->handle = mpg123_new(NULL, &err); if (!con->handle) goto bad_end; /* Guessing here: Default value triggers forced upmix of mono to stereo. */ flag = fakemono == 0 ? MPG123_FORCE_STEREO : fakemono == 1 ? MPG123_MONO_LEFT : fakemono == 2 ? MPG123_MONO_RIGHT : 0; if (mpg123_param(con->handle, MPG123_ADD_FLAGS, flag, 0.0) != MPG123_OK) 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. */ /* 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) */ #ifdef AD_MPG123_FRAMEWISE /* Prevent funky automatic resampling. * This way, we can be sure that one frame will never produce * more than 1152 stereo samples. */ mpg123_param(con->handle, MPG123_REMOVE_FLAGS, MPG123_AUTO_RESAMPLE, 0.); #else /* Older mpg123 is vulnerable to concatenated streams when gapless cutting * is enabled (will only play the jingle of a badly constructed radio * stream). The versions using framewise decoding are fine with that. */ mpg123_param(con->handle, MPG123_REMOVE_FLAGS, MPG123_GAPLESS, 0.); #endif return 1; bad_end: if (!con->handle) mp_msg(MSGT_DECAUDIO, MSGL_ERR, "mpg123 preinit error: %s\n", mpg123_plain_strerror(err)); else mp_msg(MSGT_DECAUDIO, MSGL_ERR, "mpg123 preinit error: %s\n", mpg123_strerror(con->handle)); if (con->handle) mpg123_delete(con->handle); mpg123_exit(); free(sh->context); sh->context = NULL; return 0; }
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; }
int mpeg_open(char *path) { int rv = -1; int err = 0; int res = 0; int channels = 0; int encoding = 0; long rate = 0; if(handle != NULL) { goto mpeg_open_exit; } handle = calloc(1, sizeof(mpeg_handle_t)); if(handle == NULL) { goto mpeg_open_exit; } handle->mh = mpg123_new(NULL, &err); if(handle->mh == NULL) { goto mpeg_open_exit; } mpg123_param(handle->mh, MPG123_FLAGS, MPG123_QUIET, 0.0); handle->driver = ao_default_driver_id(); handle->bufsize = mpg123_outblock(handle->mh) / BUF_DIVISOR; handle->buf = (unsigned char*) malloc(handle->bufsize); if(handle->buf == NULL) { goto mpeg_open_exit; } res = mpg123_open(handle->mh, path); if(res != MPG123_OK) { goto mpeg_open_exit; } res = mpg123_getformat(handle->mh, &rate, &channels, &encoding); if(res != MPG123_OK) { goto mpeg_open_exit; } handle->format.bits = mpg123_encsize(encoding) * 8; handle->format.rate = rate; handle->format.channels = channels; handle->format.byte_format = AO_FMT_NATIVE; handle->format.matrix = 0; handle->device = ao_open_live(handle->driver, &(handle->format), NULL); if(handle->device == NULL) { goto mpeg_open_exit; } else { /* Return value to indicate success */ rv = 0; } mpeg_open_exit: if(rv == -1) { if(handle != NULL) { 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; } } return rv; }
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 main(int argc, char **argv) { int sockfd; int newfd; int portno; int ready; fd_set read_set; socklen_t socklen; struct sockaddr_in serv_addr; struct sockaddr_in cli_addr; thread_args_t *thread_args; pthread_t stream_thread; mpg123_handle *mh; char buffer[32]; int bytes_read; if (argc < 2) { fprintf(stderr, "specify port to listen too\n"); return 1; } sockfd = -1; newfd = -1; stream_thread = -1; fprintf(stderr, "bring up ao\n"); ao_initialize(); fprintf(stderr, "bring up mpg123\n"); mpg123_init(); mh = mpg123_new(NULL, NULL); if (!mh) { fprintf(stderr, "error mpg123_new()\n"); goto cleanup; } fprintf(stderr, "mpg123 initialized\n"); mpg123_param(mh, MPG123_VERBOSE, 2, 0); signal(SIGINT, handle_sigint); sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) { perror("socket"); goto cleanup; } memset(&serv_addr, 0, sizeof(serv_addr)); portno = atoi(argv[1]); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_port = htons(portno); if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { perror("bind"); goto cleanup; } if (listen(sockfd, 5) < 0) { perror("listen"); goto cleanup; } socklen = sizeof(cli_addr); g_go_on = 1; g_cmd_sock = -1; g_busy = 0; g_stop = 0; FD_ZERO(&g_read_master); FD_SET(sockfd, &g_read_master); while (g_go_on) { read_set = g_read_master; ready = select(10, &read_set, NULL, NULL, NULL); if (ready < 0) { perror("select!!!!"); //g_go_on = 0; } else if (ready > 0) { if (FD_ISSET(sockfd, &read_set)) { newfd = accept(sockfd, (struct sockaddr *)&cli_addr, &socklen); if (newfd < 0) { perror("accept"); } else { bytes_read = read(newfd, buffer, sizeof(buffer)); if (bytes_read > 0) { if (bytes_read >= strlen(IDENT_STREAM_SOCK) && strncmp(buffer, IDENT_STREAM_SOCK, strlen(IDENT_STREAM_SOCK)) == 0) { fprintf(stderr, "stream sock %d connected\n", newfd); thread_args = malloc(sizeof(thread_args_t)); thread_args->mh = mh; thread_args->stream_socket = newfd; if (stream_thread != -1) { pthread_detach(stream_thread); stream_thread = -1; } if (pthread_create(&stream_thread, NULL, stream_thread_main, thread_args) < 0) { free(thread_args); perror("pthread create"); break; } } else if (bytes_read >= strlen(IDENT_CMD_SOCK) && strncmp(buffer, IDENT_CMD_SOCK, strlen(IDENT_CMD_SOCK)) == 0) { make_socket_nonblock(newfd); FD_SET(newfd, &g_read_master); g_cmd_sock = newfd; fprintf(stderr, "cmd sock %d connected\n", newfd); } } } } if (FD_ISSET(g_cmd_sock, &read_set)) { memset(buffer, 0, sizeof(buffer)); bytes_read = read(g_cmd_sock, buffer, sizeof(buffer)); if (bytes_read <= 0) { fprintf(stderr, "read() - lost cmd_sock\n"); close_cmd_sock(); /* reset paused state here.. otherwise we get in dead lock */ /* and stop that bitch */ g_paused = 0; g_stop = 1; if (bytes_read != 0) { perror("cmd_sock read"); } } else { handle_command(buffer, bytes_read); } } } } fprintf(stderr, "shutdown... waiting for thread\n"); if (stream_thread != -1 ) { pthread_join(stream_thread, NULL); pthread_detach(stream_thread); } fprintf(stderr, "shutdown\n"); cleanup: if (g_cmd_sock != -1) { close_cmd_sock(); } if (sockfd != -1) { close(sockfd); } if (mh) { fprintf(stderr, "close mpg123\n"); mpg123_close(mh); mpg123_delete(mh); } mpg123_exit(); fprintf(stderr, "shutdown ao\n"); ao_shutdown(); return 0; }
bool DecoderMPG123::initialize() { if (input()->isSequential ()) //for streams only { TagExtractor extractor(input()); if(!extractor.id3v2tag().isEmpty()) addMetaData(extractor.id3v2tag()); } int err = mpg123_init(); if(err != MPG123_OK) { qWarning("DecoderMPG123: basic setup goes wrong: %s", mpg123_plain_strerror(err)); return false; } int channels = 0; if(!(m_handle = mpg123_new(0, &err))) { qWarning("DecoderMPG123: basic setup goes wrong: %s", mpg123_plain_strerror(err)); return false; } mpg123_param (m_handle, MPG123_ADD_FLAGS, MPG123_SEEKBUFFER | MPG123_FUZZY, 0); if((err = mpg123_replace_reader_handle(m_handle, mpg123_read_cb, mpg123_seek_cb, 0)) != MPG123_OK) { qWarning("DecoderMPG123: mpg123 error: %s", mpg123_plain_strerror(err)); cleanup(m_handle); m_handle = 0; return false; } setMPG123Format(MPG123_ENC_FLOAT_32); if((err = mpg123_open_handle(m_handle, this)) != MPG123_OK) { qWarning("DecoderMPG123: mpg123 error: %s", mpg123_plain_strerror(err)); cleanup(m_handle); m_handle = 0; return false; } if((err = mpg123_getformat(m_handle, &m_rate, &channels, &m_mpg123_encoding)) != MPG123_OK) { qWarning("DecoderMPG123: mpg123 error: %s", mpg123_plain_strerror(err)); cleanup(m_handle); m_handle = 0; return false; } //check format if(m_mpg123_encoding != MPG123_ENC_FLOAT_32) { cleanup(m_handle); qWarning("DecoderMPG123: bad encoding: 0x%x!\n", m_mpg123_encoding); m_handle = 0; return false; } if(!input()->isSequential()) { if((err = mpg123_scan(m_handle)) != MPG123_OK) qWarning("DecoderMPG123: mpg123 error: %s", mpg123_plain_strerror(err)); //duration m_totalTime = (qint64) mpg123_length(m_handle) * 1000 / m_rate; } else m_totalTime = 0; configure(m_rate, channels, Qmmp::PCM_FLOAT); return true; }
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; }
static void term_handle_input(mpg123_handle *fr, audio_output_t *ao, int do_delay) { int n = 1; /* long offset = 0; */ while(n > 0) { fd_set r; struct timeval t; char val; t.tv_sec=0; t.tv_usec=(do_delay) ? 10*1000 : 0; FD_ZERO(&r); FD_SET(0,&r); n = select(1,&r,NULL,NULL,&t); if(n > 0 && FD_ISSET(0,&r)) { if(read(0,&val,1) <= 0) break; switch(tolower(val)) { case MPG123_BACK_KEY: if(!param.usebuffer) ao->flush(ao); else buffer_resync(); if(paused) pause_cycle=(int)(LOOP_CYCLES/mpg123_tpf(fr)); if(mpg123_seek_frame(fr, 0, SEEK_SET) < 0) error1("Seek to begin failed: %s", mpg123_strerror(fr)); framenum=0; break; case MPG123_NEXT_KEY: if(!param.usebuffer) ao->flush(ao); else buffer_resync(); /* was: plain_buffer_resync */ next_track(); break; case MPG123_QUIT_KEY: debug("QUIT"); if(stopped) { stopped = 0; if(param.usebuffer) { buffer_resync(); buffer_start(); } } set_intflag(); offset = 0; break; case MPG123_PAUSE_KEY: paused=1-paused; if(paused) { /* Not really sure if that is what is wanted This jumps in audio output, but has direct reaction to pausing loop. */ if(param.usebuffer) buffer_resync(); pause_recycle(fr); } if(stopped) { stopped=0; if(param.usebuffer) buffer_start(); } fprintf(stderr, "%s", (paused) ? MPG123_PAUSED_STRING : MPG123_EMPTY_STRING); break; case MPG123_STOP_KEY: case ' ': /* when seeking while stopped and then resuming, I want to prevent the chirp from the past */ if(!param.usebuffer) ao->flush(ao); stopped=1-stopped; if(paused) { paused=0; offset -= pause_cycle; } if(param.usebuffer) { if(stopped) buffer_stop(); else { /* When we stopped buffer for seeking, we must resync. */ if(offset) buffer_resync(); buffer_start(); } } fprintf(stderr, "%s", (stopped) ? MPG123_STOPPED_STRING : MPG123_EMPTY_STRING); break; case MPG123_FINE_REWIND_KEY: if(param.usebuffer) seekmode(); offset--; break; case MPG123_FINE_FORWARD_KEY: seekmode(); offset++; break; case MPG123_REWIND_KEY: seekmode(); offset-=10; break; case MPG123_FORWARD_KEY: seekmode(); offset+=10; break; case MPG123_FAST_REWIND_KEY: seekmode(); offset-=50; break; case MPG123_FAST_FORWARD_KEY: seekmode(); offset+=50; break; case MPG123_VOL_UP_KEY: mpg123_volume_change(fr, 0.02); break; case MPG123_VOL_DOWN_KEY: mpg123_volume_change(fr, -0.02); break; case MPG123_PITCH_UP_KEY: case MPG123_PITCH_BUP_KEY: case MPG123_PITCH_DOWN_KEY: case MPG123_PITCH_BDOWN_KEY: case MPG123_PITCH_ZERO_KEY: { double new_pitch = param.pitch; switch(val) /* Not tolower here! */ { case MPG123_PITCH_UP_KEY: new_pitch += MPG123_PITCH_VAL; break; case MPG123_PITCH_BUP_KEY: new_pitch += MPG123_PITCH_BVAL; break; case MPG123_PITCH_DOWN_KEY: new_pitch -= MPG123_PITCH_VAL; break; case MPG123_PITCH_BDOWN_KEY: new_pitch -= MPG123_PITCH_BVAL; break; case MPG123_PITCH_ZERO_KEY: new_pitch = 0.0; break; } set_pitch(fr, ao, new_pitch); fprintf(stderr, "New pitch: %f\n", param.pitch); } break; case MPG123_VERBOSE_KEY: param.verbose++; if(param.verbose > VERBOSE_MAX) { param.verbose = 0; clear_stat(); } mpg123_param(fr, MPG123_VERBOSE, param.verbose, 0); break; case MPG123_RVA_KEY: if(++param.rva > MPG123_RVA_MAX) param.rva = 0; mpg123_param(fr, MPG123_RVA, param.rva, 0); mpg123_volume_change(fr, 0.); break; case MPG123_PREV_KEY: if(!param.usebuffer) ao->flush(ao); else buffer_resync(); /* was: plain_buffer_resync */ prev_track(); break; case MPG123_PLAYLIST_KEY: fprintf(stderr, "%s\nPlaylist (\">\" indicates current track):\n", param.verbose ? "\n" : ""); print_playlist(stderr, 1); fprintf(stderr, "\n"); break; case MPG123_TAG_KEY: fprintf(stderr, "%s\n", param.verbose ? "\n" : ""); print_id3_tag(fr, param.long_id3, stderr); fprintf(stderr, "\n"); break; case MPG123_MPEG_KEY: if(param.verbose) print_stat(fr,0,0); /* Make sure that we are talking about the correct frame. */ fprintf(stderr, "\n"); print_header(fr); fprintf(stderr, "\n"); break; case MPG123_HELP_KEY: { /* This is more than the one-liner before, but it's less spaghetti. */ int i; fprintf(stderr,"\n\n -= terminal control keys =-\n"); for(i=0; i<(sizeof(term_help)/sizeof(struct keydef)); ++i) { if(term_help[i].key2) fprintf(stderr, "[%c] or [%c]", term_help[i].key, term_help[i].key2); else fprintf(stderr, "[%c]", term_help[i].key); fprintf(stderr, "\t%s\n", term_help[i].desc); } fprintf(stderr, "\n"); } break; case MPG123_FRAME_INDEX_KEY: case MPG123_VARIOUS_INFO_KEY: if(param.verbose) fprintf(stderr, "\n"); switch(val) /* because of tolower() ... */ { case MPG123_FRAME_INDEX_KEY: print_index(fr); { long accurate; if(mpg123_getstate(fr, MPG123_ACCURATE, &accurate, NULL) == MPG123_OK) fprintf(stderr, "Accurate position: %s\n", (accurate == 0 ? "no" : "yes")); else error1("Unable to get state: %s", mpg123_strerror(fr)); } break; case MPG123_VARIOUS_INFO_KEY: { const char* curdec = mpg123_current_decoder(fr); if(curdec == NULL) fprintf(stderr, "Cannot get decoder info!\n"); else fprintf(stderr, "Active decoder: %s\n", curdec); } } break; default: ; } } } }