ntom.c File Reference

#include "mpg123lib_intern.h"
#include "debug.h"

Include dependency graph for ntom.c:

Go to the source code of this file.

Macros
#define	SAFE_NTOM   /* Do not depend on off_t*off_t with big values still being in the range... */

Functions
int	synth_ntom_set_step (mpg123_handle *fr)
unsigned long	ntom_val (mpg123_handle *fr, off_t frame)
void	ntom_set_ntom (mpg123_handle *fr, off_t num)
off_t	ntom_frame_outsamples (mpg123_handle *fr)
off_t	ntom_frmouts (mpg123_handle *fr, off_t frame)
off_t	ntom_ins2outs (mpg123_handle *fr, off_t ins)
off_t	ntom_frameoff (mpg123_handle *fr, off_t soff)

Macro Definition Documentation

SAFE_NTOM

#define SAFE_NTOM   /* Do not depend on off_t*off_t with big values still being in the range... */

Definition at line 9 of file ntom.c.

Function Documentation

ntom_frame_outsamples()

off_t ntom_frame_outsamples

(

mpg123_handle *

fr

)

Definition at line 73 of file ntom.c.

{
    /* The do this before decoding the separate channels, so there is only one common ntom value. */
    int ntm = fr->ntom_val[0];
    ntm += fr->spf*fr->ntom_step;
    return ntm/NTOM_MUL;
}

ntom_frameoff()

off_t ntom_frameoff	(	mpg123_handle *	fr,
		off_t	soff
	)

Definition at line 130 of file ntom.c.

{
    off_t ioff = 0; /* frames or samples */
    off_t ntm = ntom_val(fr,0);
#ifdef SAFE_NTOM
    if(soff <= 0) return 0;
    for(ioff=0; 1; ++ioff)
    {
        ntm  += fr->spf*fr->ntom_step;
        if(ntm/NTOM_MUL > soff) break;
        soff -= ntm/NTOM_MUL;
        ntm  -= (ntm/NTOM_MUL)*NTOM_MUL;
    }
    return ioff;
#else
    ioff = (soff*(off_t)NTOM_MUL-ntm)/(off_t)fr->ntom_step;
    return ioff/(off_t)fr->spf;
#endif
}

ntom_frmouts()

off_t ntom_frmouts	(	mpg123_handle *	fr,
		off_t	frame
	)

Definition at line 82 of file ntom.c.

{
#ifdef SAFE_NTOM
    off_t f;
#endif
    off_t soff = 0;
    off_t ntm = ntom_val(fr,0);
#ifdef SAFE_NTOM
    if(frame <= 0) return 0;
    for(f=0; f<frame; ++f)
    {
        ntm  += fr->spf*fr->ntom_step;
        soff += ntm/NTOM_MUL;
        ntm  -= (ntm/NTOM_MUL)*NTOM_MUL;
    }
#else
    soff = (ntm + frame*(off_t)fr->spf*(off_t)fr->ntom_step)/(off_t)NTOM_MUL;
#endif
    return soff;
}

ntom_ins2outs()

off_t ntom_ins2outs	(	mpg123_handle *	fr,
		off_t	ins
	)

Definition at line 104 of file ntom.c.

{
    off_t soff = 0;
    off_t ntm = ntom_val(fr,0);
#ifdef SAFE_NTOM
    {
        off_t block = fr->spf;
        if(ins <= 0) return 0;
        do
        {
            off_t nowblock = ins > block ? block : ins;
            ntm  += nowblock*fr->ntom_step;
            soff += ntm/NTOM_MUL;
            ntm  -= (ntm/NTOM_MUL)*NTOM_MUL;
            ins -= nowblock;
        } while(ins > 0);
    }
#else
    /* Beware of overflows: when off_t is 32bits, the multiplication blows too easily.
       Of course, it blows for 64bits, too, in theory, but that's for _really_ large files. */
    soff = ((off_t)ntm + (off_t)ins*(off_t)fr->ntom_step)/(off_t)NTOM_MUL;
#endif
    return soff;
}

ntom_set_ntom()

void ntom_set_ntom	(	mpg123_handle *	fr,
		off_t	num
	)

Definition at line 66 of file ntom.c.

{
    fr->ntom_val[1] = fr->ntom_val[0] = ntom_val(fr, num);
}

ntom_val()

unsigned long ntom_val	(	mpg123_handle *	fr,
		off_t	frame
	)

Definition at line 46 of file ntom.c.

{
    off_t ntm;
#ifdef SAFE_NTOM /* Carry out the loop, without the threatening integer overflow. */
    off_t f;
    ntm = NTOM_MUL>>1; /* for frame 0 */
    for(f=0; f<frame; ++f)   /* for frame > 0 */
    {
        ntm += fr->spf*fr->ntom_step;
        ntm -= (ntm/NTOM_MUL)*NTOM_MUL;
    }
#else /* Just make one computation with overall sample offset. */
    ntm  = (NTOM_MUL>>1) + fr->spf*frame*fr->ntom_step;
    ntm -= (ntm/NTOM_MUL)*NTOM_MUL;
#endif
    return (unsigned long) ntm;
}

synth_ntom_set_step()

int synth_ntom_set_step

(

mpg123_handle *

fr

)

Definition at line 13 of file ntom.c.

{
    long m,n;
    m = frame_freq(fr);
    n = fr->af.rate;
    if(VERBOSE2)
        fprintf(stderr,"Init rate converter: %ld->%ld\n",m,n);
 
    if(n > NTOM_MAX_FREQ || m > NTOM_MAX_FREQ || m <= 0 || n <= 0) {
        if(NOQUIET) error("NtoM converter: illegal rates");
        fr->err = MPG123_BAD_RATE;
        return -1;
    }
 
    n *= NTOM_MUL;
    fr->ntom_step = (unsigned long) n / m;
 
    if(fr->ntom_step > (unsigned long)NTOM_MAX*NTOM_MUL) {
        if(NOQUIET) error3("max. 1:%i conversion allowed (%lu vs %lu)!", NTOM_MAX, fr->ntom_step, (unsigned long)8*NTOM_MUL);
        fr->err = MPG123_BAD_RATE;
        return -1;
    }
 
    fr->ntom_val[0] = fr->ntom_val[1] = ntom_val(fr, fr->num);
    return 0;
}