optimize.h File Reference

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

Go to the source code of this file.

Macros
#define	ALIGNED(a)
#define	opt_dct36(fr)   dct36

Enumerations
enum	optdec {   autodec =0 , generic , generic_dither , idrei ,   ivier , ifuenf , ifuenf_dither , mmx ,   dreidnow , dreidnowext , altivec , sse ,   x86_64 , arm , neon , neon64 ,   avx , dreidnow_vintage , dreidnowext_vintage , sse_vintage ,   nodec }
enum	optcla { nocla =0 , normal , mmxsse }

Functions
int	frame_cpu_opt (mpg123_handle *fr, const char *cpu)
int	set_synth_functions (mpg123_handle *fr)
enum optdec	dectype (const char *decoder)
enum optdec	defdec (void)
enum optcla	decclass (const enum optdec)
void	check_decoders (void)

Macro Definition Documentation

ALIGNED

#define ALIGNED

(

a

)

Definition at line 190 of file optimize.h.

opt_dct36

#define opt_dct36

(

fr

)

dct36

Definition at line 391 of file optimize.h.

Enumeration Type Documentation

optcla

enum optcla

Enumerator
nocla
normal
mmxsse

Definition at line 166 of file optimize.h.

{ nocla=0, normal, mmxsse };

optdec

enum optdec

Enumerator
autodec
generic
generic_dither
idrei
ivier
ifuenf
ifuenf_dither
mmx
dreidnow
dreidnowext
altivec
sse
x86_64
arm
neon
neon64
avx
dreidnow_vintage
dreidnowext_vintage
sse_vintage
nodec

Definition at line 94 of file optimize.h.

{
     autodec=0
    ,generic
    ,generic_dither
    ,idrei
    ,ivier
    ,ifuenf
    ,ifuenf_dither
    ,mmx
    ,dreidnow
    ,dreidnowext
    ,altivec
    ,sse
    ,x86_64
    ,arm
    ,neon
    ,neon64
    ,avx
    ,dreidnow_vintage
    ,dreidnowext_vintage
    ,sse_vintage
    ,nodec
};

Function Documentation

check_decoders()

void check_decoders

(

void

)

Definition at line 1084 of file optimize.c.

{
#ifndef OPT_MULTI
    /* In non-multi mode, only the full list (one entry) is used. */
    return;
#else
    const char **d = mpg123_supported_decoder_list;
#if (defined OPT_X86) || (defined OPT_X86_64) || (defined OPT_NEON) || (defined OPT_NEON64)
    getcpuflags(&cpu_flags);
#endif
#ifdef OPT_X86
    if(cpu_i586(cpu_flags))
    {
        /* not yet: if(cpu_sse2(cpu_flags)) printf(" SSE2");
        if(cpu_sse3(cpu_flags)) printf(" SSE3"); */
#ifdef OPT_SSE
        if(cpu_sse(cpu_flags)) *(d++) = dn_sse;
#endif
#ifdef OPT_SSE_VINTAGE
        if(cpu_sse(cpu_flags)) *(d++) = dn_sse_vintage;
#endif
#ifdef OPT_3DNOWEXT
        if(cpu_3dnowext(cpu_flags)) *(d++) = dn_dreidnowext;
#endif
#ifdef OPT_3DNOWEXT_VINTAGE
        if(cpu_3dnowext(cpu_flags)) *(d++) = dn_dreidnowext_vintage;
#endif
#ifdef OPT_3DNOW
        if(cpu_3dnow(cpu_flags)) *(d++) = dn_dreidnow;
#endif
#ifdef OPT_3DNOW_VINTAGE
        if(cpu_3dnow(cpu_flags)) *(d++) = dn_dreidnow_vintage;
#endif
#ifdef OPT_MMX
        if(cpu_mmx(cpu_flags)) *(d++) = dn_mmx;
#endif
#ifdef OPT_I586
        *(d++) = dn_ifuenf;
#endif
#ifdef OPT_I586_DITHER
        *(d++) = dn_ifuenf_dither;
#endif
    }
#endif
/* just assume that the i486 built is run on a i486 cpu... */
#ifdef OPT_I486
    *(d++) = dn_ivier;
#endif
#ifdef OPT_ALTIVEC
    *(d++) = dn_altivec;
#endif
/* every supported x86 can do i386, any cpu can do generic */
#ifdef OPT_I386
    *(d++) = dn_idrei;
#endif
#ifdef OPT_AVX
    if(cpu_avx(cpu_flags)) *(d++) = dn_avx;
#endif
#ifdef OPT_X86_64
    *(d++) = dn_x86_64;
#endif
#ifdef OPT_ARM
    *(d++) = dn_arm;
#endif
#ifdef OPT_NEON
    if(cpu_neon(cpu_flags)) *(d++) = dn_neon;
#endif
#ifdef OPT_NEON64
    if(cpu_neon(cpu_flags)) *(d++) = dn_neon64;
#endif
#ifdef OPT_GENERIC
    *(d++) = dn_generic;
#endif
#ifdef OPT_GENERIC_DITHER
    *(d++) = dn_generic_dither;
#endif
#endif /* ndef OPT_MULTI */
}

decclass()

enum optcla decclass

(

const enum

optdec

)

Definition at line 141 of file optimize.c.

{
    return
    (
           type == mmx
        || type == sse
        || type == sse_vintage
        || type == dreidnowext
        || type == dreidnowext_vintage
        || type == x86_64
        || type == neon
        || type == neon64
        || type == avx
    ) ? mmxsse : normal;
}

dectype()

enum optdec dectype

(

const char *

decoder

)

Definition at line 940 of file optimize.c.

{
    enum optdec dt;
    if(   (decoder == NULL)
       || (decoder[0] == 0) )
    return autodec;
 
    for(dt=autodec; dt<nodec; ++dt)
    if(!strcasecmp(decoder, decname[dt])) return dt;
 
    return nodec; /* If we found nothing... */
}

defdec()

enum optdec defdec

(

void

)

Definition at line 139 of file optimize.c.

{ return defopt; }

frame_cpu_opt()

int frame_cpu_opt	(	mpg123_handle *	fr,
		const char *	cpu
	)

Definition at line 496 of file optimize.c.

{
    const char* chosen = ""; /* the chosen decoder opt as string */
    enum optdec want_dec = nodec;
    int done = 0;
    int auto_choose = 0;
#ifdef OPT_DITHER
    int dithered = FALSE; /* If some dithered decoder is chosen. */
#endif
 
    want_dec = dectype(cpu);
    auto_choose = want_dec == autodec;
    /* Fill whole array of synth functions with generic code first. */
    fr->synths = synth_base;
 
#ifndef OPT_MULTI
    {
        if(!auto_choose && want_dec != defopt)
        {
            if(NOQUIET) error2("you wanted decoder type %i, I only have %i", want_dec, defopt);
        }
        auto_choose = TRUE; /* There will be only one choice anyway. */
    }
#endif
 
    fr->cpu_opts.type = nodec;
#ifdef OPT_MULTI
#ifndef NO_LAYER3
#if (defined OPT_3DNOW_VINTAGE || defined OPT_3DNOWEXT_VINTAGE || defined OPT_SSE || defined OPT_X86_64 || defined OPT_AVX || defined OPT_NEON || defined OPT_NEON64)
    fr->cpu_opts.the_dct36 = dct36;
#endif
#endif
#endif
    /* covers any i386+ cpu; they actually differ only in the synth_1to1 function, mostly... */
#ifdef OPT_X86
    if(cpu_i586(cpu_flags))
    {
#       ifdef OPT_MULTI
        debug2("standard flags: 0x%08x\textended flags: 0x%08x", cpu_flags.std, cpu_flags.ext);
#       endif
#       ifdef OPT_SSE
        if(   !done && (auto_choose || want_dec == sse)
           && cpu_sse(cpu_flags) && cpu_mmx(cpu_flags) )
        {
            chosen = dn_sse;
            fr->cpu_opts.type = sse;
#ifdef OPT_MULTI
#           ifndef NO_LAYER3
            /* if(cpu_fast_sse(cpu_flags)) */ fr->cpu_opts.the_dct36 = dct36_sse;
#           endif
#endif
#           ifndef NO_16BIT
            fr->synths.plain[r_1to1][f_16] = synth_1to1_sse;
#           ifdef ACCURATE_ROUNDING
            fr->synths.stereo[r_1to1][f_16] = synth_1to1_stereo_sse;
#           endif
#           endif
#           ifndef NO_REAL
            fr->synths.plain[r_1to1][f_real] = synth_1to1_real_sse;
            fr->synths.stereo[r_1to1][f_real] = synth_1to1_real_stereo_sse;
#           endif
#           ifndef NO_32BIT
            fr->synths.plain[r_1to1][f_32] = synth_1to1_s32_sse;
            fr->synths.stereo[r_1to1][f_32] = synth_1to1_s32_stereo_sse;
#           endif
            done = 1;
        }
#       endif
#       ifdef OPT_SSE_VINTAGE
        if(   !done && (auto_choose || want_dec == sse_vintage)
           && cpu_sse(cpu_flags) && cpu_mmx(cpu_flags) )
        {
            chosen = dn_sse_vintage;
            fr->cpu_opts.type = sse_vintage;
#           ifndef NO_16BIT
            fr->synths.plain[r_1to1][f_16] = synth_1to1_sse;
#           ifdef ACCURATE_ROUNDING
            fr->synths.stereo[r_1to1][f_16] = synth_1to1_stereo_sse;
#           endif
#           endif
#           ifndef NO_REAL
            fr->synths.plain[r_1to1][f_real] = synth_1to1_real_sse;
            fr->synths.stereo[r_1to1][f_real] = synth_1to1_real_stereo_sse;
#           endif
#           ifndef NO_32BIT
            fr->synths.plain[r_1to1][f_32] = synth_1to1_s32_sse;
            fr->synths.stereo[r_1to1][f_32] = synth_1to1_s32_stereo_sse;
#           endif
            done = 1;
        }
#       endif
#       ifdef OPT_3DNOWEXT
        if(   !done && (auto_choose || want_dec == dreidnowext)
           && cpu_3dnow(cpu_flags)
           && cpu_3dnowext(cpu_flags)
           && cpu_mmx(cpu_flags) )
        {
            chosen = dn_dreidnowext;
            fr->cpu_opts.type = dreidnowext;
#           ifndef NO_16BIT
            fr->synths.plain[r_1to1][f_16] = synth_1to1_3dnowext;
#           endif
            done = 1;
        }
#       endif
#       ifdef OPT_3DNOWEXT_VINTAGE
        if(   !done && (auto_choose || want_dec == dreidnowext_vintage)
           && cpu_3dnow(cpu_flags)
           && cpu_3dnowext(cpu_flags)
           && cpu_mmx(cpu_flags) )
        {
            chosen = dn_dreidnowext_vintage;
            fr->cpu_opts.type = dreidnowext_vintage;
#ifdef OPT_MULTI
#           ifndef NO_LAYER3
            fr->cpu_opts.the_dct36 = dct36_3dnowext;
#           endif
#endif
#           ifndef NO_16BIT
            fr->synths.plain[r_1to1][f_16] = synth_1to1_3dnowext;
#           endif
            done = 1;
        }
#       endif
#       ifdef OPT_3DNOW
        if(    !done && (auto_choose || want_dec == dreidnow)
            && cpu_3dnow(cpu_flags) && cpu_mmx(cpu_flags) )
        {
            chosen = dn_dreidnow;
            fr->cpu_opts.type = dreidnow;
#           ifndef NO_16BIT
            fr->synths.plain[r_1to1][f_16] = synth_1to1_3dnow;
#           endif
            done = 1;
        }
#       endif
#       ifdef OPT_3DNOW_VINTAGE
        if(    !done && (auto_choose || want_dec == dreidnow_vintage)
            && cpu_3dnow(cpu_flags) && cpu_mmx(cpu_flags) )
        {
            chosen = dn_dreidnow_vintage;
            fr->cpu_opts.type = dreidnow_vintage;
#ifdef OPT_MULTI
#           ifndef NO_LAYER3
            fr->cpu_opts.the_dct36 = dct36_3dnow;
#           endif
#endif
#           ifndef NO_16BIT
            fr->synths.plain[r_1to1][f_16] = synth_1to1_3dnow;
#           endif
            done = 1;
        }
#       endif
        #ifdef OPT_MMX
        if(   !done && (auto_choose || want_dec == mmx)
           && cpu_mmx(cpu_flags) )
        {
            chosen = dn_mmx;
            fr->cpu_opts.type = mmx;
#           ifndef NO_16BIT
            fr->synths.plain[r_1to1][f_16] = synth_1to1_mmx;
#           endif
            done = 1;
        }
        #endif
        #ifdef OPT_I586
        if(!done && (auto_choose || want_dec == ifuenf))
        {
            chosen = "i586/pentium";
            fr->cpu_opts.type = ifuenf;
#           ifndef NO_16BIT
            fr->synths.plain[r_1to1][f_16] = synth_1to1_i586;
#           endif
            done = 1;
        }
        #endif
        #ifdef OPT_I586_DITHER
        if(!done && (auto_choose || want_dec == ifuenf_dither))
        {
            chosen = "dithered i586/pentium";
            fr->cpu_opts.type = ifuenf_dither;
            dithered = TRUE;
#           ifndef NO_16BIT
            fr->synths.plain[r_1to1][f_16] = synth_1to1_i586_dither;
#           ifndef NO_DOWNSAMPLE
            fr->synths.plain[r_2to1][f_16] = synth_2to1_dither;
            fr->synths.plain[r_4to1][f_16] = synth_4to1_dither;
#           endif
#           endif
            done = 1;
        }
        #endif
    }
    #ifdef OPT_I486
    /* That won't cooperate in multi opt mode - forcing i486 in layer3.c
       But still... here it is... maybe for real use in future. */
    if(!done && (auto_choose || want_dec == ivier))
    {
        chosen = dn_ivier;
        fr->cpu_opts.type = ivier;
        done = 1;
    }
    #endif
    #ifdef OPT_I386
    if(!done && (auto_choose || want_dec == idrei))
    {
        chosen = dn_idrei;
        fr->cpu_opts.type = idrei;
        done = 1;
    }
    #endif
 
    if(done)
    {
        /*
            We have chosen some x86 decoder... fillup some i386 stuff.
            There is an open question about using dithered synth_1to1 for 8bit wrappers.
            For quality it won't make sense, but wrapped i586_dither wrapped may still be faster...
        */
        enum synth_resample ri;
        enum synth_format   fi;
#       ifndef NO_8BIT
#       ifndef NO_16BIT /* possibility to use a 16->8 wrapper... */
        if(fr->synths.plain[r_1to1][f_16] != synth_base.plain[r_1to1][f_16])
        {
            fr->synths.plain[r_1to1][f_8] = synth_1to1_8bit_wrap;
            fr->synths.mono[r_1to1][f_8] = synth_1to1_8bit_wrap_mono;
            fr->synths.mono2stereo[r_1to1][f_8] = synth_1to1_8bit_wrap_m2s;
        }
#       endif
#       endif
        for(ri=0; ri<r_limit; ++ri)
        for(fi=0; fi<f_limit; ++fi)
        {
            if(fr->synths.plain[ri][fi] == synth_base.plain[ri][fi])
            fr->synths.plain[ri][fi] = plain_i386[ri][fi];
        }
    }
 
#endif /* OPT_X86 */
 
#ifdef OPT_AVX
    if(!done && (auto_choose || want_dec == avx) && cpu_avx(cpu_flags))
    {
        chosen = "x86-64 (AVX)";
        fr->cpu_opts.type = avx;
#ifdef OPT_MULTI
#       ifndef NO_LAYER3
        fr->cpu_opts.the_dct36 = dct36_avx;
#       endif
#endif
#       ifndef NO_16BIT
        fr->synths.plain[r_1to1][f_16] = synth_1to1_avx;
        fr->synths.stereo[r_1to1][f_16] = synth_1to1_stereo_avx;
#       endif
#       ifndef NO_REAL
        fr->synths.plain[r_1to1][f_real] = synth_1to1_real_avx;
        fr->synths.stereo[r_1to1][f_real] = synth_1to1_fltst_avx;
#       endif
#       ifndef NO_32BIT
        fr->synths.plain[r_1to1][f_32] = synth_1to1_s32_avx;
        fr->synths.stereo[r_1to1][f_32] = synth_1to1_s32_stereo_avx;
#       endif
        done = 1;
    }
#endif
 
#ifdef OPT_X86_64
    if(!done && (auto_choose || want_dec == x86_64))
    {
        chosen = "x86-64 (SSE)";
        fr->cpu_opts.type = x86_64;
#ifdef OPT_MULTI
#       ifndef NO_LAYER3
        fr->cpu_opts.the_dct36 = dct36_x86_64;
#       endif
#endif
#       ifndef NO_16BIT
        fr->synths.plain[r_1to1][f_16] = synth_1to1_x86_64;
        fr->synths.stereo[r_1to1][f_16] = synth_1to1_stereo_x86_64;
#       endif
#       ifndef NO_REAL
        fr->synths.plain[r_1to1][f_real] = synth_1to1_real_x86_64;
        fr->synths.stereo[r_1to1][f_real] = synth_1to1_real_stereo_x86_64;
#       endif
#       ifndef NO_32BIT
        fr->synths.plain[r_1to1][f_32] = synth_1to1_s32_x86_64;
        fr->synths.stereo[r_1to1][f_32] = synth_1to1_s32_stereo_x86_64;
#       endif
        done = 1;
    }
#endif
 
#   ifdef OPT_ALTIVEC
    if(!done && (auto_choose || want_dec == altivec))
    {
        chosen = dn_altivec;
        fr->cpu_opts.type = altivec;
#       ifndef NO_16BIT
        fr->synths.plain[r_1to1][f_16] = synth_1to1_altivec;
        fr->synths.stereo[r_1to1][f_16] = synth_1to1_stereo_altivec;
#       endif
#       ifndef NO_REAL
        fr->synths.plain[r_1to1][f_real] = synth_1to1_real_altivec;
        fr->synths.stereo[r_1to1][f_real] = synth_1to1_fltst_altivec;
#       endif
#       ifndef NO_32BIT
        fr->synths.plain[r_1to1][f_32] = synth_1to1_s32_altivec;
        fr->synths.stereo[r_1to1][f_32] = synth_1to1_s32_stereo_altivec;
#       endif
        done = 1;
    }
#   endif
 
#   ifdef OPT_NEON
    if(!done && (auto_choose || want_dec == neon) && cpu_neon(cpu_flags))
    {
        chosen = dn_neon;
        fr->cpu_opts.type = neon;
#ifdef OPT_MULTI
#       ifndef NO_LAYER3
        fr->cpu_opts.the_dct36 = dct36_neon;
#       endif
#endif
#       ifndef NO_16BIT
        fr->synths.plain[r_1to1][f_16] = synth_1to1_neon;
        fr->synths.stereo[r_1to1][f_16] = synth_1to1_stereo_neon;
#       endif
#       ifndef NO_REAL
        fr->synths.plain[r_1to1][f_real] = synth_1to1_real_neon;
        fr->synths.stereo[r_1to1][f_real] = synth_1to1_real_stereo_neon;
#       endif
#       ifndef NO_32BIT
        fr->synths.plain[r_1to1][f_32] = synth_1to1_s32_neon;
        fr->synths.stereo[r_1to1][f_32] = synth_1to1_s32_stereo_neon;
#       endif
        done = 1;
    }
#   endif
 
#   ifdef OPT_ARM
    if(!done && (auto_choose || want_dec == arm))
    {
        chosen = dn_arm;
        fr->cpu_opts.type = arm;
#       ifndef NO_16BIT
        fr->synths.plain[r_1to1][f_16] = synth_1to1_arm;
#       endif
        done = 1;
    }
#   endif
 
#   ifdef OPT_NEON64
    if(!done && (auto_choose || want_dec == neon64) && cpu_neon(cpu_flags))
    {
        chosen = dn_neon64;
        fr->cpu_opts.type = neon64;
#ifdef OPT_MULTI
#       ifndef NO_LAYER3
        fr->cpu_opts.the_dct36 = dct36_neon64;
#       endif
#endif
#       ifndef NO_16BIT
        fr->synths.plain[r_1to1][f_16] = synth_1to1_neon64;
        fr->synths.stereo[r_1to1][f_16] = synth_1to1_stereo_neon64;
#       endif
#       ifndef NO_REAL
        fr->synths.plain[r_1to1][f_real] = synth_1to1_real_neon64;
        fr->synths.stereo[r_1to1][f_real] = synth_1to1_fltst_neon64;
#       endif
#       ifndef NO_32BIT
        fr->synths.plain[r_1to1][f_32] = synth_1to1_s32_neon64;
        fr->synths.stereo[r_1to1][f_32] = synth_1to1_s32st_neon64;
#       endif
        done = 1;
    }
#   endif
 
#   ifdef OPT_GENERIC
    if(!done && (auto_choose || want_dec == generic))
    {
        chosen = dn_generic;
        fr->cpu_opts.type = generic;
        done = 1;
    }
#   endif
 
#ifdef OPT_GENERIC_DITHER
    if(!done && (auto_choose || want_dec == generic_dither))
    {
        chosen = "dithered generic";
        fr->cpu_opts.type = generic_dither;
        dithered = TRUE;
#       ifndef NO_16BIT
        fr->synths.plain[r_1to1][f_16] = synth_1to1_dither;
#       ifndef NO_DOWNSAMPLE
        fr->synths.plain[r_2to1][f_16] = synth_2to1_dither;
        fr->synths.plain[r_4to1][f_16] = synth_4to1_dither;
#       endif
#       endif
        done = 1;
    }
#endif
 
    fr->cpu_opts.class = decclass(fr->cpu_opts.type);
 
#   ifndef NO_8BIT
#   ifndef NO_16BIT /* possibility to use a 16->8 wrapper... */
    /* Last chance to use some optimized routine via generic wrappers (for 8bit). */
    if(     fr->cpu_opts.type != ifuenf_dither
         && fr->cpu_opts.type != generic_dither
         && fr->synths.plain[r_1to1][f_16] != synth_base.plain[r_1to1][f_16] )
    {
        fr->synths.plain[r_1to1][f_8] = synth_1to1_8bit_wrap;
        fr->synths.mono[r_1to1][f_8] = synth_1to1_8bit_wrap_mono;
        fr->synths.mono2stereo[r_1to1][f_8] = synth_1to1_8bit_wrap_m2s;
    }
#   endif
#   endif
 
#ifdef OPT_DITHER
    if(done && dithered)
    {
        /* run-time dither noise table generation */
        if(!frame_dither_init(fr))
        {
            if(NOQUIET) error("Dither noise setup failed!");
            return 0;
        }
    }
#endif
 
    if(done)
    {
        if(VERBOSE) fprintf(stderr, "Decoder: %s\n", chosen);
        return 1;
    }
    else
    {
        if(NOQUIET) error("Could not set optimization!");
        return 0;
    }
}

set_synth_functions()

int set_synth_functions

(

mpg123_handle *

fr

)

Definition at line 363 of file optimize.c.

{
    enum synth_resample resample = r_none;
    enum synth_format basic_format = f_none; /* Default is always 16bit, or whatever. */
 
    /* Select the basic output format, different from 16bit: 8bit, real. */
    if(FALSE){}
#ifndef NO_16BIT
    else if(fr->af.dec_enc & MPG123_ENC_16)
    basic_format = f_16;
#endif
#ifndef NO_8BIT
    else if(fr->af.dec_enc & MPG123_ENC_8)
    basic_format = f_8;
#endif
#ifndef NO_REAL
    else if(fr->af.dec_enc & MPG123_ENC_FLOAT)
    basic_format = f_real;
#endif
#ifndef NO_32BIT
    /* 24 bit integer means decoding to 32 bit first. */
    else if(fr->af.dec_enc & MPG123_ENC_32 || fr->af.dec_enc & MPG123_ENC_24)
    basic_format = f_32;
#endif
 
    /* Make sure the chosen format is compiled into this lib. */
    if(basic_format == f_none)
    {
        if(NOQUIET) error("set_synth_functions: This output format is disabled in this build!");
 
        return -1;
    }
 
    /* Be explicit about downsampling variant. */
    switch(fr->down_sample)
    {
        case 0: resample = r_1to1; break;
#ifndef NO_DOWNSAMPLE
        case 1: resample = r_2to1; break;
        case 2: resample = r_4to1; break;
#endif
#ifndef NO_NTOM
        case 3: resample = r_ntom; break;
#endif
    }
 
    if(resample == r_none)
    {
        if(NOQUIET) error("set_synth_functions: This resampling mode is not supported in this build!");
 
        return -1;
    }
 
    debug2("selecting synth: resample=%i format=%i", resample, basic_format);
    /* Finally selecting the synth functions for stereo / mono. */
    fr->synth = fr->synths.plain[resample][basic_format];
    fr->synth_stereo = fr->synths.stereo[resample][basic_format];
    fr->synth_mono = fr->af.channels==2
        ? fr->synths.mono2stereo[resample][basic_format] /* Mono MPEG file decoded to stereo. */
        : fr->synths.mono[resample][basic_format];       /* Mono MPEG file decoded to mono. */
 
    if(find_dectype(fr) != MPG123_OK) /* Actually determine the currently active decoder breed. */
    {
        fr->err = MPG123_BAD_DECODER_SETUP;
        return MPG123_ERR;
    }
 
    if(frame_buffers(fr) != 0)
    {
        fr->err = MPG123_NO_BUFFERS;
        if(NOQUIET) error("Failed to set up decoder buffers!");
 
        return MPG123_ERR;
    }
 
#ifndef NO_8BIT
    if(basic_format == f_8)
    {
        if(make_conv16to8_table(fr) != 0)
        {
            if(NOQUIET) error("Failed to set up conv16to8 table!");
            /* it's a bit more work to get proper error propagation up */
            return -1;
        }
    }
#endif
 
#ifdef OPT_MMXORSSE
    /* Special treatment for MMX, SSE and 3DNowExt stuff.
       The real-decoding SSE for x86-64 uses normal tables! */
    if(fr->cpu_opts.class == mmxsse
#   ifndef NO_REAL
       && basic_format != f_real
#   endif
#   ifndef NO_32BIT
       && basic_format != f_32
#   endif
#   ifdef ACCURATE_ROUNDING
       && fr->cpu_opts.type != sse
       && fr->cpu_opts.type != sse_vintage
       && fr->cpu_opts.type != x86_64
       && fr->cpu_opts.type != neon
       && fr->cpu_opts.type != neon64
       && fr->cpu_opts.type != avx
#   endif
      )
    {
#ifndef NO_LAYER3
        init_layer3_stuff(fr, init_layer3_gainpow2_mmx);
#endif
#ifndef NO_LAYER12
        init_layer12_stuff(fr, init_layer12_table_mmx);
#endif
        fr->make_decode_tables = make_decode_tables_mmx;
    }
    else
#endif
    {
#ifndef NO_LAYER3
        init_layer3_stuff(fr, init_layer3_gainpow2);
#endif
#ifndef NO_LAYER12
        init_layer12_stuff(fr, init_layer12_table);
#endif
        fr->make_decode_tables = make_decode_tables;
    }
 
    /* We allocated the table buffers just now, so (re)create the tables. */
    fr->make_decode_tables(fr);
 
    return 0;
}