Mercurial > mplayer.hg
changeset 31524:083786e4aaf2
MP3 decoding through libmpg123
patch by Thomas Orgis, thomas-forum orgis org
| author | diego |
|---|---|
| date | Wed, 30 Jun 2010 09:55:14 +0000 |
| parents | 7ab5787e625c |
| children | dd2b64511f05 |
| files | Changelog Makefile configure etc/codecs.conf libmpcodecs/ad.c libmpcodecs/ad_mpg123.c |
| diffstat | 6 files changed, 622 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- a/Changelog Wed Jun 30 09:27:03 2010 +0000 +++ b/Changelog Wed Jun 30 09:55:14 2010 +0000 @@ -28,6 +28,7 @@ * hardware MPEG decoder priority lowered * support for external FAAD removed, since FFmpeg decoder is complete and only internal FAAD supports LATM it is pointless. + * external libmpg123 support Demuxers: * Mostly fixed timing issues with some H.264 (PAFF) samples
--- a/Makefile Wed Jun 30 09:27:03 2010 +0000 +++ b/Makefile Wed Jun 30 09:55:14 2010 +0000 @@ -185,6 +185,7 @@ stream/stream_live555.c SRCS_COMMON-$(MACOSX_FINDER) += osdep/macosx_finder_args.c SRCS_COMMON-$(MNG) += libmpdemux/demux_mng.c +SRCS_COMMON-$(MPG123) += libmpcodecs/ad_mpg123.c SRCS_MP3LIB-X86-$(HAVE_AMD3DNOW) += mp3lib/dct36_3dnow.c \ mp3lib/dct64_3dnow.c
--- a/configure Wed Jun 30 09:27:03 2010 +0000 +++ b/configure Wed Jun 30 09:55:14 2010 +0000 @@ -337,6 +337,7 @@ --disable-ladspa disable LADSPA plugin support [autodetect] --disable-libbs2b disable libbs2b audio filter support [autodetect] --disable-libdv disable libdv 0.9.5 en/decoding support [autodetect] + --disable-mpg123 disable libmpg123 MP3 decoding support [autodetect] --disable-mad disable libmad (MPEG audio) support [autodetect] --disable-mp3lame disable LAME MP3 encoding support [autodetect] --disable-mp3lame-lavc disable LAME in libavcodec [autodetect] @@ -639,6 +640,7 @@ _libvorbis=auto _speex=auto _theora=auto +_mpg123=auto _mp3lib=auto _liba52=auto _libdca=auto @@ -1033,6 +1035,8 @@ --disable-tremor-low) _tremor_low=no ;; --enable-theora) _theora=yes ;; --disable-theora) _theora=no ;; + --enable-mpg123) _mpg123=yes ;; + --disable-mpg123) _mpg123=no ;; --enable-mp3lib) _mp3lib=yes ;; --disable-mp3lib) _mp3lib=no ;; --enable-liba52) _liba52=yes ;; @@ -6693,6 +6697,25 @@ fi echores "$_mp3lib" +# Any version of libmpg123 shall be fine. +echocheck "mpg123 support" +def_mpg123='#undef CONFIG_MPG123' +if test "$_mpg123" = auto; then + _mpg123=no + cat > $TMPC <<EOF +#include <mpg123.h> +int main(void){ mpg123_init(); return 0; } +EOF + cc_check -lmpg123 && _mpg123=yes && extra_ldflags="$extra_ldflags -lmpg123" +fi +if test "$_mpg123" = yes ; then + def_mpg123='#define CONFIG_MPG123 1' + codecmodules="mpg123 $codecmodules" +else + nocodecmodules="mpg123 $nocodecmodules" +fi +echores "$_mpg123" + echocheck "liba52 support" def_liba52='#undef CONFIG_LIBA52' if test "$_liba52" = auto ; then @@ -8564,6 +8587,7 @@ MNG = $_mng MP3LAME = $_mp3lame MP3LIB = $_mp3lib +MPG123 = $_mpg123 MUSEPACK = $_musepack NAS = $_nas NATIVE_RTSP = $_native_rtsp @@ -8935,6 +8959,7 @@ $def_mp3lame_preset $def_mp3lame_preset_medium $def_mp3lib +$def_mpg123 $def_musepack $def_speex $def_theora
--- a/etc/codecs.conf Wed Jun 30 09:27:03 2010 +0000 +++ b/etc/codecs.conf Wed Jun 30 09:55:14 2010 +0000 @@ -4163,6 +4163,21 @@ fourcc "LAME" ; used in mythtv .nuv files driver mp3lib +audiocodec mpg123 + ; this is preferred over ffmp2/ffmp3 since it is faster, generally + info "MPEG 1.0/2.0/2.5 layers I, II, III" + status working + comment "High-performance decoder using libmpg123." + format 0x50 ; layer-1 && layer-2 + format 0x55 ; layer-3 + format 0x5500736d ; "ms\0\x55" older mp3 fcc (MOV files) + format 0x5000736d ; "ms\0\x50" older mp2 fcc (MOV files) + format 0x55005354 ; broken file + fourcc ".mp3" ; CBR/VBR MP3 (MOV files) + fourcc "MP3 " ; used in .nsv files + fourcc "LAME" ; used in mythtv .nuv files + driver mpg123 + audiocodec ffmp3on4float info "FFmpeg Multi-channel MPEG layer-3 on MP4 audio" status working
--- a/libmpcodecs/ad.c Wed Jun 30 09:27:03 2010 +0000 +++ b/libmpcodecs/ad.c Wed Jun 30 09:55:14 2010 +0000 @@ -34,6 +34,7 @@ /* Missed vorbis, mad, dshow */ //extern ad_functions_t mpcodecs_ad_null; +extern const ad_functions_t mpcodecs_ad_mpg123; extern const ad_functions_t mpcodecs_ad_mp3lib; extern const ad_functions_t mpcodecs_ad_ffmpeg; extern const ad_functions_t mpcodecs_ad_liba52; @@ -64,6 +65,9 @@ const ad_functions_t * const mpcodecs_ad_drivers[] = { // &mpcodecs_ad_null, +#ifdef CONFIG_MPG123 + &mpcodecs_ad_mpg123, +#endif #ifdef CONFIG_MP3LIB &mpcodecs_ad_mp3lib, #endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libmpcodecs/ad_mpg123.c Wed Jun 30 09:55:14 2010 +0000 @@ -0,0 +1,576 @@ +/* + * MPEG 1.0/2.0/2.5 audio layer I, II, III decoding with libmpg123 + * + * Copyright (C) 2010 Thomas Orgis <thomas@orgis.org> + * + * MPlayer is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * MPlayer is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with MPlayer; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> + +#include "config.h" + +#include "ad_internal.h" + +static const ad_info_t info = { + "MPEG 1.0/2.0/2.5 layers I, II, III", + "mpg123", + "Thomas Orgis", + "mpg123.org", + "High-performance decoder using libmpg123." +}; + +LIBAD_EXTERN(mpg123) + +#include "libvo/fastmemcpy.h" + +/* We avoid any usage of mpg123 API that is sensitive to the large file + * support setting. This ensures compatibility with a wide range of libmpg123 + * installs. This code is intended to work with version 1.0.0 of libmpg123. + * + * Though the chosen API subset is not affected by the choice of large file + * support, the mpg123 header (old versions of which) might include a check + * for matching _FILE_OFFSET_BITS. Since MPlayer does always define this one + * for large file support, we are safe for any default mpg123 install that + * either doesn't have such checks or defaults to the large value of + * _FILE_OFFSET_BITS . + * So, in short: There's no worry unless you have a non-default libmpg123 + * with intentionally disabled large file support. */ +/* You might need to #undef _FILE_OFFSET_BITS here on a 64 bit system + with released mpg123 1.12 when using callback API. SVN snapshots + should work fine. */ +#include <mpg123.h> + +/* Selection of mpg123 usage patterns: + * AD_MPG123_CALLBACK: Use callback API instead of feeding of memory buffers. + * That needs mpg123>=1.12, on x86-64 SVN snapshot because of + * _FILE_OFFSET_BITS being defined (see above). + * AD_MPG123_PACKET: Use packet-based input (including pts handling). + * AD_MPG123_SEEKBUFFER: Use internal mpg123 buffer to enhance stream parsing. + * Makes sense with callback API only. + * Any of those might affect I/O performance, might be significant compared + * to the excessively optimized decoding. + */ +/* #define AD_MPG123_CALLBACK */ +#define AD_MPG123_PACKET +/* #define AD_MPG123_SEEKBUFFER */ + +/* Switch for updating bitrate info of VBR files. Not essential. */ +#define AD_MPG123_MEAN_BITRATE + +/* Funny thing, that. I assume I shall use it for selecting mpg123 channels. + * Please correct me if I guessed wrong. */ +extern int fakemono; + +struct ad_mpg123_context { + mpg123_handle *handle; +#ifdef AD_MPG123_MEAN_BITRATE + /* Running mean for bit rate, stream length estimation. */ + float mean_rate; + unsigned int mean_count; + /* Time delay for updates. */ + short delay; +#endif + /* If the stream is actually VBR. */ + char vbr; +#if (defined AD_MPG123_CALLBACK) && (defined AD_MPG123_PACKET) + unsigned char *packet; + int packleft; +#endif +}; + +static void context_reset(struct ad_mpg123_context *con) +{ +#ifdef AD_MPG123_MEAN_BITRATE + con->mean_rate = 0.; + con->mean_count = 0; + con->delay = 1; +#endif +#if (defined AD_MPG123_CALLBACK) && (defined AD_MPG123_PACKET) + con->packet = NULL; + con->packleft = 0; +#endif +} + + +#ifdef AD_MPG123_CALLBACK +/* Mpg123 calls that for retrieving data. + * This wrapper is at least needed for the call frame (ssize_t vs. int). */ +static ssize_t read_callback(void *ash, void *buf, size_t count) +{ + sh_audio_t *sh = ash; +#ifdef AD_MPG123_PACKET + struct ad_mpg123_context *con = sh->context; + unsigned char *target = buf; + int need = count; + ssize_t got = 0; + while (need > 0) { + if (con->packleft > 0) { + int get = need > con->packleft ? con->packleft : need; + /* Any difference to normal memcpy? */ + fast_memcpy(target, con->packet, get); + /* OK, that does look redundant. */ + con->packet += get; + con->packleft -= get; + target += get; + need -= get; + got += get; + } else { + double pts; + /* Feed more input data. */ + con->packleft = ds_get_packet_pts(sh->ds, &con->packet, &pts); + if (con->packleft <= 0) + break; /* Apparently that's it. EOF. */ + + /* Next bytes from that presentation time. */ + if (pts != MP_NOPTS_VALUE) { + sh->pts = pts; + sh->pts_bytes = 0; + } + } + } + return got; +#else + /* It returns int... with the meaning of byte count. */ + return (ssize_t) demux_read_data(sh->ds, buf, count); +#endif +} + +/* Arbitrary input seeking is not supported with this MPlayer API(?). + That also means that we won't read any ID3v1 tags. */ +static off_t seek_callback(void *sh, off_t pos, int whence) +{ + return -1; +} +#endif + +/* 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; + context_reset(con); + + /* Auto-choice of optimized decoder (first argument NULL). */ + con->handle = mpg123_new(NULL, &err); + if (!con->handle) + goto bad_end; + +#ifdef CONFIG_FAKE_MONO + /* 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; +#endif +#ifdef AD_MPG123_CALLBACK + /* The I/O is handled via callbacks to MPlayer stream functions, + * actually only the reading, as general seeking does not seem to be available */ + if (mpg123_replace_reader_handle(con->handle, read_callback, + seek_callback, NULL) != MPG123_OK) { + mp_msg(MSGT_DECAUDIO, MSGL_ERR, "mpg123 error: %s\n", + mpg123_strerror(con->handle)); + mpg123_exit(); + return 0; + } +#endif + + /* 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); + /* Old headers don't know MPG123_SEEKBUFFER yet, so use the plain 0x100. */ +#ifdef AD_MPG123_SEEKBUFFER + mpg123_param(con->handle, MPG123_ADD_FLAGS, 0x100, 0.0); +#endif + + /* 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. */ + + /* Example for RVA choice (available since libmpg123 1.0.0): + mpg123_param(con->handle, MPG123_RVA, MPG123_RVA_MIX, 0.0) */ + + 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; +} + +/* Compute bitrate from frame size. */ +static int compute_bitrate(struct mpg123_frameinfo *i) +{ + static const int samples_per_frame[4][4] = { + {-1, 384, 1152, 1152}, /* MPEG 1 */ + {-1, 384, 1152, 576}, /* MPEG 2 */ + {-1, 384, 1152, 576}, /* MPEG 2.5 */ + {-1, -1, -1, -1}, /* Unknown */ + }; + return (int) ((i->framesize + 4) * 8 * i->rate * 0.001 / + samples_per_frame[i->version][i->layer] + 0.5); +} + +/* Opted against the header printout from old mp3lib, too much + * irrelevant info. This is modelled after the mpg123 app's + * standard output line. + * If more verbosity is demanded, one can add more detail and + * also throw in ID3v2 info which libmpg123 collects anyway. */ +static void print_header_compact(struct mpg123_frameinfo *i) +{ + static const char *smodes[5] = { + "stereo", "joint-stereo", "dual-channel", "mono", "invalid" + }; + static const char *layers[4] = { + "Unknown", "I", "II", "III" + }; + static const char *versions[4] = { + "1.0", "2.0", "2.5", "x.x" + }; + + mp_msg(MSGT_DECAUDIO, MSGL_V, "MPEG %s layer %s, ", + versions[i->version], layers[i->layer]); + switch (i->vbr) { + case MPG123_CBR: + if (i->bitrate) + mp_msg(MSGT_DECAUDIO, MSGL_V, "%d kbit/s", i->bitrate); + else + mp_msg(MSGT_DECAUDIO, MSGL_V, "%d kbit/s (free format)", + compute_bitrate(i)); + break; + case MPG123_VBR: + mp_msg(MSGT_DECAUDIO, MSGL_V, "VBR"); + break; + case MPG123_ABR: + mp_msg(MSGT_DECAUDIO, MSGL_V, "%d kbit/s ABR", i->abr_rate); + break; + default: + mp_msg(MSGT_DECAUDIO, MSGL_V, "???"); + } + mp_msg(MSGT_DECAUDIO, MSGL_V, ", %ld Hz %s\n", i->rate, + smodes[i->mode]); +} + +#ifndef AD_MPG123_CALLBACK +/* This tries to extract a requested amount of decoded data. + * Even when you request 0 bytes, it will feed enough input so that + * the decoder _could_ have delivered something. + * Returns byte count >= 0, -1 on error. + * + * Thoughts on exact pts keeping: + * We have to assume that MPEG frames are cut in pieces by packet boundaries. + * Also, it might be possible that the first packet does not contain enough + * data to ensure initial stream sync... or re-sync on erroneous streams. + * So we need something robust to relate the decoded byte count to the correct + * time stamp. This is tricky, though. From the outside, you cannot tell if, + * after having fed two packets until the first output arrives, one should + * start counting from the first packet's pts or the second packet's. + * So, let's just count from the last fed package's pts. If the packets are + * exactly cut to MPEG frames, this will cause one frame mismatch in the + * beginning (when mpg123 peeks ahead for the following header), but will + * be corrected with the third frame already. One might add special code to + * not increment the base pts past the first packet's after a resync before + * the first decoded bytes arrived. */ +static int decode_a_bit(sh_audio_t *sh, unsigned char *buf, int count) +{ + int ret = MPG123_OK; + int got = 0; + struct ad_mpg123_context *con = sh->context; + + /* There will be one MPG123_NEW_FORMAT message on first open. + * This will be implicitly handled in reopen_stream(). */ + do { + size_t got_now = 0; + ret = mpg123_decode(con->handle, NULL, 0, buf + got, count - got, + &got_now); + got += got_now; +#ifdef AD_MPG123_PACKET + sh->pts_bytes += got_now; +#endif + + if (ret == MPG123_NEED_MORE) { + int incount; +#ifdef AD_MPG123_PACKET + double pts; + unsigned char *inbuf; + /* Feed more input data. */ + incount = ds_get_packet_pts(sh->ds, &inbuf, &pts); + if (incount <= 0) + break; /* Apparently that's it. EOF. */ + + /* Next bytes from that presentation time. */ + if (pts != MP_NOPTS_VALUE) { + sh->pts = pts; + sh->pts_bytes = 0; + } +#else + const int inbufsize = 4096; + unsigned char inbuf[inbufsize]; + /* Feed more input data. */ + incount = demux_read_data(((sh_audio_t *) sh)->ds, + inbuf, inbufsize); + if (incount == 0) + break; /* Apparently that's it. EOF. */ +#endif + + /* Do not use mpg123_feed(), added in later libmpg123 versions. */ + ret = mpg123_decode(con->handle, inbuf, incount, NULL, 0, NULL); + /* Return value is checked in the loop condition. + * It could be MPG12_OK now, it could need more. */ + } + /* Older mpg123 versions might indicate MPG123_DONE, so be prepared. */ + else if (ret == MPG123_ERR || ret == MPG123_DONE) + break; + + } while (ret == MPG123_NEED_MORE || got < count); + + if (ret == MPG123_ERR) { + mp_msg(MSGT_DECAUDIO, MSGL_ERR, "mpg123 decoding failed: %s\n", + mpg123_strerror(con->handle)); + mpg123_close(con->handle); + return -1; + } + + return got; +} +#endif + +/* Close, reopen stream. Feed data until we know the format of the stream. + * 1 on success, 0 on error */ +static int reopen_stream(sh_audio_t *sh) +{ + long rate; + int chan, enc; + struct ad_mpg123_context *con = (struct ad_mpg123_context*) sh->context; + + mpg123_close(con->handle); + context_reset(con); + +#ifdef AD_MPG123_CALLBACK + if (MPG123_OK == mpg123_open_handle(con->handle, sh) && +#else + if (/* Open and make sure we have fed enough data to get stream properties. */ + MPG123_OK == mpg123_open_feed(con->handle) && + /* Feed data until mpg123 is ready (has found stream beginning). */ + !decode_a_bit(sh, NULL, 0) && +#endif + /* Not handing NULL pointers for compatibility with old libmpg123. */ + MPG123_OK == mpg123_getformat(con->handle, &rate, &chan, &enc)) { + return 1; + } else { + mp_msg(MSGT_DECAUDIO, MSGL_ERR, + "mpg123 failed to reopen stream: %s\n", + mpg123_strerror(con->handle)); + mpg123_close(con->handle); + return 0; + } +} + +/* Now we really start accessing some data and determining file format. + * Paranoia note: The mpg123_close() on errors is not really necessary, + * But it ensures that we don't accidentally continue decoding with a + * bad state (possibly interpreting the format badly or whatnot). */ +static int init(sh_audio_t *sh) +{ + long rate = 0; + int channels = 0; + int encoding = 0; + mpg123_id3v2 *v2; + struct mpg123_frameinfo finfo; + struct ad_mpg123_context *con = sh->context; + + /* We're open about any output format that libmpg123 will suggest. + * Note that a standard build will always default to 16 bit signed and + * the native sample rate of the file. */ + if (MPG123_OK == mpg123_format_all(con->handle) && + reopen_stream(sh) && + MPG123_OK == mpg123_getformat(con->handle, &rate, &channels, &encoding) && + /* Forbid the format to change later on. */ + MPG123_OK == mpg123_format_none(con->handle) && + MPG123_OK == mpg123_format(con->handle, rate, channels, encoding) && + /* Get MPEG header info. */ + MPG123_OK == mpg123_info(con->handle, &finfo) && + /* Since we queried format, mpg123 should have read past ID3v2 tags. + * We need to decide if printing of UTF-8 encoded text info is wanted. */ + MPG123_OK == mpg123_id3(con->handle, NULL, &v2)) { + /* If we are here, we passed all hurdles. Yay! Extract the info. */ + print_header_compact(&finfo); + /* Do we want to print out the UTF-8 Id3v2 info? + if (v2) + print_id3v2(v2); */ + + /* Have kb/s, want B/s + * For VBR, the first frame will be a bad estimate. */ + sh->i_bps = (finfo.bitrate ? finfo.bitrate : compute_bitrate(&finfo)) + * 1000 / 8; + context_reset(con); + con->vbr = (finfo.vbr != MPG123_CBR); + sh->channels = channels; + sh->samplerate = rate; + /* Without external force, mpg123 will always choose signed encoding, + * and non-16-bit only on builds that don't support it. + * Be reminded that it doesn't matter to the MPEG file what encoding + * is produced from it. */ + switch (encoding) { + case MPG123_ENC_SIGNED_8: + sh->sample_format = AF_FORMAT_S8; + sh->samplesize = 1; + break; + case MPG123_ENC_SIGNED_16: + sh->sample_format = AF_FORMAT_S16_NE; + sh->samplesize = 2; + break; + /* To stay compatible with the oldest libmpg123 headers, do not rely + * on float and 32 bit encoding symbols being defined. + * Those formats came later */ + case 0x1180: /* MPG123_ENC_SIGNED_32 */ + sh->sample_format = AF_FORMAT_S32_NE; + sh->samplesize = 4; + break; + case 0x200: /* MPG123_ENC_FLOAT_32 */ + sh->sample_format = AF_FORMAT_FLOAT_NE; + sh->samplesize = 4; + break; + default: + mp_msg(MSGT_DECAUDIO, MSGL_ERR, + "Bad encoding from mpg123: %i.\n", encoding); + mpg123_close(con->handle); + return 0; + } + + return 1; + } else { + mp_msg(MSGT_DECAUDIO, MSGL_ERR, "mpg123 init error: %s\n", + mpg123_strerror(con->handle)); + mpg123_close(con->handle); + return 0; + } +} + +static void uninit(sh_audio_t *sh) +{ + struct ad_mpg123_context *con = (struct ad_mpg123_context*) sh->context; + + mpg123_close(con->handle); + mpg123_delete(con->handle); + free(sh->context); + sh->context = NULL; + mpg123_exit(); +} + +#ifdef AD_MPG123_MEAN_BITRATE +/* Update mean bitrate. This could be dropped if accurate time display + * on audio file playback is not desired. */ +static void update_info(sh_audio_t *sh) +{ + struct ad_mpg123_context *con = sh->context; + if (con->vbr && --con->delay < 1) { + struct mpg123_frameinfo finfo; + if (MPG123_OK == mpg123_info(con->handle, &finfo)) { + if (++con->mean_count > ((unsigned int) -1) / 2) + con->mean_count = ((unsigned int) -1) / 4; + + /* Might not be numerically optimal, but works fine enough. */ + con->mean_rate = ((con->mean_count - 1) * con->mean_rate + + finfo.bitrate) / con->mean_count; + sh->i_bps = (int) (con->mean_rate * 1000 / 8); + + con->delay = 10; + } + } +} +#endif + +static int decode_audio(sh_audio_t *sh, unsigned char *buf, int minlen, + int maxlen) +{ + int bytes; + +#ifdef AD_MPG123_CALLBACK + struct ad_mpg123_context *con = sh->context; + size_t got_bytes = 0; + if (MPG123_ERR == mpg123_read(con->handle, buf, minlen, &got_bytes)) { + mp_msg(MSGT_DECAUDIO, MSGL_ERR, "Decoding error in mpg123: %s\n", + mpg123_strerror(con->handle)); + return -1; + } +#ifdef AD_MPG123_PACKET + sh->pts_bytes += got_bytes; +#endif + bytes = got_bytes; +#else + bytes = decode_a_bit(sh, buf, minlen); +#endif + + if (bytes == 0) + return -1; /* EOF */ + +#ifdef AD_MPG123_MEAN_BITRATE + update_info(sh); +#endif + + return bytes; +} + +static int control(sh_audio_t *sh, int cmd, void *arg, ...) +{ + switch (cmd) { + case ADCTRL_RESYNC_STREAM: + /* Close/reopen the stream for mpg123 to make sure it doesn't + * think that it still knows the exact stream position. + * Otherwise, we would have funny effects from the gapless code. + * Oh, and it helps to minimize artifacts from jumping in the stream. */ + if (reopen_stream(sh)) { +#ifdef AD_MPG123_MEAN_BITRATE + update_info(sh); +#endif + return CONTROL_TRUE; + } else { + mp_msg(MSGT_DECAUDIO, MSGL_ERR, + "mpg123 cannot reopen stream for resync.\n"); + return CONTROL_FALSE; + } + break; + } + return CONTROL_UNKNOWN; +}