frame.h File Reference

#include <stdio.h>
#include "config.h"
#include "mpg123.h"
#include "optimize.h"
#include "id3.h"
#include "icy.h"
#include "reader.h"
#include "index.h"
#include "synths.h"

Include dependency graph for frame.h:

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

Go to the source code of this file.

Classes
struct	al_table
struct	outbuffer
struct	audioformat
struct	mpg123_pars_struct
struct	mpg123_handle_struct

Macros
#define	MAXFRAMESIZE   3456
#define	NUM_CHANNELS   2
#define	SINGLE_STEREO   -1
#define	SINGLE_LEFT   0
#define	SINGLE_RIGHT   1
#define	SINGLE_MIX   3
#define	GAPLESS_DELAY   529

Enumerations
enum	frame_state_flags { FRAME_ACCURATE = 0x1, FRAME_FRANKENSTEIN = 0x2, FRAME_FRESH_DECODER = 0x4 }

Functions
void	invalidate_format (struct audioformat *af)
void	frame_init (mpg123_handle *fr)
void	frame_init_par (mpg123_handle *fr, mpg123_pars *mp)
int	frame_outbuffer (mpg123_handle *fr)
int	frame_output_format (mpg123_handle *fr)
int	frame_buffers (mpg123_handle *fr)
int	frame_reset (mpg123_handle *fr)
int	frame_buffers_reset (mpg123_handle *fr)
void	frame_exit (mpg123_handle *fr)
int	mpg123_print_index (mpg123_handle *fr, FILE *out)
off_t	frame_index_find (mpg123_handle *fr, off_t want_frame, off_t *get_frame)
int	frame_index_setup (mpg123_handle *fr)
void	do_volume (mpg123_handle *fr, double factor)
void	do_rva (mpg123_handle *fr)
void	frame_gapless_init (mpg123_handle *fr, off_t framecount, off_t bskip, off_t eskip)
void	frame_gapless_realinit (mpg123_handle *fr)
void	frame_gapless_update (mpg123_handle *mh, off_t total_samples)
off_t	frame_expect_outsamples (mpg123_handle *fr)
void	frame_skip (mpg123_handle *fr)
off_t	frame_ins2outs (mpg123_handle *fr, off_t ins)
off_t	frame_outs (mpg123_handle *fr, off_t num)
off_t	frame_expect_outsampels (mpg123_handle *fr)
off_t	frame_offset (mpg123_handle *fr, off_t outs)
void	frame_set_frameseek (mpg123_handle *fr, off_t fe)
void	frame_set_seek (mpg123_handle *fr, off_t sp)
off_t	frame_tell_seek (mpg123_handle *fr)
int	frame_fill_toc (mpg123_handle *fr, unsigned char *in)

Macro Definition Documentation

GAPLESS_DELAY

#define GAPLESS_DELAY   529

Definition at line 390 of file frame.h.

MAXFRAMESIZE

#define MAXFRAMESIZE   3456

Definition at line 30 of file frame.h.

NUM_CHANNELS

#define NUM_CHANNELS   2

Definition at line 72 of file frame.h.

SINGLE_LEFT

#define SINGLE_LEFT   0

Definition at line 189 of file frame.h.

SINGLE_MIX

#define SINGLE_MIX   3

Definition at line 191 of file frame.h.

SINGLE_RIGHT

#define SINGLE_RIGHT   1

Definition at line 190 of file frame.h.

SINGLE_STEREO

#define SINGLE_STEREO   -1

Definition at line 188 of file frame.h.

Enumeration Type Documentation

frame_state_flags

enum frame_state_flags

Enumerator
FRAME_ACCURATE	0001 Positions are considered accurate.
FRAME_FRANKENSTEIN	0010 This stream is concatenated.
FRAME_FRESH_DECODER	0100 Decoder is fleshly initialized.

Definition at line 90 of file frame.h.

{
     FRAME_ACCURATE      = 0x1  
    ,FRAME_FRANKENSTEIN  = 0x2  
    ,FRAME_FRESH_DECODER = 0x4  
};

Function Documentation

do_rva()

void do_rva

(

mpg123_handle *

fr

)

Definition at line 1014 of file frame.c.

{
    double peak = 0;
    double gain = 0;
    double newscale;
    double rvafact = 1;
    if(get_rva(fr, &peak, &gain))
    {
        if(NOQUIET && fr->p.verbose > 1) fprintf(stderr, "Note: doing RVA with gain %f\n", gain);
        rvafact = pow(10,gain/20);
    }

    newscale = fr->p.outscale*rvafact;

    /* if peak is unknown (== 0) this check won't hurt */
    if((peak*newscale) > 1.0)
    {
        newscale = 1.0/peak;
        warning2("limiting scale value to %f to prevent clipping with indicated peak factor of %f", newscale, peak);
    }
    /* first rva setting is forced with fr->lastscale < 0 */
    if(newscale != fr->lastscale || fr->decoder_change)
    {
        debug3("changing scale value from %f to %f (peak estimated to %f)", fr->lastscale != -1 ? fr->lastscale : fr->p.outscale, newscale, (double) (newscale*peak));
        fr->lastscale = newscale;
        /* It may be too early, actually. */
        if(fr->make_decode_tables != NULL) fr->make_decode_tables(fr); /* the actual work */
    }
}

Referenced by mpg123_volume().

do_volume()

void do_volume	(	mpg123_handle *	fr,
		double	factor
	)

frame_buffers()

int frame_buffers

(

mpg123_handle *

fr

)

Definition at line 268 of file frame.c.

{
    int buffssize = 0;
    debug1("frame %p buffer", (void*)fr);
/*
    the used-to-be-static buffer of the synth functions, has some subtly different types/sizes

    2to1, 4to1, ntom, generic, i386: real[2][2][0x110]
    mmx, sse: short[2][2][0x110]
    i586(_dither): 4352 bytes; int/long[2][2][0x110]
    i486: int[2][2][17*FIR_BUFFER_SIZE]
    altivec: static real __attribute__ ((aligned (16))) buffs[4][4][0x110]

    Huh, altivec looks like fun. Well, let it be large... then, the 16 byte alignment seems to be implicit on MacOSX malloc anyway.
    Let's make a reasonable attempt to allocate enough memory...
    Keep in mind: biggest ones are i486 and altivec (mutually exclusive!), then follows i586 and normal real.
    mmx/sse use short but also real for resampling.
    Thus, minimum is 2*2*0x110*sizeof(real).
*/
    if(fr->cpu_opts.type == altivec) buffssize = 4*4*0x110*sizeof(real);
#ifdef OPT_I486
    else if(fr->cpu_opts.type == ivier) buffssize = 2*2*17*FIR_BUFFER_SIZE*sizeof(int);
#endif
    else if(fr->cpu_opts.type == ifuenf || fr->cpu_opts.type == ifuenf_dither || fr->cpu_opts.type == dreidnow)
    buffssize = 2*2*0x110*4; /* don't rely on type real, we need 4352 bytes */

    if(2*2*0x110*sizeof(real) > buffssize)
    buffssize = 2*2*0x110*sizeof(real);
    buffssize += 15; /* For 16-byte alignment (SSE likes that). */

    if(fr->rawbuffs != NULL && fr->rawbuffss != buffssize)
    {
        free(fr->rawbuffs);
        fr->rawbuffs = NULL;
    }

    if(fr->rawbuffs == NULL) fr->rawbuffs = (unsigned char*) malloc(buffssize);
    if(fr->rawbuffs == NULL) return -1;
    fr->rawbuffss = buffssize;
    fr->short_buffs[0][0] = aligned_pointer(fr->rawbuffs,short,16);
    fr->short_buffs[0][1] = fr->short_buffs[0][0] + 0x110;
    fr->short_buffs[1][0] = fr->short_buffs[0][1] + 0x110;
    fr->short_buffs[1][1] = fr->short_buffs[1][0] + 0x110;
    fr->real_buffs[0][0] = aligned_pointer(fr->rawbuffs,real,16);
    fr->real_buffs[0][1] = fr->real_buffs[0][0] + 0x110;
    fr->real_buffs[1][0] = fr->real_buffs[0][1] + 0x110;
    fr->real_buffs[1][1] = fr->real_buffs[1][0] + 0x110;
#ifdef OPT_I486
    if(fr->cpu_opts.type == ivier)
    {
        fr->int_buffs[0][0] = (int*) fr->rawbuffs;
        fr->int_buffs[0][1] = fr->int_buffs[0][0] + 17*FIR_BUFFER_SIZE;
        fr->int_buffs[1][0] = fr->int_buffs[0][1] + 17*FIR_BUFFER_SIZE;
        fr->int_buffs[1][1] = fr->int_buffs[1][0] + 17*FIR_BUFFER_SIZE;
    }
#endif
#ifdef OPT_ALTIVEC
    if(fr->cpu_opts.type == altivec)
    {
        int i,j;
        fr->areal_buffs[0][0] = (real*) fr->rawbuffs;
        for(i=0; i<4; ++i) for(j=0; j<4; ++j)
        fr->areal_buffs[i][j] = fr->areal_buffs[0][0] + (i*4+j)*0x110;
    }
#endif
    /* now the different decwins... all of the same size, actually */
    /* The MMX ones want 32byte alignment, which I'll try to ensure manually */
    {
        int decwin_size = (512+32)*sizeof(real);
#ifdef OPT_MMXORSSE
#ifdef OPT_MULTI
        if(fr->cpu_opts.class == mmxsse)
        {
#endif
            /* decwin_mmx will share, decwins will be appended ... sizeof(float)==4 */
            if(decwin_size < (512+32)*4) decwin_size = (512+32)*4;

            /* the second window + alignment zone -- we align for 32 bytes for SSE as
               requirement, 64 byte for matching cache line size (that matters!) */
            decwin_size += (512+32)*4 + 63;
            /* (512+32)*4/32 == 2176/32 == 68, so one decwin block retains alignment for 32 or 64 bytes */
#ifdef OPT_MULTI
        }
#endif
#endif
#if defined(OPT_ALTIVEC) || defined(OPT_ARM)
        /* sizeof(real) >= 4 ... yes, it could be 8, for example.
           We got it intialized to at least (512+32)*sizeof(real).*/
        decwin_size += 512*sizeof(real);
#endif
        /* Hm, that's basically realloc() ... */
        if(fr->rawdecwin != NULL && fr->rawdecwins != decwin_size)
        {
            free(fr->rawdecwin);
            fr->rawdecwin = NULL;
        }

        if(fr->rawdecwin == NULL)
        fr->rawdecwin = (unsigned char*) malloc(decwin_size);

        if(fr->rawdecwin == NULL) return -1;

        fr->rawdecwins = decwin_size;
        fr->decwin = (real*) fr->rawdecwin;
#ifdef OPT_MMXORSSE
#ifdef OPT_MULTI
        if(fr->cpu_opts.class == mmxsse)
        {
#endif
            /* align decwin, assign that to decwin_mmx, append decwins */
            /* I need to add to decwin what is missing to the next full 64 byte -- also I want to make gcc -pedantic happy... */
            fr->decwin = aligned_pointer(fr->rawdecwin,real,64);
            debug1("aligned decwin: %p", (void*)fr->decwin);
            fr->decwin_mmx = (float*)fr->decwin;
            fr->decwins = fr->decwin_mmx+512+32;
#ifdef OPT_MULTI
        }
        else debug("no decwins/decwin_mmx for that class");
#endif
#endif
    }

    /* Layer scratch buffers are of compile-time fixed size, so allocate only once. */
    if(fr->layerscratch == NULL)
    {
        /* Allocate specific layer1/2/3 buffers, so that we know they'll work for SSE. */
        size_t scratchsize = 0;
        real *scratcher;
#ifndef NO_LAYER1
        scratchsize += sizeof(real) * 2 * SBLIMIT;
#endif
#ifndef NO_LAYER2
        scratchsize += sizeof(real) * 2 * 4 * SBLIMIT;
#endif
#ifndef NO_LAYER3
        scratchsize += sizeof(real) * 2 * SBLIMIT * SSLIMIT; /* hybrid_in */
        scratchsize += sizeof(real) * 2 * SSLIMIT * SBLIMIT; /* hybrid_out */
#endif
        /*
            Now figure out correct alignment:
            We need 16 byte minimum, smallest unit of the blocks is 2*SBLIMIT*sizeof(real), which is 64*4=256. Let's do 64bytes as heuristic for cache line (as proven useful in buffs above).
        */
        fr->layerscratch = malloc(scratchsize+63);
        if(fr->layerscratch == NULL) return -1;

        /* Get aligned part of the memory, then divide it up. */
        scratcher = aligned_pointer(fr->layerscratch,real,64);
        /* Those funky pointer casts silence compilers...
           One might change the code at hand to really just use 1D arrays, but in practice, that would not make a (positive) difference. */
#ifndef NO_LAYER1
        fr->layer1.fraction = (real(*)[SBLIMIT])scratcher;
        scratcher += 2 * SBLIMIT;
#endif
#ifndef NO_LAYER2
        fr->layer2.fraction = (real(*)[4][SBLIMIT])scratcher;
        scratcher += 2 * 4 * SBLIMIT;
#endif
#ifndef NO_LAYER3
        fr->layer3.hybrid_in = (real(*)[SBLIMIT][SSLIMIT])scratcher;
        scratcher += 2 * SBLIMIT * SSLIMIT;
        fr->layer3.hybrid_out = (real(*)[SSLIMIT][SBLIMIT])scratcher;
        scratcher += 2 * SSLIMIT * SBLIMIT;
#endif
        /* Note: These buffers don't need resetting here. */
    }

    /* Only reset the buffers we created just now. */
    frame_decode_buffers_reset(fr);

    debug1("frame %p buffer done", (void*)fr);
    return 0;
}

frame_buffers_reset()

int frame_buffers_reset

(

mpg123_handle *

fr

)

Definition at line 441 of file frame.c.

{
    fr->buffer.fill = 0; /* hm, reset buffer fill... did we do a flush? */
    fr->bsnum = 0;
    /* Wondering: could it be actually _wanted_ to retain buffer contents over different files? (special gapless / cut stuff) */
    fr->bsbuf = fr->bsspace[1];
    fr->bsbufold = fr->bsbuf;
    fr->bitreservoir = 0;
    frame_decode_buffers_reset(fr);
    memset(fr->bsspace, 0, 2*(MAXFRAMESIZE+512));
    memset(fr->ssave, 0, 34);
    fr->hybrid_blc[0] = fr->hybrid_blc[1] = 0;
    memset(fr->hybrid_block, 0, sizeof(real)*2*2*SBLIMIT*SSLIMIT);
    return 0;
}

Referenced by frame_reset().

frame_exit()

void frame_exit

(

mpg123_handle *

fr

)

Definition at line 593 of file frame.c.

{
    if(fr->buffer.rdata != NULL)
    {
        debug1("freeing buffer at %p", (void*)fr->buffer.rdata);
        free(fr->buffer.rdata);
    }
    fr->buffer.rdata = NULL;
    frame_free_buffers(fr);
    frame_free_toc(fr);
#ifdef FRAME_INDEX
    fi_exit(&fr->index);
#endif
#ifdef OPT_DITHER
    if(fr->dithernoise != NULL)
    {
        free(fr->dithernoise);
        fr->dithernoise = NULL;
    }
#endif
    exit_id3(fr);
    clear_icy(&fr->icy);
    /* Clean up possible mess from LFS wrapper. */
    if(fr->wrapperclean != NULL)
    {
        fr->wrapperclean(fr->wrapperdata);
        fr->wrapperdata = NULL;
    }
#ifndef NO_FEEDER
    bc_cleanup(&fr->rdat.buffer);
#endif
}

frame_expect_outsampels()

off_t frame_expect_outsampels

(

mpg123_handle *

fr

)

frame_expect_outsamples()

off_t frame_expect_outsamples

(

mpg123_handle *

fr

)

Definition at line 797 of file frame.c.

{
    off_t outs = 0;
    switch(fr->down_sample)
    {
        case 0:
#       ifndef NO_DOWNSAMPLE
        case 1:
        case 2:
#       endif
            outs = fr->spf>>fr->down_sample;
        break;
#ifndef NO_NTOM
        case 3: outs = ntom_frame_outsamples(fr); break;
#endif
        default: if(NOQUIET)
            merror( "Bad down_sample (%i) ... should not be possible!!"
            ,   fr->down_sample );
    }
    return outs;
}

frame_fill_toc()

int frame_fill_toc	(	mpg123_handle *	fr,
		unsigned char *	in
	)

Definition at line 473 of file frame.c.

{
    if(fr->xing_toc == NULL) fr->xing_toc = malloc(100);
    if(fr->xing_toc != NULL)
    {
        memcpy(fr->xing_toc, in, 100);
#ifdef DEBUG
        debug("Got a TOC! Showing the values...");
        {
            int i;
            for(i=0; i<100; ++i)
            debug2("entry %i = %i", i, fr->xing_toc[i]);
        }
#endif
        return TRUE;
    }
    return FALSE;
}

frame_gapless_init()

void frame_gapless_init	(	mpg123_handle *	fr,
		off_t	framecount,
		off_t	bskip,
		off_t	eskip
	)

Referenced by check_lame_tag(), and frame_fixed_reset().

frame_gapless_realinit()

void frame_gapless_realinit

(

mpg123_handle *

fr

)

Referenced by get_next_frame().

frame_gapless_update()

void frame_gapless_update	(	mpg123_handle *	mh,
		off_t	total_samples
	)

Referenced by mpg123_scan().

frame_index_find()

off_t frame_index_find	(	mpg123_handle *	fr,
		off_t	want_frame,
		off_t *	get_frame
	)

Definition at line 706 of file frame.c.

{
    /* default is file start if no index position */
    off_t gopos = 0;
    *get_frame = 0;
#ifdef FRAME_INDEX
    /* Possibly use VBRI index, too? I'd need an example for this... */
    if(fr->index.fill)
    {
        /* find in index */
        size_t fi;
        /* at index fi there is frame step*fi... */
        fi = want_frame/fr->index.step;
        if(fi >= fr->index.fill) /* If we are beyond the end of frame index...*/
        {
            /* When fuzzy seek is allowed, we have some limited tolerance for the frames we want to read rather then jump over. */
            if(fr->p.flags & MPG123_FUZZY && want_frame - (fr->index.fill-1)*fr->index.step > 10)
            {
                gopos = frame_fuzzy_find(fr, want_frame, get_frame);
                if(gopos > fr->audio_start) return gopos; /* Only in that case, we have a useful guess. */
                /* Else... just continue, fuzzyness didn't help. */
            }
            /* Use the last available position, slowly advancing from that one. */
            fi = fr->index.fill - 1;
        }
        /* We have index position, that yields frame and byte offsets. */
        *get_frame = fi*fr->index.step;
        gopos = fr->index.data[fi];
        fr->state_flags |= FRAME_ACCURATE; /* When using the frame index, we are accurate. */
    }
    else
    {
#endif
        if(fr->p.flags & MPG123_FUZZY)
        return frame_fuzzy_find(fr, want_frame, get_frame);
        /* A bit hackish here... but we need to be fresh when looking for the first header again. */
        fr->firsthead = 0;
        fr->oldhead = 0;
#ifdef FRAME_INDEX
    }
#endif
    debug2("index: 0x%lx for frame %li", (unsigned long)gopos, (long) *get_frame);
    return gopos;
}

frame_index_setup()

int frame_index_setup

(

mpg123_handle *

fr

)

Referenced by frame_init_par(), and mpg123_param().

frame_init()

void frame_init

(

mpg123_handle *

fr

)

Definition at line 70 of file frame.c.

{
    frame_init_par(fr, NULL);
}

frame_init_par()

void frame_init_par	(	mpg123_handle *	fr,
		mpg123_pars *	mp
	)

Definition at line 75 of file frame.c.

{
    fr->own_buffer = TRUE;
    fr->buffer.data = NULL;
    fr->buffer.rdata = NULL;
    fr->buffer.fill = 0;
    fr->buffer.size = 0;
    fr->rawbuffs = NULL;
    fr->rawbuffss = 0;
    fr->rawdecwin = NULL;
    fr->rawdecwins = 0;
#ifndef NO_8BIT
    fr->conv16to8_buf = NULL;
#endif
#ifdef OPT_DITHER
    fr->dithernoise = NULL;
#endif
    fr->layerscratch = NULL;
    fr->xing_toc = NULL;
    fr->cpu_opts.type = defdec();
    fr->cpu_opts.class = decclass(fr->cpu_opts.type);
#ifndef NO_NTOM
    /* these two look unnecessary, check guarantee for synth_ntom_set_step (in control_generic, even)! */
    fr->ntom_val[0] = NTOM_MUL>>1;
    fr->ntom_val[1] = NTOM_MUL>>1;
    fr->ntom_step = NTOM_MUL;
#endif
    /* unnecessary: fr->buffer.size = fr->buffer.fill = 0; */
    mpg123_reset_eq(fr);
    init_icy(&fr->icy);
    init_id3(fr);
    /* frame_outbuffer is missing... */
    /* frame_buffers is missing... that one needs cpu opt setting! */
    /* after these... frame_reset is needed before starting full decode */
    invalidate_format(&fr->af);
    fr->rdat.r_read = NULL;
    fr->rdat.r_lseek = NULL;
    fr->rdat.iohandle = NULL;
    fr->rdat.r_read_handle = NULL;
    fr->rdat.r_lseek_handle = NULL;
    fr->rdat.cleanup_handle = NULL;
    fr->wrapperdata = NULL;
    fr->wrapperclean = NULL;
    fr->decoder_change = 1;
    fr->err = MPG123_OK;
    if(mp == NULL) frame_default_pars(&fr->p);
    else memcpy(&fr->p, mp, sizeof(struct mpg123_pars_struct));

#ifndef NO_FEEDER
    bc_prepare(&fr->rdat.buffer, fr->p.feedpool, fr->p.feedbuffer);
#endif

    fr->down_sample = 0; /* Initialize to silence harmless errors when debugging. */
    fr->id3v2_raw = NULL;
    frame_fixed_reset(fr); /* Reset only the fixed data, dynamic buffers are not there yet! */
    fr->synth = NULL;
    fr->synth_mono = NULL;
    fr->make_decode_tables = NULL;
#ifdef FRAME_INDEX
    fi_init(&fr->index);
    frame_index_setup(fr); /* Apply the size setting. */
#endif
#ifndef NO_MOREINFO
    fr->pinfo = NULL;
#endif
}

Referenced by frame_init().

frame_ins2outs()

off_t frame_ins2outs	(	mpg123_handle *	fr,
		off_t	ins
	)

Definition at line 751 of file frame.c.

{
    off_t outs = 0;
    switch(fr->down_sample)
    {
        case 0:
#       ifndef NO_DOWNSAMPLE
        case 1:
        case 2:
#       endif
            outs = ins>>fr->down_sample;
        break;
#       ifndef NO_NTOM
        case 3: outs = ntom_ins2outs(fr, ins); break;
#       endif
        default: if(NOQUIET)
            merror( "Bad down_sample (%i) ... should not be possible!!"
            ,   fr->down_sample );
    }
    return outs;
}

frame_offset()

off_t frame_offset	(	mpg123_handle *	fr,
		off_t	outs
	)

Definition at line 819 of file frame.c.

{
    off_t num = 0;
    switch(fr->down_sample)
    {
        case 0:
#       ifndef NO_DOWNSAMPLE
        case 1:
        case 2:
#       endif
            num = outs/(fr->spf>>fr->down_sample);
        break;
#ifndef NO_NTOM
        case 3: num = ntom_frameoff(fr, outs); break;
#endif
        default: if(NOQUIET)
            error("Bad down_sample ... should not be possible!!");
    }
    return num;
}

Referenced by frame_set_frameseek(), and frame_set_seek().

frame_outbuffer()

int frame_outbuffer

(

mpg123_handle *

fr

)

Definition at line 183 of file frame.c.

{
    size_t size = fr->outblock;
    if(!fr->own_buffer)
    {
        if(fr->buffer.size < size)
        {
            fr->err = MPG123_BAD_BUFFER;
            if(NOQUIET)
                merror( "have external buffer of size %"SIZE_P", need %"SIZE_P
                ,   (size_p)fr->buffer.size, (size_p)size );
            return MPG123_ERR;
        }
    }

    debug1("need frame buffer of %"SIZE_P, (size_p)size);
    if(fr->buffer.rdata != NULL && fr->buffer.size != size)
    {
        free(fr->buffer.rdata);
        fr->buffer.rdata = NULL;
    }
    fr->buffer.size = size;
    fr->buffer.data = NULL;
    /* be generous: use 16 byte alignment */
    if(fr->buffer.rdata == NULL) fr->buffer.rdata = (unsigned char*) malloc(fr->buffer.size+15);
    if(fr->buffer.rdata == NULL)
    {
        fr->err = MPG123_OUT_OF_MEM;
        return MPG123_ERR;
    }
    fr->buffer.data = aligned_pointer(fr->buffer.rdata, unsigned char*, 16);
    fr->own_buffer = TRUE;
    fr->buffer.fill = 0;
    return MPG123_OK;
}

frame_output_format()

int frame_output_format

(

mpg123_handle *

fr

)

Definition at line 226 of file format.c.

{
    struct audioformat nf;
    int f0=0;
    int f2=MPG123_ENCODINGS+1; // Include all encodings by default.
    mpg123_pars *p = &fr->p;
    int try_float = (p->flags & MPG123_FLOAT_FALLBACK) ? 0 : 1;
    /* initialize new format, encoding comes later */
    nf.channels = fr->stereo;

    // I intended the forcing stuff to be weaved into the format support table,
    // but this probably will never happen, as this would change library behaviour.
    // One could introduce an additional effective format table that takes for
    // forcings into account, but that would have to be updated on any flag
    // change. Tedious.
    if(p->flags & MPG123_FORCE_8BIT)
    {
        f0 = enc_8bit_range[0];
        f2 = enc_8bit_range[1];
    }
    if(p->flags & MPG123_FORCE_FLOAT)
    {
        try_float = 1;
        f0 = enc_float_range[0];
        f2 = enc_float_range[1];
    }

    /* force stereo is stronger */
    if(p->flags & MPG123_FORCE_MONO)   nf.channels = 1;
    if(p->flags & MPG123_FORCE_STEREO) nf.channels = 2;

    // Strategy update: Avoid too early triggering of the NtoM decoder.
    // Main target is the native rate, with any encoding.
    // Then, native rate with any channel count and any encoding.
    // Then, it's down_sample from native rate.
    // As last resort: NtoM rate.
    // So the priority is 1. rate 2. channels 3. encoding.
    // As encodings go, 16 bit is tranditionally preferred as efficient choice.
    // Next in line are wider float and integer encodings, then 8 bit as
    // last resort.

#ifndef NO_NTOM
    if(p->force_rate)
    {
        if(enc_chan_fit(p, p->force_rate, &nf, f0, f2, try_float))
            goto end;
        // Keep the order consistent if float is considered fallback only.
        if(!try_float &&
            enc_chan_fit(p, p->force_rate, &nf, f0, f2, TRUE))
                goto end;

        merror( "Unable to set up output format! Constraints: %s%s%liHz."
        ,   ( p->flags & MPG123_FORCE_STEREO ? "stereo, " :
                (p->flags & MPG123_FORCE_MONO ? "mono, " : "") )
        ,   ( p->flags & MPG123_FORCE_FLOAT ? "float, " :
                (p->flags & MPG123_FORCE_8BIT ? "8bit, " : "") )
        ,   p->force_rate );
/*      if(NOQUIET && p->verbose <= 1) print_capabilities(fr); */

        fr->err = MPG123_BAD_OUTFORMAT;
        return -1;
    }
#endif
    // Native decoder rate first.
    if(enc_chan_fit(p, frame_freq(fr)>>p->down_sample, &nf, f0, f2, try_float))
        goto end;
    // Then downsamplings.
    if(p->flags & MPG123_AUTO_RESAMPLE && p->down_sample < 2)
    {
        if(enc_chan_fit( p, frame_freq(fr)>>(p->down_sample+1), &nf
        ,   f0, f2, try_float ))
            goto end;
        if(p->down_sample < 1 && enc_chan_fit( p, frame_freq(fr)>>2, &nf
        ,   f0, f2, try_float ))
            goto end;
    }
    // And again the whole deal with float fallback.
    if(!try_float)
    {
        if(enc_chan_fit(p, frame_freq(fr)>>p->down_sample, &nf, f0, f2, TRUE))
            goto end;
        // Then downsamplings.
        if(p->flags & MPG123_AUTO_RESAMPLE && p->down_sample < 2)
        {
            if(enc_chan_fit( p, frame_freq(fr)>>(p->down_sample+1), &nf
            ,   f0, f2, TRUE ))
                goto end;
            if(p->down_sample < 1 && enc_chan_fit( p, frame_freq(fr)>>2, &nf
            ,   f0, f2, TRUE ))
                goto end;
        }
    }
#ifndef NO_NTOM
    // Try to find any rate that works and resample using NtoM hackery.
    if(  p->flags & MPG123_AUTO_RESAMPLE && fr->p.down_sample == 0)
    {
        int i;
        int rn = rate2num(p, frame_freq(fr));
        int rrn;
        if(rn < 0) return 0;
        /* Try higher rates first. */
        for(rrn=rn+1; rrn<MPG123_RATES; ++rrn)
            if(enc_chan_fit(p, my_rates[rrn], &nf, f0, f2, try_float))
                goto end;
        /* Then lower rates. */
        for(i=f0;i<f2;i++) for(rrn=rn-1; rrn>=0; --rrn)
            if(enc_chan_fit(p, my_rates[rrn], &nf, f0, f2, try_float))
                goto end;
        // And again for float fallback.
        if(!try_float)
        {
            /* Try higher rates first. */
            for(rrn=rn+1; rrn<MPG123_RATES; ++rrn)
                if(enc_chan_fit(p, my_rates[rrn], &nf, f0, f2, TRUE))
                    goto end;
            /* Then lower rates. */
            for(i=f0;i<f2;i++) for(rrn=rn-1; rrn>=0; --rrn)
                if(enc_chan_fit(p, my_rates[rrn], &nf, f0, f2, TRUE))
                    goto end;
        }
    }
#endif

    /* Here is the _bad_ end. */
    merror( "Unable to set up output format! Constraints: %s%s%li, %li or %liHz."
    ,   ( p->flags & MPG123_FORCE_STEREO ? "stereo, " :
            (p->flags & MPG123_FORCE_MONO ? "mono, " : "") )
    ,   ( p->flags & MPG123_FORCE_FLOAT ? "float, " :
            (p->flags & MPG123_FORCE_8BIT ? "8bit, " : "") )
    ,   frame_freq(fr),  frame_freq(fr)>>1, frame_freq(fr)>>2 );
/*  if(NOQUIET && p->verbose <= 1) print_capabilities(fr); */

    fr->err = MPG123_BAD_OUTFORMAT;
    return -1;

end: /* Here is the _good_ end. */
    /* we had a successful match, now see if there's a change */
    if(nf.rate == fr->af.rate && nf.channels == fr->af.channels && nf.encoding == fr->af.encoding)
    {
        debug2("Old format with %i channels, and FORCE_MONO=%li", nf.channels, p->flags & MPG123_FORCE_MONO);
        return 0; /* the same format as before */
    }
    else /* a new format */
    {
        debug1("New format with %i channels!", nf.channels);
        fr->af.rate = nf.rate;
        fr->af.channels = nf.channels;
        fr->af.encoding = nf.encoding;
        /* Cache the size of one sample in bytes, for ease of use. */
        fr->af.encsize = mpg123_encsize(fr->af.encoding);
        if(fr->af.encsize < 1)
        {
            error1("Some unknown encoding??? (%i)", fr->af.encoding);

            fr->err = MPG123_BAD_OUTFORMAT;
            return -1;
        }
        /* Set up the decoder synth format. Might differ. */
#ifdef NO_SYNTH32
        /* Without high-precision synths, 16 bit signed is the basis for
           everything higher than 8 bit. */
        if(fr->af.encsize > 2)
        fr->af.dec_enc = MPG123_ENC_SIGNED_16;
        else
        {
#endif
            switch(fr->af.encoding)
            {
#ifndef NO_32BIT
            case MPG123_ENC_SIGNED_24:
            case MPG123_ENC_UNSIGNED_24:
            case MPG123_ENC_UNSIGNED_32:
                fr->af.dec_enc = MPG123_ENC_SIGNED_32;
            break;
#endif
#ifndef NO_16BIT
            case MPG123_ENC_UNSIGNED_16:
                fr->af.dec_enc = MPG123_ENC_SIGNED_16;
            break;
#endif
            default:
                fr->af.dec_enc = fr->af.encoding;
            }
#ifdef NO_SYNTH32
        }
#endif
        fr->af.dec_encsize = mpg123_encsize(fr->af.dec_enc);
        return 1;
    }
}

frame_outs()

off_t frame_outs	(	mpg123_handle *	fr,
		off_t	num
	)

Definition at line 773 of file frame.c.

{
    off_t outs = 0;
    switch(fr->down_sample)
    {
        case 0:
#       ifndef NO_DOWNSAMPLE
        case 1:
        case 2:
#       endif
            outs = (fr->spf>>fr->down_sample)*num;
        break;
#ifndef NO_NTOM
        case 3: outs = ntom_frmouts(fr, num); break;
#endif
        default: if(NOQUIET)
            merror( "Bad down_sample (%i) ... should not be possible!!"
            ,   fr->down_sample );
    }
    return outs;
}

Referenced by frame_set_frameseek(), and frame_set_seek().

frame_reset()

int frame_reset

(

mpg123_handle *

fr

)

Definition at line 494 of file frame.c.

{
    frame_buffers_reset(fr);
    frame_fixed_reset(fr);
    frame_free_toc(fr);
#ifdef FRAME_INDEX
    fi_reset(&fr->index);
#endif

    return 0;
}

frame_set_frameseek()

void frame_set_frameseek	(	mpg123_handle *	fr,
		off_t	fe
	)

Definition at line 913 of file frame.c.

{
    fr->firstframe = fe;
#ifdef GAPLESS
    if(fr->p.flags & MPG123_GAPLESS && fr->gapless_frames > 0)
    {
        /* Take care of the beginning... */
        off_t beg_f = frame_offset(fr, fr->begin_os);
        if(fe <= beg_f)
        {
            fr->firstframe = beg_f;
            fr->firstoff   = fr->begin_os - frame_outs(fr, beg_f);
        }
        else fr->firstoff = 0;
        /* The end is set once for a track at least, on the frame_set_frameseek called in get_next_frame() */
        if(fr->end_os > 0)
        {
            fr->lastframe  = frame_offset(fr,fr->end_os);
            fr->lastoff    = fr->end_os - frame_outs(fr, fr->lastframe);
        } else {fr->lastframe = -1; fr->lastoff = 0; }
    } else { fr->firstoff = fr->lastoff = 0; fr->lastframe = -1; }
#endif
    fr->ignoreframe = ignoreframe(fr);
#ifdef GAPLESS
    debug5("frame_set_frameseek: begin at %li frames and %li samples, end at %li and %li; ignore from %li",
           (long) fr->firstframe, (long) fr->firstoff,
           (long) fr->lastframe,  (long) fr->lastoff, (long) fr->ignoreframe);
#else
    debug3("frame_set_frameseek: begin at %li frames, end at %li; ignore from %li",
           (long) fr->firstframe, (long) fr->lastframe, (long) fr->ignoreframe);
#endif
}

frame_set_seek()

void frame_set_seek	(	mpg123_handle *	fr,
		off_t	sp
	)

Definition at line 955 of file frame.c.

{
    fr->firstframe = frame_offset(fr, sp);
    debug1("frame_set_seek: from %"OFF_P, fr->num);
#ifndef NO_NTOM
    if(fr->down_sample == 3) ntom_set_ntom(fr, fr->firstframe);
#endif
    fr->ignoreframe = ignoreframe(fr);
#ifdef GAPLESS /* The sample offset is used for non-gapless mode, too! */
    fr->firstoff = sp - frame_outs(fr, fr->firstframe);
    debug5("frame_set_seek: begin at %li frames and %li samples, end at %li and %li; ignore from %li",
           (long) fr->firstframe, (long) fr->firstoff,
           (long) fr->lastframe,  (long) fr->lastoff, (long) fr->ignoreframe);
#else
    debug3("frame_set_seek: begin at %li frames, end at %li; ignore from %li",
           (long) fr->firstframe, (long) fr->lastframe, (long) fr->ignoreframe);
#endif
}

frame_skip()

void frame_skip

(

mpg123_handle *

fr

)

Definition at line 946 of file frame.c.

{
#ifndef NO_LAYER3
    if(fr->lay == 3) set_pointer(fr, 1, 512);
#endif
}

frame_tell_seek()

off_t frame_tell_seek

(

mpg123_handle *

fr

)

invalidate_format()

void invalidate_format

(

struct audioformat *

af

)

Definition at line 550 of file format.c.

{
    af->encoding = 0;
    af->rate     = 0;
    af->channels = 0;
}

mpg123_print_index()

int mpg123_print_index	(	mpg123_handle *	fr,
		FILE *	out
	)