parse.h File Reference

#include "frame.h"

Include dependency graph for parse.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	read_frame_init (mpg123_handle *fr)
int	frame_bitrate (mpg123_handle *fr)
long	frame_freq (mpg123_handle *fr)
int	read_frame_recover (mpg123_handle *fr)
int	read_frame (mpg123_handle *fr)
void	set_pointer (mpg123_handle *fr, int part2, long backstep)
int	position_info (mpg123_handle *fr, unsigned long no, long buffsize, unsigned long *frames_left, double *current_seconds, double *seconds_left)
double	compute_bpf (mpg123_handle *fr)
long	time_to_frame (mpg123_handle *fr, double seconds)
int	get_songlen (mpg123_handle *fr, int no)

Function Documentation

compute_bpf()

double compute_bpf

(

mpg123_handle *

fr

)

Definition at line 968 of file parse.c.

{
    return (fr->framesize > 0) ? fr->framesize + 4.0 : 1.0;
}

Referenced by get_songlen(), mpg123_position(), and read_frame().

frame_bitrate()

int frame_bitrate

(

mpg123_handle *

fr

)

Definition at line 80 of file parse.c.

{
    return tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index];
}

frame_freq()

long frame_freq

(

mpg123_handle *

fr

)

Definition at line 85 of file parse.c.

{
    return freqs[fr->sampling_frequency];
}

get_songlen()

int get_songlen	(	mpg123_handle *	fr,
		int	no
	)

Definition at line 1053 of file parse.c.

{
    double tpf;

    if(!fr)
        return 0;

    if(no < 0) {
        if(!fr->rd || fr->rdat.filelen < 0)
            return 0;
        no = (int) ((double) fr->rdat.filelen / compute_bpf(fr));
    }

    tpf = mpg123_tpf(fr);
    return (int) (no*tpf);
}

position_info()

int position_info	(	mpg123_handle *	fr,
		unsigned long	no,
		long	buffsize,
		unsigned long *	frames_left,
		double *	current_seconds,
		double *	seconds_left
	)

read_frame()

int read_frame

(

mpg123_handle *

fr

)

Definition at line 500 of file parse.c.

{
    /* TODO: rework this thing */
    int freeformat_count = 0;
    unsigned long newhead;
    off_t framepos;
    int ret;
    /* stuff that needs resetting if complete frame reading fails */
    int oldsize  = fr->framesize;
    int oldphase = fr->halfphase;

    /* The counter for the search-first-header loop.
       It is persistent outside the loop to prevent seemingly endless loops
       when repeatedly headers are found that do not have valid followup headers. */
    long headcount = 0;

    fr->fsizeold=fr->framesize;       /* for Layer3 */

    if(halfspeed_do(fr) == 1) return 1;

    /* From now on, old frame data is tainted by parsing attempts. */
    fr->to_decode = fr->to_ignore = FALSE;

    if( fr->p.flags & MPG123_NO_FRANKENSTEIN &&
        ( (fr->track_frames > 0 && fr->num >= fr->track_frames-1)
#ifdef GAPLESS
        || (fr->gapless_frames > 0 && fr->num >= fr->gapless_frames-1)
#endif
        ) )
    {
        mdebug( "stopping parsing at %"OFF_P
            " frames as indicated fixed track length"
        ,   (off_p)fr->num+1 );
        return 0;
    }

read_again:
    /* In case we are looping to find a valid frame, discard any buffered data before the current position.
       This is essential to prevent endless looping, always going back to the beginning when feeder buffer is exhausted. */
    if(fr->rd->forget != NULL) fr->rd->forget(fr);

    debug2("trying to get frame %"OFF_P" at %"OFF_P, (off_p)fr->num+1, (off_p)fr->rd->tell(fr));
    if((ret = fr->rd->head_read(fr,&newhead)) <= 0){ debug1("need more? (%i)", ret); goto read_frame_bad;}

init_resync:

#ifdef SKIP_JUNK
    if(!fr->firsthead && !head_check(newhead))
    {
        ret = skip_junk(fr, &newhead, &headcount);
        JUMP_CONCLUSION(ret);
    }
#endif

    ret = head_check(newhead);
    if(ret) ret = decode_header(fr, newhead, &freeformat_count);

    JUMP_CONCLUSION(ret); /* That only continues for ret == PARSE_BAD or PARSE_GOOD. */
    if(ret == PARSE_BAD)
    { /* Header was not good. */
        ret = wetwork(fr, &newhead); /* Messy stuff, handle junk, resync ... */
        JUMP_CONCLUSION(ret);
        /* Normally, we jumped already. If for some reason everything's fine to continue, do continue. */
        if(ret != PARSE_GOOD) goto read_frame_bad;
    }

    if(!fr->firsthead)
    {
        ret = fr->p.flags & MPG123_NO_READAHEAD
        ?   PARSE_GOOD
        :   do_readahead(fr, newhead);
        /* readahead can fail mit NEED_MORE, in which case we must also make the just read header available again for next go */
        if(ret < 0) fr->rd->back_bytes(fr, 4);
        JUMP_CONCLUSION(ret);
    }

    /* Now we should have our valid header and proceed to reading the frame. */

    if(fr->p.flags & MPG123_NO_FRANKENSTEIN)
    {
        if(fr->firsthead && !head_compatible(fr->firsthead, newhead))
        {
            mdebug( "stopping before reading frame %"OFF_P
                " as its header indicates Frankenstein coming for you", (off_p)fr->num );
            return 0;
        }
    }

    /* if filepos is invalid, so is framepos */
    framepos = fr->rd->tell(fr) - 4;
    /* flip/init buffer for Layer 3 */
    {
        unsigned char *newbuf = fr->bsspace[fr->bsnum]+512;
        /* read main data into memory */
        debug2("read frame body of %i at %"OFF_P, fr->framesize, framepos+4);
        if((ret=fr->rd->read_frame_body(fr,newbuf,fr->framesize))<0)
        {
            /* if failed: flip back */
            debug1("%s", ret == MPG123_NEED_MORE ? "need more" : "read error");
            goto read_frame_bad;
        }
        fr->bsbufold = fr->bsbuf;
        fr->bsbuf = newbuf;
    }
    fr->bsnum = (fr->bsnum + 1) & 1;

    if(!fr->firsthead)
    {
        fr->firsthead = newhead; /* _now_ it's time to store it... the first real header */
        /* This is the first header of our current stream segment.
           It is only the actual first header of the whole stream when fr->num is still below zero!
           Think of resyncs where firsthead has been reset for format flexibility. */
        if(fr->num < 0)
        {
            fr->audio_start = framepos;
            /* Only check for LAME  tag at beginning of whole stream
               ... when there indeed is one in between, it's the user's problem. */
            if(fr->lay == 3 && check_lame_tag(fr) == 1)
            { /* ...in practice, Xing/LAME tags are layer 3 only. */
                if(fr->rd->forget != NULL) fr->rd->forget(fr);

                fr->oldhead = 0;
                goto read_again;
            }
            /* now adjust volume */
            do_rva(fr);
        }

        debug2("fr->firsthead: %08lx, audio_start: %li", fr->firsthead, (long int)fr->audio_start);
    }

    set_pointer(fr, 0, 0);

    /* Question: How bad does the floating point value get with repeated recomputation?
       Also, considering that we can play the file or parts of many times. */
    if(++fr->mean_frames != 0)
    {
        fr->mean_framesize = ((fr->mean_frames-1)*fr->mean_framesize+compute_bpf(fr)) / fr->mean_frames ;
    }
    ++fr->num; /* 0 for first frame! */
    debug4("Frame %"OFF_P" %08lx %i, next filepos=%"OFF_P,
    (off_p)fr->num, newhead, fr->framesize, (off_p)fr->rd->tell(fr));
    if(!(fr->state_flags & FRAME_FRANKENSTEIN) && (
        (fr->track_frames > 0 && fr->num >= fr->track_frames)
#ifdef GAPLESS
        || (fr->gapless_frames > 0 && fr->num >= fr->gapless_frames)
#endif
    ))
    {
        fr->state_flags |= FRAME_FRANKENSTEIN;
        if(NOQUIET) fprintf(stderr, "\nWarning: Encountered more data after announced end of track (frame %"OFF_P"/%"OFF_P"). Frankenstein!\n", (off_p)fr->num,
#ifdef GAPLESS
        fr->gapless_frames > 0 ? (off_p)fr->gapless_frames :
#endif
        (off_p)fr->track_frames);
    }

    halfspeed_prepare(fr);

    /* index the position */
    fr->input_offset = framepos;
#ifdef FRAME_INDEX
    /* Keep track of true frame positions in our frame index.
       but only do so when we are sure that the frame number is accurate... */
    if((fr->state_flags & FRAME_ACCURATE) && FI_NEXT(fr->index, fr->num))
    fi_add(&fr->index, framepos);
#endif

    if(fr->silent_resync > 0) --fr->silent_resync;

    if(fr->rd->forget != NULL) fr->rd->forget(fr);

    fr->to_decode = fr->to_ignore = TRUE;
    if(fr->error_protection) fr->crc = getbits(fr, 16); /* skip crc */

    /*
        Let's check for header change after deciding that the new one is good
        and actually having read a frame.

        header_change > 1: decoder structure has to be updated
        Preserve header_change value from previous runs if it is serious.
        If we still have a big change pending, it should be dealt with outside,
        fr->header_change set to zero afterwards.
    */
    if(fr->header_change < 2)
    {
        fr->header_change = 2; /* output format change is possible... */
        if(fr->oldhead)        /* check a following header for change */
        {
            if(fr->oldhead == newhead) fr->header_change = 0;
            else
            /* Headers that match in this test behave the same for the outside world.
               namely: same decoding routines, same amount of decoded data. */
            if(head_compatible(fr->oldhead, newhead))
            fr->header_change = 1;
            else
            {
                fr->state_flags |= FRAME_FRANKENSTEIN;
                if(NOQUIET)
                fprintf(stderr, "\nWarning: Big change (MPEG version, layer, rate). Frankenstein stream?\n");
            }
        }
        else if(fr->firsthead && !head_compatible(fr->firsthead, newhead))
        {
            fr->state_flags |= FRAME_FRANKENSTEIN;
            if(NOQUIET)
            fprintf(stderr, "\nWarning: Big change from first (MPEG version, layer, rate). Frankenstein stream?\n");
        }
    }

    fr->oldhead = newhead;

    return 1;
read_frame_bad:
    /* Also if we searched for valid data in vein, we can forget skipped data.
       Otherwise, the feeder would hold every dead old byte in memory until the first valid frame! */
    if(fr->rd->forget != NULL) fr->rd->forget(fr);

    fr->silent_resync = 0;
    if(fr->err == MPG123_OK) fr->err = MPG123_ERR_READER;
    fr->framesize = oldsize;
    fr->halfphase = oldphase;
    /* That return code might be inherited from some feeder action, or reader error. */
    return ret;
}

read_frame_init()

int read_frame_init

(

mpg123_handle *

fr

)

read_frame_recover()

int read_frame_recover

(

mpg123_handle *

fr

)

set_pointer()

void set_pointer	(	mpg123_handle *	fr,
		int	part2,
		long	backstep
	)

Definition at line 940 of file parse.c.

{
    fr->bitindex = 0;
    if(fr->lay == 3)
    {
        if(part2)
        {
            fr->wordpointer = fr->bsbuf + fr->ssize - backstep;
            if(backstep)
                memcpy( fr->wordpointer, fr->bsbufold+fr->fsizeold-backstep
                ,   backstep );
            fr->bits_avail = (long)(fr->framesize - fr->ssize + backstep)*8;
        }
        else
        {
            fr->wordpointer = fr->bsbuf;
            fr->bits_avail  = fr->ssize*8;
        }
    }
    else
    {
        fr->wordpointer = fr->bsbuf;
        fr->bits_avail  = fr->framesize*8;
    }
}

Referenced by halfspeed_do(), and read_frame().

time_to_frame()

long time_to_frame	(	mpg123_handle *	fr,
		double	seconds
	)