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, 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 890 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 74 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 79 of file parse.c.

{
    return freqs[fr->sampling_frequency];
}

get_songlen()

int get_songlen	(	mpg123_handle *	fr,
		int	no
	)

Definition at line 975 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 492 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;

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 = 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 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 */
        if((ret=fr->rd->read_frame_body(fr,newbuf,fr->framesize))<0)
        {
            /* if failed: flip back */
            debug("need more?");
            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);
    }

  fr->bitindex = 0;
  fr->wordpointer = (unsigned char *) fr->bsbuf;
    /* 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,
		long	backstep
	)

Definition at line 879 of file parse.c.

{
    fr->wordpointer = fr->bsbuf + fr->ssize - backstep;
    if (backstep)
    memcpy(fr->wordpointer,fr->bsbufold+fr->fsizeold-backstep,backstep);

    fr->bitindex = 0; 
}

time_to_frame()

long time_to_frame	(	mpg123_handle *	fr,
		double	seconds
	)