format.c File Reference

#include "mpg123lib_intern.h"
#include "sample.h"
#include "debug.h"
#include "swap_bytes_impl.h"

Include dependency graph for format.c:

Go to the source code of this file.

Macros
#define	MPG123_FLOAT_ENC   MPG123_ENC_FLOAT_32
#define	ENCRANGE(range)   imax(f0, range[0]), imin(f2, range[1])

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_pars *p, struct audioformat *nf, int f0, int f2)
static int	imin (int a, int b)
static int	imax (int a, int b)
static int	enc_chan_fit (mpg123_pars *p, long rate, struct audioformat *nnf, int f0, int f2, int try_float)
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_format2 (mpg123_handle *mh, long rate, int channels, int encodings)
int attribute_align_arg	mpg123_format (mpg123_handle *mh, long rate, int channels, int encodings)
int attribute_align_arg	mpg123_fmt2 (mpg123_pars *mp, 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	swap_endian (struct outbuffer *buf, int block)
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	enc_24bit_range [2] = { 2, 6 }
static const int	enc_16bit_range [2] = { 0, 2}
static const int	good_encodings []
static const char *	bufsizeerr = "Fatal: Buffer too small for postprocessing!"

Macro Definition Documentation

ENCRANGE

#define ENCRANGE

(

range

)

imax(f0, range[0]), imin(f2, range[1])

MPG123_FLOAT_ENC

#define MPG123_FLOAT_ENC   MPG123_ENC_FLOAT_32

Definition at line 80 of file format.c.

Function Documentation

bytes_to_samples()

off_t bytes_to_samples	(	mpg123_handle *	fr,
		off_t	b
	)

Definition at line 570 of file format.c.

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

cap_fit()

static int cap_fit ( mpg123_pars *  p, struct audioformat *  nf, int  f0, int  f2  )

static

Definition at line 158 of file format.c.

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

Referenced by enc_chan_fit().

chop_fourth_byte()

static void chop_fourth_byte ( struct outbuffer *  buf )

static

Definition at line 590 of file format.c.

{
    unsigned char *wpos = buf->data;
    unsigned char *rpos = buf->data;
    size_t blocks = buf->fill/4;
    size_t i;
    for(i=0; i<blocks; ++i,wpos+=3,rpos+=4)
        DROP4BYTE(wpos, rpos)
    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 635 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 661 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 623 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)
        usamples[i] = CONV_SU16(ssamples[i]);
}

Referenced by postprocess_buffer().

conv_s32_to_u32()

static void conv_s32_to_u32 ( struct outbuffer *  buf )

static

Definition at line 601 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)
        usamples[i] = CONV_SU32(ssamples[i]);
}

Referenced by postprocess_buffer().

decoder_synth_bytes()

off_t decoder_synth_bytes	(	mpg123_handle *	fr,
		off_t	s
	)

Definition at line 558 of file format.c.

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

enc2num()

static int enc2num ( int  encoding )

static

Definition at line 149 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().

enc_chan_fit()

static int enc_chan_fit ( mpg123_pars *  p, long  rate, struct audioformat *  nnf, int  f0, int  f2, int  try_float  )

static

Definition at line 188 of file format.c.

{
#define ENCRANGE(range) imax(f0, range[0]), imin(f2, range[1])
    struct audioformat nf = *nnf;
    nf.rate = rate;
    if(cap_fit(p, &nf, ENCRANGE(enc_16bit_range)))
        goto eend;
    if(cap_fit(p, &nf, ENCRANGE(enc_24bit_range)))
        goto eend;
    if(try_float &&
        cap_fit(p, &nf, ENCRANGE(enc_float_range)))
        goto eend;
    if(cap_fit(p, &nf, ENCRANGE(enc_8bit_range)))
        goto eend;

    /* 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(p, &nf, ENCRANGE(enc_16bit_range)))
        goto eend;
    if(cap_fit(p, &nf, ENCRANGE(enc_24bit_range)))
        goto eend;
    if(try_float &&
        cap_fit(p, &nf, ENCRANGE(enc_float_range)))
        goto eend;
    if(cap_fit(p, &nf, ENCRANGE(enc_8bit_range)))
        goto eend;
    return FALSE;
eend:
    *nnf = nf;
    return TRUE;
#undef ENCRANGE
}

Referenced by frame_output_format().

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;
    }
}

good_enc()

static int good_enc ( const int  enc )

static

Definition at line 109 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_fmt2(), and mpg123_fmt_all().

imax()

static int imax ( int  a, int  b  )

static

Definition at line 179 of file format.c.

{
    return a > b ? a : b;
}

Referenced by pwlarc_intersect().

imin()

static int imin ( int  a, int  b  )

static

Definition at line 174 of file format.c.

{
    return a < b ? a : b;
}

Referenced by Pos_InitPage(), and pwlarc_intersect().

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;
}

outblock_bytes()

off_t outblock_bytes	(	mpg123_handle *	fr,
		off_t	s
	)

Definition at line 576 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 700 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
    }
    if(fr->p.flags & MPG123_FORCE_ENDIAN)
    {
        if(
#ifdef WORDS_BIGENDIAN
            !(
#endif
                fr->p.flags & MPG123_BIG_ENDIAN
#ifdef WORDS_BIGENDIAN
            )
#endif
        )
            swap_endian(&fr->buffer, mpg123_encsize(fr->af.encoding));
    }
}

rate2num()

static int rate2num ( mpg123_pars *  mp, long  r  )

static

Definition at line 138 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(), frame_output_format(), mpg123_fmt2(), and mpg123_fmt_support().

samples_to_bytes()

off_t samples_to_bytes	(	mpg123_handle *	fr,
		off_t	s
	)

Definition at line 565 of file format.c.

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

swap_endian()

void swap_endian	(	struct outbuffer *	buf,
		int	block
	)

Definition at line 689 of file format.c.

{
    size_t count;

    if(block >= 2)
    {
        count = buf->fill/(unsigned int)block;
        swap_bytes(buf->data, (size_t)block, count);
    }
}

Referenced by postprocess_buffer().

Variable Documentation

bufsizeerr

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

static

Definition at line 618 of file format.c.

Referenced by conv_s16_to_f32(), and conv_s16_to_s32().

enc_16bit_range

const int enc_16bit_range[2] = { 0, 2}

static

Definition at line 67 of file format.c.

Referenced by enc_chan_fit().

enc_24bit_range

const int enc_24bit_range[2] = { 2, 6 }

static

Definition at line 65 of file format.c.

Referenced by enc_chan_fit().

enc_8bit_range

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

static

Definition at line 63 of file format.c.

Referenced by enc_chan_fit(), and frame_output_format().

enc_float_range

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

static

Definition at line 61 of file format.c.

Referenced by enc_chan_fit(), and 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 84 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 40 of file format.c.

Referenced by cap_fit(), enc2num(), mpg123_fmt2(), 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 33 of file format.c.

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