libmpg123.c File Reference

#include "mpg123lib_intern.h"
#include "icy2utf8.h"
#include "debug.h"
#include "gapless.h"
#include "sample.h"
#include "parse.h"

Include dependency graph for libmpg123.c:

Go to the source code of this file.

Macros
#define	FORCE_ACCURATE
#define	SEEKFRAME(mh)   ((mh)->ignoreframe < 0 ? 0 : (mh)->ignoreframe)
#define	track_need_init(mh)   ((mh)->num < 0)

Functions
int attribute_align_arg	mpg123_init (void)
void attribute_align_arg	mpg123_exit (void)
mpg123_handle attribute_align_arg *	mpg123_new (const char *decoder, int *error)
mpg123_handle attribute_align_arg *	mpg123_parnew (mpg123_pars *mp, const char *decoder, int *error)
int attribute_align_arg	mpg123_decoder (mpg123_handle *mh, const char *decoder)
int attribute_align_arg	mpg123_param (mpg123_handle *mh, enum mpg123_parms key, long val, double fval)
int attribute_align_arg	mpg123_par (mpg123_pars *mp, enum mpg123_parms key, long val, double fval)
int attribute_align_arg	mpg123_getparam (mpg123_handle *mh, enum mpg123_parms key, long *val, double *fval)
int attribute_align_arg	mpg123_getpar (mpg123_pars *mp, enum mpg123_parms key, long *val, double *fval)
int attribute_align_arg	mpg123_getstate (mpg123_handle *mh, enum mpg123_state key, long *val, double *fval)
int attribute_align_arg	mpg123_eq (mpg123_handle *mh, enum mpg123_channels channel, int band, double val)
double attribute_align_arg	mpg123_geteq (mpg123_handle *mh, enum mpg123_channels channel, int band)
int attribute_align_arg	mpg123_open (mpg123_handle *mh, const char *path)
int	open_fixed_pre (mpg123_handle *mh, int channels, int encoding)
int	open_fixed_post (mpg123_handle *mh, int channels, int encoding)
int attribute_align_arg	mpg123_open_fixed (mpg123_handle *mh, const char *path, int channels, int encoding)
int attribute_align_arg	mpg123_open_fd (mpg123_handle *mh, int fd)
int attribute_align_arg	mpg123_open_handle (mpg123_handle *mh, void *iohandle)
int attribute_align_arg	mpg123_open_feed (mpg123_handle *mh)
int attribute_align_arg	mpg123_replace_reader (mpg123_handle *mh, ssize_t(*r_read)(int, void *, size_t), off_t(*r_lseek)(int, off_t, int))
int attribute_align_arg	mpg123_replace_reader_handle (mpg123_handle *mh, ssize_t(*r_read)(void *, void *, size_t), off_t(*r_lseek)(void *, off_t, int), void(*cleanup)(void *))
int	decode_update (mpg123_handle *mh)
size_t attribute_align_arg	mpg123_safe_buffer (void)
size_t attribute_align_arg	mpg123_outblock (mpg123_handle *mh)
static int	get_next_frame (mpg123_handle *mh)
static int	zero_byte (mpg123_handle *fr)
static void	decode_the_frame (mpg123_handle *fr)
int attribute_align_arg	mpg123_framebyframe_decode (mpg123_handle *mh, off_t *num, unsigned char **audio, size_t *bytes)
int attribute_align_arg	mpg123_framebyframe_next (mpg123_handle *mh)
int attribute_align_arg	mpg123_decode_frame (mpg123_handle *mh, off_t *num, unsigned char **audio, size_t *bytes)
int attribute_align_arg	mpg123_read (mpg123_handle *mh, void *out, size_t size, size_t *done)
int attribute_align_arg	mpg123_feed (mpg123_handle *mh, const unsigned char *in, size_t size)
int attribute_align_arg	mpg123_decode (mpg123_handle *mh, const unsigned char *inmemory, size_t inmemsize, void *outmem, size_t outmemsize, size_t *done)
long attribute_align_arg	mpg123_clip (mpg123_handle *mh)
static int	init_track (mpg123_handle *mh)
int attribute_align_arg	mpg123_info (mpg123_handle *mh, struct mpg123_frameinfo *mi)
int attribute_align_arg	mpg123_getformat2 (mpg123_handle *mh, long *rate, int *channels, int *encoding, int clear_flag)
int attribute_align_arg	mpg123_getformat (mpg123_handle *mh, long *rate, int *channels, int *encoding)
off_t attribute_align_arg	mpg123_timeframe (mpg123_handle *mh, double seconds)
off_t attribute_align_arg	mpg123_tell (mpg123_handle *mh)
off_t attribute_align_arg	mpg123_tellframe (mpg123_handle *mh)
off_t attribute_align_arg	mpg123_tell_stream (mpg123_handle *mh)
static int	do_the_seek (mpg123_handle *mh)
off_t attribute_align_arg	mpg123_seek (mpg123_handle *mh, off_t sampleoff, int whence)
off_t attribute_align_arg	mpg123_feedseek (mpg123_handle *mh, off_t sampleoff, int whence, off_t *input_offset)
off_t attribute_align_arg	mpg123_seek_frame (mpg123_handle *mh, off_t offset, int whence)
int attribute_align_arg	mpg123_set_filesize (mpg123_handle *mh, off_t size)
off_t attribute_align_arg	mpg123_framelength (mpg123_handle *mh)
off_t attribute_align_arg	mpg123_length (mpg123_handle *mh)
int attribute_align_arg	mpg123_scan (mpg123_handle *mh)
int attribute_align_arg	mpg123_meta_check (mpg123_handle *mh)
void attribute_align_arg	mpg123_meta_free (mpg123_handle *mh)
int attribute_align_arg	mpg123_id3 (mpg123_handle *mh, mpg123_id3v1 **v1, mpg123_id3v2 **v2)
int attribute_align_arg	mpg123_id3_raw (mpg123_handle *mh, unsigned char **v1, size_t *v1_size, unsigned char **v2, size_t *v2_size)
int attribute_align_arg	mpg123_icy (mpg123_handle *mh, char **icy_meta)
char *attribute_align_arg	mpg123_icy2utf8 (const char *icy_text)
enum mpg123_text_encoding attribute_align_arg	mpg123_enc_from_id3 (unsigned char id3_enc_byte)
int	mpg123_store_utf8 (mpg123_string *sb, enum mpg123_text_encoding enc, const unsigned char *source, size_t source_size)
int attribute_align_arg	mpg123_index (mpg123_handle *mh, off_t **offsets, off_t *step, size_t *fill)
int attribute_align_arg	mpg123_set_index (mpg123_handle *mh, off_t *offsets, off_t step, size_t fill)
int attribute_align_arg	mpg123_close (mpg123_handle *mh)
void attribute_align_arg	mpg123_delete (mpg123_handle *mh)
void attribute_align_arg	mpg123_free (void *ptr)
const char *attribute_align_arg	mpg123_plain_strerror (int errcode)
int attribute_align_arg	mpg123_errcode (mpg123_handle *mh)
const char *attribute_align_arg	mpg123_strerror (mpg123_handle *mh)

Variables
static int	initialized = 0
static const char *	mpg123_error []

Macro Definition Documentation

FORCE_ACCURATE

#define FORCE_ACCURATE

Definition at line 15 of file libmpg123.c.

SEEKFRAME

#define SEEKFRAME

(

mh

)

((mh)->ignoreframe < 0 ? 0 : (mh)->ignoreframe)

Definition at line 19 of file libmpg123.c.

track_need_init

#define track_need_init

(

mh

)

((mh)->num < 0)

Definition at line 1074 of file libmpg123.c.

Function Documentation

decode_the_frame()

static void decode_the_frame ( mpg123_handle *  fr )

static

Definition at line 776 of file libmpg123.c.

{
    size_t needed_bytes = decoder_synth_bytes(fr, frame_expect_outsamples(fr));
    fr->clip += (fr->do_layer)(fr);
    /*fprintf(stderr, "frame %"OFF_P": got %"SIZE_P" / %"SIZE_P"\n", fr->num,(size_p)fr->buffer.fill, (size_p)needed_bytes);*/
    /* There could be less data than promised.
       Also, then debugging, we look out for coding errors that could result in _more_ data than expected. */
#ifdef DEBUG
    if(fr->buffer.fill != needed_bytes)
    {
#endif
        if(fr->buffer.fill < needed_bytes)
        {
            if(VERBOSE2)
            fprintf(stderr, "Note: broken frame %li, filling up with %"SIZE_P" zeroes, from %"SIZE_P"\n", (long)fr->num, (size_p)(needed_bytes-fr->buffer.fill), (size_p)fr->buffer.fill);
 
            /*
                One could do a loop with individual samples instead... but zero is zero
                Actually, that is wrong: zero is mostly a series of null bytes,
                but we have funny 8bit formats that have a different opinion on zero...
                Unsigned 16 or 32 bit formats are handled later.
            */
            memset( fr->buffer.data + fr->buffer.fill, zero_byte(fr), needed_bytes - fr->buffer.fill );
 
            fr->buffer.fill = needed_bytes;
#ifndef NO_NTOM
            /* ntom_val will be wrong when the decoding wasn't carried out completely */
            ntom_set_ntom(fr, fr->num+1);
#endif
        }
#ifdef DEBUG
        else
        {
            if(NOQUIET)
            error2("I got _more_ bytes than expected (%"SIZE_P" / %"SIZE_P"), that should not be possible!", (size_p)fr->buffer.fill, (size_p)needed_bytes);
        }
    }
#endif
    postprocess_buffer(fr);
}

Referenced by mpg123_decode(), mpg123_decode_frame(), and mpg123_framebyframe_decode().

decode_update()

int decode_update

(

mpg123_handle *

mh

)

Definition at line 573 of file libmpg123.c.

{
    long native_rate;
    int b;
 
    if(mh->num < 0)
    {
        if(!(mh->p.flags & MPG123_QUIET)) error("decode_update() has been called before reading the first MPEG frame! Internal programming error.");
 
        mh->err = MPG123_BAD_DECODER_SETUP;
        return MPG123_ERR;
    }
 
    mh->state_flags |= FRAME_FRESH_DECODER;
    native_rate = frame_freq(mh);
 
    b = frame_output_format(mh); /* Select the new output format based on given constraints. */
    if(b < 0) return MPG123_ERR;
 
    if(b == 1) mh->new_format = 1; /* Store for later... */
 
    debug3("updating decoder structure with native rate %li and af.rate %li (new format: %i)", native_rate, mh->af.rate, mh->new_format);
    if(mh->af.rate == native_rate) mh->down_sample = 0;
    else if(mh->af.rate == native_rate>>1) mh->down_sample = 1;
    else if(mh->af.rate == native_rate>>2) mh->down_sample = 2;
    else mh->down_sample = 3; /* flexible (fixed) rate */
    switch(mh->down_sample)
    {
        case 0:
        case 1:
        case 2:
            mh->down_sample_sblimit = SBLIMIT>>(mh->down_sample);
            /* With downsampling I get less samples per frame */
            mh->outblock = outblock_bytes(mh, (mh->spf>>mh->down_sample));
        break;
#ifndef NO_NTOM
        case 3:
        {
            if(synth_ntom_set_step(mh) != 0) return -1;
            if(frame_freq(mh) > mh->af.rate)
            {
                mh->down_sample_sblimit = SBLIMIT * mh->af.rate;
                mh->down_sample_sblimit /= frame_freq(mh);
                if(mh->down_sample_sblimit < 1)
                    mh->down_sample_sblimit = 1;
            }
            else mh->down_sample_sblimit = SBLIMIT;
            mh->outblock = outblock_bytes(mh,
                             ( ( NTOM_MUL-1+mh->spf
                               * (((size_t)NTOM_MUL*mh->af.rate)/frame_freq(mh))
                             )/NTOM_MUL ));
        }
        break;
#endif
    }
 
    if(!(mh->p.flags & MPG123_FORCE_MONO))
    {
        if(mh->af.channels == 1) mh->single = SINGLE_MIX;
        else mh->single = SINGLE_STEREO;
    }
    else mh->single = (mh->p.flags & MPG123_FORCE_MONO)-1;
    if(set_synth_functions(mh) != 0) return -1;;
 
    /* The needed size of output buffer may have changed. */
    if(frame_outbuffer(mh) != MPG123_OK) return -1;
 
    do_rva(mh);
    debug3("done updating decoder structure with native rate %li and af.rate %li and down_sample %i", frame_freq(mh), mh->af.rate, mh->down_sample);
 
    mh->decoder_change = 0;
    return 0;
}

do_the_seek()

static int do_the_seek ( mpg123_handle *  mh )

static

Definition at line 1211 of file libmpg123.c.

{
    int b;
    off_t fnum = SEEKFRAME(mh);
    mh->buffer.fill = 0;
 
    /* If we are inside the ignoreframe - firstframe window, we may get away without actual seeking. */
    if(mh->num < mh->firstframe)
    {
        mh->to_decode = FALSE; /* In any case, don't decode the current frame, perhaps ignore instead. */
        if(mh->num > fnum) return MPG123_OK;
    }
 
    /* If we are already there, we are fine either for decoding or for ignoring. */
    if(mh->num == fnum && (mh->to_decode || fnum < mh->firstframe)) return MPG123_OK;
    /* We have the frame before... just go ahead as normal. */
    if(mh->num == fnum-1)
    {
        mh->to_decode = FALSE;
        return MPG123_OK;
    }
 
    /* OK, real seeking follows... clear buffers and go for it. */
    frame_buffers_reset(mh);
#ifndef NO_NTOM
    if(mh->down_sample == 3)
    {
        ntom_set_ntom(mh, fnum);
        debug3("fixed ntom for frame %"OFF_P" to %lu, num=%"OFF_P, (off_p)fnum, mh->ntom_val[0], (off_p)mh->num);
    }
#endif
    b = mh->rd->seek_frame(mh, fnum);
    if(mh->header_change > 1)
    {
        if(decode_update(mh) < 0) return MPG123_ERR;
        mh->header_change = 0;
    }
    debug1("seek_frame returned: %i", b);
    if(b<0) return b;
    /* Only mh->to_ignore is TRUE. */
    if(mh->num < mh->firstframe) mh->to_decode = FALSE;
 
    mh->playnum = mh->num;
    return 0;
}

Referenced by mpg123_seek(), and mpg123_seek_frame().

get_next_frame()

static int get_next_frame ( mpg123_handle *  mh )

static

Definition at line 662 of file libmpg123.c.

{
    int change = mh->decoder_change;
    /* Ensure we got proper decoder for ignoring frames.
       Header can be changed from seeking around. But be careful: Only after at
       least one frame got read, decoder update makes sense. */
    if(mh->header_change > 1 && mh->num >= 0)
    {
        change = 1;
        mh->header_change = 0;
        debug("starting with big header change");
        if(decode_update(mh) < 0)
        return MPG123_ERR;
    }
 
    do
    {
        int b;
        /* Decode & discard some frame(s) before beginning. */
        if(mh->to_ignore && mh->num < mh->firstframe && mh->num >= mh->ignoreframe)
        {
            debug1("ignoring frame %li", (long)mh->num);
            /* Decoder structure must be current! decode_update has been called before... */
            (mh->do_layer)(mh); mh->buffer.fill = 0;
#ifndef NO_NTOM
            /* The ignored decoding may have failed. Make sure ntom stays consistent. */
            if(mh->down_sample == 3) ntom_set_ntom(mh, mh->num+1);
#endif
            mh->to_ignore = mh->to_decode = FALSE;
        }
        /* Read new frame data; possibly breaking out here for MPG123_NEED_MORE. */
        debug("read frame");
        mh->to_decode = FALSE;
        b = read_frame(mh); /* That sets to_decode only if a full frame was read. */
        debug4("read of frame %li returned %i (to_decode=%i) at sample %li", (long)mh->num, b, mh->to_decode, (long)mpg123_tell(mh));
        if(b == MPG123_NEED_MORE) return MPG123_NEED_MORE; /* need another call with data */
        else if(b <= 0)
        {
            /* More sophisticated error control? */
            if(b==0 || (mh->rdat.filelen >= 0 && mh->rdat.filepos == mh->rdat.filelen))
            { /* We simply reached the end. */
                mh->track_frames = mh->num + 1;
                debug("What about updating/checking gapless sample count here?");
                return MPG123_DONE;
            }
            else return MPG123_ERR; /* Some real error. */
        }
        /* Now, there should be new data to decode ... and also possibly new stream properties */
        if(mh->header_change > 1 || mh->decoder_change)
        {
            debug("big header or decoder change");
            change = 1;
            mh->header_change = 0;
            /* Need to update decoder structure right away since frame might need to
               be decoded on next loop iteration for properly ignoring its output. */
            if(decode_update(mh) < 0)
            return MPG123_ERR;
        }
        /* Now some accounting: Look at the numbers and decide if we want this frame. */
        ++mh->playnum;
        /* Plain skipping without decoding, only when frame is not ignored on next cycle. */
        if(mh->num < mh->firstframe || (mh->p.doublespeed && (mh->playnum % mh->p.doublespeed)))
        {
            if(!(mh->to_ignore && mh->num < mh->firstframe && mh->num >= mh->ignoreframe))
            {
                frame_skip(mh);
                /* Should one fix NtoM here or not?
                   It is not work the trouble for doublespeed, but what with leading frames? */
            }
        }
        /* Or, we are finally done and have a new frame. */
        else break;
    } while(1);
 
    /* If we reach this point, we got a new frame ready to be decoded.
       All other situations resulted in returns from the loop. */
    if(change)
    {
        if(mh->fresh)
        {
#ifdef GAPLESS
            int b=0;
            /* Prepare offsets for gapless decoding. */
            debug1("preparing gapless stuff with native rate %li", frame_freq(mh));
            frame_gapless_realinit(mh);
            frame_set_frameseek(mh, mh->num);
#endif
            mh->fresh = 0;
#ifdef GAPLESS
            /* Could this possibly happen? With a real big gapless offset... */
            if(mh->num < mh->firstframe) b = get_next_frame(mh);
            if(b < 0) return b; /* Could be error, need for more, new format... */
#endif
        }
    }
    return MPG123_OK;
}

Referenced by get_next_frame(), init_track(), mpg123_decode(), mpg123_decode_frame(), and mpg123_framebyframe_next().

init_track()

static int init_track ( mpg123_handle *  mh )

static

Definition at line 1076 of file libmpg123.c.

{
    if(track_need_init(mh))
    {
        /* Fresh track, need first frame for basic info. */
        int b = get_next_frame(mh);
        if(b < 0) return b;
    }
    return 0;
}

Referenced by mpg123_feedseek(), mpg123_framelength(), mpg123_getformat2(), mpg123_info(), mpg123_length(), mpg123_scan(), mpg123_seek(), mpg123_seek_frame(), and mpg123_timeframe().

open_fixed_post()

int open_fixed_post	(	mpg123_handle *	mh,
		int	channels,
		int	encoding
	)

Definition at line 480 of file libmpg123.c.

{
    if(!mh)
        return MPG123_BAD_HANDLE;
    long rate;
    int err = mpg123_getformat(mh, &rate, &channels, &encoding);
    if(err == MPG123_OK)
        err = mpg123_format_none(mh);
    if(err == MPG123_OK)
        err = mpg123_format(mh, rate, channels, encoding);
    if(err == MPG123_OK)
    {
        if(mh->track_frames < 1 && (mh->rdat.flags & READER_SEEKABLE))
        {
            debug("open_fixed_post: scan because we can seek and do not know track_frames");
            err = mpg123_scan(mh);
        }
    }
    if(err != MPG123_OK)
        mpg123_close(mh);
    return err;
}

open_fixed_pre()

int open_fixed_pre	(	mpg123_handle *	mh,
		int	channels,
		int	encoding
	)

Definition at line 469 of file libmpg123.c.

{
    if(!mh)
        return MPG123_BAD_HANDLE;
    mh->p.flags |= MPG123_NO_FRANKENSTEIN;
    int err = mpg123_format_none(mh);
    if(err == MPG123_OK)
        err = mpg123_format2(mh, 0, channels, encoding);
    return err;
}

zero_byte()

static int zero_byte ( mpg123_handle *  fr )

static

Definition at line 763 of file libmpg123.c.

{
#ifndef NO_8BIT
    return fr->af.encoding & MPG123_ENC_8 ? fr->conv16to8[0] : 0;
#else
    return 0; /* All normal signed formats have the zero here (even in byte form -- that may be an assumption for your funny machine...). */
#endif
}

Referenced by decode_the_frame(), test_trailing_slash(), and test_urlcacheA().

Variable Documentation

initialized

int initialized = 0

static

Definition at line 21 of file libmpg123.c.

Referenced by mpg123_init(), and mpg123_parnew().

mpg123_error

const char* mpg123_error[]

static

Definition at line 1727 of file libmpg123.c.

Referenced by mpg123_plain_strerror().