format.c File Reference

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

Include dependency graph for format.c:

Go to the source code of this file.

Macros
#define	MPG123_FLOAT_ENC   MPG123_ENC_FLOAT_32

Functions
static int	good_enc (const int enc)
void attribute_align_arg	mpg123_rates (const long **list, size_t *number)
void attribute_align_arg	mpg123_encodings (const int **list, size_t *number)
int attribute_align_arg	mpg123_encsize (int encoding)
static int	rate2num (mpg123_pars *mp, long r)
static int	enc2num (int encoding)
static int	cap_fit (mpg123_handle *fr, struct audioformat *nf, int f0, int f2)
static int	freq_fit (mpg123_handle *fr, struct audioformat *nf, int f0, int f2)
int	frame_output_format (mpg123_handle *fr)
int attribute_align_arg	mpg123_format_none (mpg123_handle *mh)
int attribute_align_arg	mpg123_fmt_none (mpg123_pars *mp)
int attribute_align_arg	mpg123_format_all (mpg123_handle *mh)
int attribute_align_arg	mpg123_fmt_all (mpg123_pars *mp)
int attribute_align_arg	mpg123_format (mpg123_handle *mh, long rate, int channels, int encodings)
int attribute_align_arg	mpg123_fmt (mpg123_pars *mp, long rate, int channels, int encodings)
int attribute_align_arg	mpg123_format_support (mpg123_handle *mh, long rate, int encoding)
int attribute_align_arg	mpg123_fmt_support (mpg123_pars *mp, long rate, int encoding)
void	invalidate_format (struct audioformat *af)
off_t	decoder_synth_bytes (mpg123_handle *fr, off_t s)
off_t	samples_to_bytes (mpg123_handle *fr, off_t s)
off_t	bytes_to_samples (mpg123_handle *fr, off_t b)
off_t	outblock_bytes (mpg123_handle *fr, off_t s)
static void	chop_fourth_byte (struct outbuffer *buf)
static void	conv_s32_to_u32 (struct outbuffer *buf)
static void	conv_s16_to_u16 (struct outbuffer *buf)
static void	conv_s16_to_f32 (struct outbuffer *buf)
static void	conv_s16_to_s32 (struct outbuffer *buf)
void	postprocess_buffer (mpg123_handle *fr)

Variables
static const long	my_rates [MPG123_RATES]
static const int	my_encodings [MPG123_ENCODINGS]
static const int	enc_float_range [2] = { 6, 8 }
static const int	enc_8bit_range [2] = { 8, 12 }
static const int	good_encodings []
static const char *	bufsizeerr = "Fatal: Buffer too small for postprocessing!"

Macro Definition Documentation

MPG123_FLOAT_ENC

#define MPG123_FLOAT_ENC   MPG123_ENC_FLOAT_32

Definition at line 75 of file format.c.

Function Documentation

bytes_to_samples()

off_t bytes_to_samples	(	mpg123_handle *	fr,
		off_t	b
	)

Definition at line 470 of file format.c.

{
    return b / fr->af.encsize / fr->af.channels;
}

cap_fit()

static int cap_fit ( mpg123_handle *  fr, struct audioformat *  nf, int  f0, int  f2  )

static

Definition at line 153 of file format.c.

{
    int i;
    int c  = nf->channels-1;
    int rn = rate2num(&fr->p, nf->rate);
    if(rn >= 0) for(i=f0;i<f2;i++)
    {
        if(fr->p.audio_caps[c][rn][i])
        {
            nf->encoding = my_encodings[i];
            return 1;
        }
    }
    return 0;
}

Referenced by frame_output_format(), and freq_fit().

chop_fourth_byte()

static void chop_fourth_byte ( struct outbuffer *  buf )

static

Definition at line 489 of file format.c.

{
    unsigned char *wpos = buf->data;
    unsigned char *rpos = buf->data;
#ifdef WORDS_BIGENDIAN
    while((size_t) (rpos - buf->data + 4) <= buf->fill)
    {
        /* Really stupid: Copy, increment. Byte per byte. */
        *wpos = *rpos;
        wpos++; rpos++;
        *wpos = *rpos;
        wpos++; rpos++;
        *wpos = *rpos;
        wpos++; rpos++;
        rpos++; /* Skip the lowest byte (last). */
    }
#else
    while((size_t) (rpos - buf->data + 4) <= buf->fill)
    {
        /* Really stupid: Copy, increment. Byte per byte. */
        rpos++; /* Skip the lowest byte (first). */
        *wpos = *rpos;
        wpos++; rpos++;
        *wpos = *rpos;
        wpos++; rpos++;
        *wpos = *rpos;
        wpos++; rpos++;
    }
#endif
    buf->fill = wpos-buf->data;
}

Referenced by postprocess_buffer().

conv_s16_to_f32()

static void conv_s16_to_f32 ( struct outbuffer *  buf )

static

Definition at line 569 of file format.c.

{
    ssize_t i;
    int16_t *in = (int16_t*) buf->data;
    float  *out = (float*)   buf->data;
    size_t count = buf->fill/sizeof(int16_t);
    /* Does that make any sense? In x86, there is an actual instruction to divide
       float by integer ... but then, if we have that FPU, we don't really need
       fixed point decoder hacks ...? */
    float scale = 1./SHORT_SCALE;

    if(buf->size < count*sizeof(float))
    {
        error1("%s", bufsizeerr);
        return;
    }

    /* Work from the back since output is bigger. */
    for(i=count-1; i>=0; --i)
    out[i] = (float)in[i] * scale;

    buf->fill = count*sizeof(float);
}

Referenced by postprocess_buffer().

conv_s16_to_s32()

static void conv_s16_to_s32 ( struct outbuffer *  buf )

static

Definition at line 595 of file format.c.

{
    ssize_t i;
    int16_t  *in = (int16_t*) buf->data;
    int32_t *out = (int32_t*) buf->data;
    size_t count = buf->fill/sizeof(int16_t);

    if(buf->size < count*sizeof(int32_t))
    {
        error1("%s", bufsizeerr);
        return;
    }

    /* Work from the back since output is bigger. */
    for(i=count-1; i>=0; --i)
    {
        out[i] = in[i];
        /* Could just shift bytes, but would have to mess with sign bit. */
        out[i] *= S32_RESCALE;
    }

    buf->fill = count*sizeof(int32_t);
}

Referenced by postprocess_buffer().

conv_s16_to_u16()

static void conv_s16_to_u16 ( struct outbuffer *  buf )

static

Definition at line 554 of file format.c.

{
    size_t i;
    int16_t  *ssamples = (int16_t*) buf->data;
    uint16_t *usamples = (uint16_t*)buf->data;
    size_t count = buf->fill/sizeof(int16_t);

    for(i=0; i<count; ++i)
    {
        long tmp = (long)ssamples[i]+32768;
        usamples[i] = (uint16_t)tmp;
    }
}

Referenced by postprocess_buffer().

conv_s32_to_u32()

static void conv_s32_to_u32 ( struct outbuffer *  buf )

static

Definition at line 521 of file format.c.

{
    size_t i;
    int32_t  *ssamples = (int32_t*)  buf->data;
    uint32_t *usamples = (uint32_t*) buf->data;
    size_t count = buf->fill/sizeof(int32_t);

    for(i=0; i<count; ++i)
    {
        /* Different strategy since we don't have a larger type at hand.
             Also watch out for silly +-1 fun because integer constants are signed in C90! */
        if(ssamples[i] >= 0)
        usamples[i] = (uint32_t)ssamples[i] + 2147483647+1;
        /* The smallest value goes zero. */
        else if(ssamples[i] == ((int32_t)-2147483647-1))
        usamples[i] = 0;
        /* Now -value is in the positive range of signed int ... so it's a possible value at all. */
        else
        usamples[i] = (uint32_t)2147483647+1 - (uint32_t)(-ssamples[i]);
    }
}

Referenced by postprocess_buffer().

decoder_synth_bytes()

off_t decoder_synth_bytes	(	mpg123_handle *	fr,
		off_t	s
	)

Definition at line 458 of file format.c.

{
    return s * fr->af.dec_encsize * fr->af.channels;
}

enc2num()

static int enc2num ( int  encoding )

static

Definition at line 144 of file format.c.

{
    int i;
    for(i=0;i<MPG123_ENCODINGS;++i)
    if(my_encodings[i] == encoding) return i;

    return -1;
}

Referenced by mpg123_fmt_support().

frame_output_format()

int frame_output_format

(

mpg123_handle *

fr

)

Definition at line 215 of file format.c.

{
    struct audioformat nf;
    int f0=0;
    int f2=MPG123_ENCODINGS; /* Omit the 32bit and float encodings. */
    mpg123_pars *p = &fr->p;
    /* initialize new format, encoding comes later */
    nf.channels = fr->stereo;

    /* All this forcing should be removed in favour of the capabilities table... */
    if(p->flags & MPG123_FORCE_8BIT)
    {
        f0 = enc_8bit_range[0];
        f2 = enc_8bit_range[1];
    }
    if(p->flags & MPG123_FORCE_FLOAT)
    {
        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;

#ifndef NO_NTOM
    if(p->force_rate)
    {
        nf.rate = p->force_rate;
        if(cap_fit(fr,&nf,f0,2)) goto end;            /* 16bit encodings */
        if(cap_fit(fr,&nf,f0<=2 ? 2 : f0,f2)) goto end; /*  8bit encodings */

        /* try again with different stereoness */
        if(nf.channels == 2 && !(p->flags & MPG123_FORCE_STEREO)) nf.channels = 1;
        else if(nf.channels == 1 && !(p->flags & MPG123_FORCE_MONO)) nf.channels = 2;

        if(cap_fit(fr,&nf,f0,2)) goto end;            /* 16bit encodings */
        if(cap_fit(fr,&nf,f0<=2 ? 2 : f0,f2)) goto end; /*  8bit encodings */

        if(NOQUIET)
        error3( "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_8BIT ? "8bit, " : ""),
                p->force_rate );
/*      if(NOQUIET && p->verbose <= 1) print_capabilities(fr); */

        fr->err = MPG123_BAD_OUTFORMAT;
        return -1;
    }
#endif

    if(freq_fit(fr, &nf, f0, 2)) goto end; /* try rates with 16bit */
    if(freq_fit(fr, &nf, f0<=2 ? 2 : f0, f2)) goto end; /* ... 8bit */

    /* try again with different stereoness */
    if(nf.channels == 2 && !(p->flags & MPG123_FORCE_STEREO)) nf.channels = 1;
    else if(nf.channels == 1 && !(p->flags & MPG123_FORCE_MONO)) nf.channels = 2;

    if(freq_fit(fr, &nf, f0, 2)) goto end; /* try rates with 16bit */
    if(freq_fit(fr, &nf,  f0<=2 ? 2 : f0, f2)) goto end; /* ... 8bit */

    /* Here is the _bad_ end. */
    if(NOQUIET)
    {
        error5( "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_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)
        {
            if(NOQUIET) 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;
    }
}

freq_fit()

static int freq_fit ( mpg123_handle *  fr, struct audioformat *  nf, int  f0, int  f2  )

static

Definition at line 169 of file format.c.

{
    nf->rate = frame_freq(fr)>>fr->p.down_sample;
    if(cap_fit(fr,nf,f0,f2)) return 1;
    if(fr->p.flags & MPG123_AUTO_RESAMPLE)
    {
        nf->rate>>=1;
        if(cap_fit(fr,nf,f0,f2)) return 1;
        nf->rate>>=1;
        if(cap_fit(fr,nf,f0,f2)) return 1;
    }
#ifndef NO_NTOM
    /* If nothing worked, try the other rates, only without constrains from user.
       In case you didn't guess: We enable flexible resampling if we find a working rate. */
    if(  fr->p.flags & MPG123_AUTO_RESAMPLE &&
        !fr->p.force_rate && fr->p.down_sample == 0)
    {
        int i;
        int c  = nf->channels-1;
        int rn = rate2num(&fr->p, frame_freq(fr));
        int rrn;
        if(rn < 0) return 0;
        /* Try higher rates first. */
        for(i=f0;i<f2;i++) for(rrn=rn+1; rrn<MPG123_RATES; ++rrn)
        if(fr->p.audio_caps[c][rrn][i])
        {
            nf->rate = my_rates[rrn];
            nf->encoding = my_encodings[i];
            return 1;
        }
        /* Then lower rates. */
        for(i=f0;i<f2;i++) for(rrn=rn-1; rrn>=0; --rrn)
        if(fr->p.audio_caps[c][rrn][i])
        {
            nf->rate = my_rates[rrn];
            nf->encoding = my_encodings[i];
            return 1;
        }
    }
#endif

    return 0;
}

Referenced by frame_output_format().

good_enc()

static int good_enc ( const int  enc )

static

Definition at line 104 of file format.c.

{
    size_t i;
    for(i=0; i<sizeof(good_encodings)/sizeof(int); ++i)
    if(enc == good_encodings[i]) return TRUE;

    return FALSE;
}

Referenced by mpg123_fmt(), and mpg123_fmt_all().

invalidate_format()

void invalidate_format

(

struct audioformat *

af

)

Definition at line 450 of file format.c.

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

outblock_bytes()

off_t outblock_bytes	(	mpg123_handle *	fr,
		off_t	s
	)

Definition at line 476 of file format.c.

{
    int encsize = (fr->af.encoding & MPG123_ENC_24)
    ? 4 /* Intermediate 32 bit. */
    : (fr->af.encsize > fr->af.dec_encsize
        ? fr->af.encsize
        : fr->af.dec_encsize);
    return s * encsize * fr->af.channels;
}

postprocess_buffer()

void postprocess_buffer

(

mpg123_handle *

fr

)

Definition at line 622 of file format.c.

{
    /*
        This caters for the final output formats that are never produced by
        decoder synth directly (wide unsigned and 24 bit formats) or that are
        missing because of limited decoder precision (16 bit synth but 32 or
        24 bit output).
    */
    switch(fr->af.dec_enc)
    {
#ifndef NO_32BIT
    case MPG123_ENC_SIGNED_32:
        switch(fr->af.encoding)
        {
        case MPG123_ENC_UNSIGNED_32:
            conv_s32_to_u32(&fr->buffer);
        break;
        case MPG123_ENC_UNSIGNED_24:
            conv_s32_to_u32(&fr->buffer);
            chop_fourth_byte(&fr->buffer);
        break;
        case MPG123_ENC_SIGNED_24:
            chop_fourth_byte(&fr->buffer);
        break;
        }
    break;
#endif
#ifndef NO_16BIT
    case MPG123_ENC_SIGNED_16:
        switch(fr->af.encoding)
        {
        case MPG123_ENC_UNSIGNED_16:
            conv_s16_to_u16(&fr->buffer);
        break;
#ifndef NO_REAL
        case MPG123_ENC_FLOAT_32:
            conv_s16_to_f32(&fr->buffer);
        break;
#endif
#ifndef NO_32BIT
        case MPG123_ENC_SIGNED_32:
            conv_s16_to_s32(&fr->buffer);
        break;
        case MPG123_ENC_UNSIGNED_32:
            conv_s16_to_s32(&fr->buffer);
            conv_s32_to_u32(&fr->buffer);
        break;
        case MPG123_ENC_UNSIGNED_24:
            conv_s16_to_s32(&fr->buffer);
            conv_s32_to_u32(&fr->buffer);
            chop_fourth_byte(&fr->buffer);
        break;
        case MPG123_ENC_SIGNED_24:
            conv_s16_to_s32(&fr->buffer);
            chop_fourth_byte(&fr->buffer);
        break;
#endif
        }
    break;
#endif
    }
}

rate2num()

static int rate2num ( mpg123_pars *  mp, long  r  )

static

Definition at line 133 of file format.c.

{
    int i;
    for(i=0;i<MPG123_RATES;i++) if(my_rates[i] == r) return i;
#ifndef NO_NTOM
    if(mp && mp->force_rate != 0 && mp->force_rate == r) return MPG123_RATES;
#endif

    return -1;
}

Referenced by cap_fit(), freq_fit(), mpg123_fmt(), and mpg123_fmt_support().

samples_to_bytes()

off_t samples_to_bytes	(	mpg123_handle *	fr,
		off_t	s
	)

Definition at line 465 of file format.c.

{
    return s * fr->af.encsize * fr->af.channels;
}

Variable Documentation

bufsizeerr

const char* bufsizeerr = "Fatal: Buffer too small for postprocessing!"

static

Definition at line 549 of file format.c.

Referenced by conv_s16_to_f32(), and conv_s16_to_s32().

enc_8bit_range

const int enc_8bit_range[2] = { 8, 12 }

static

Definition at line 62 of file format.c.

Referenced by frame_output_format().

enc_float_range

const int enc_float_range[2] = { 6, 8 }

static

Definition at line 60 of file format.c.

Referenced by frame_output_format().

good_encodings

const int good_encodings[]

static

Initial value:

=
{

    MPG123_ENC_SIGNED_16,
    MPG123_ENC_UNSIGNED_16,


    MPG123_ENC_SIGNED_32,
    MPG123_ENC_UNSIGNED_32,
    MPG123_ENC_SIGNED_24,
    MPG123_ENC_UNSIGNED_24,


    MPG123_FLOAT_ENC,


    MPG123_ENC_SIGNED_8,
    MPG123_ENC_UNSIGNED_8,
    MPG123_ENC_ULAW_8,
    MPG123_ENC_ALAW_8

}

Definition at line 79 of file format.c.

Referenced by good_enc(), and mpg123_encodings().

my_encodings

const int my_encodings[MPG123_ENCODINGS]

static

Initial value:

=
{
    MPG123_ENC_SIGNED_16,
    MPG123_ENC_UNSIGNED_16,
    MPG123_ENC_SIGNED_32,
    MPG123_ENC_UNSIGNED_32,
    MPG123_ENC_SIGNED_24,
    MPG123_ENC_UNSIGNED_24,
    
    MPG123_ENC_FLOAT_32,
    MPG123_ENC_FLOAT_64,
    
    MPG123_ENC_SIGNED_8,
    MPG123_ENC_UNSIGNED_8,
    MPG123_ENC_ULAW_8,
    MPG123_ENC_ALAW_8
}

Definition at line 39 of file format.c.

Referenced by cap_fit(), enc2num(), freq_fit(), mpg123_fmt(), and mpg123_fmt_all().

my_rates

const long my_rates[MPG123_RATES]

static

Initial value:

= 
{
     8000, 11025, 12000, 
    16000, 22050, 24000,
    32000, 44100, 48000,
}

Definition at line 32 of file format.c.

Referenced by freq_fit(), mpg123_rates(), and rate2num().