optimize.c

Go to the documentation of this file.

/*
    optimize: get a grip on the different optimizations

    copyright 2006-9 by the mpg123 project - free software under the terms of the LGPL 2.1
    see COPYING and AUTHORS files in distribution or http://mpg123.org
    initially written by Thomas Orgis, inspired by 3DNow stuff in mpg123.[hc]

    Currently, this file contains the struct and function to choose an optimization variant and works only when OPT_MULTI is in effect.
*/

#include "mpg123lib_intern.h" /* includes optimize.h */
#include "debug.h"

/* Must match the enum dectype! */

/*
    It SUCKS having to define these names that way, but compile-time intialization of string arrays is a bitch.
    GCC doesn't see constant stuff when it's wiggling in front of it!
    Anyhow: Have a script for that:
names="generic generic_dither i386 i486 i586 i586_dither MMX 3DNow 3DNowExt AltiVec SSE x86-64"
for i in $names; do echo "##define dn_${i/-/_} \"$i\""; done
echo -n "static const char* decname[] =
{
    \"auto\"
    "
for i in $names; do echo -n ", dn_${i/-/_}"; done
echo "
    , \"nodec\"
};"
*/
#define dn_generic "generic"
#define dn_generic_dither "generic_dither"
#define dn_i386 "i386"
#define dn_i486 "i486"
#define dn_i586 "i586"
#define dn_i586_dither "i586_dither"
#define dn_MMX "MMX"
#define dn_3DNow "3DNow"
#define dn_3DNowExt "3DNowExt"
#define dn_AltiVec "AltiVec"
#define dn_SSE "SSE"
#define dn_x86_64 "x86-64"
#define dn_ARM "ARM"
static const char* decname[] =
{
    "auto"
    , dn_generic, dn_generic_dither, dn_i386, dn_i486, dn_i586, dn_i586_dither, dn_MMX, dn_3DNow, dn_3DNowExt, dn_AltiVec, dn_SSE, dn_x86_64, dn_ARM
    , "nodec"
};

#if (defined OPT_X86) && (defined OPT_MULTI)
#include "getcpuflags.h"
struct cpuflags cpu_flags;
#else
/* Faking stuff for non-multi builds. The same code for synth function choice is used.
   Just no runtime dependency of result... */
char cpu_flags;
#define cpu_i586(s)     1
#define cpu_fpu(s)      1
#define cpu_mmx(s)      1
#define cpu_3dnow(s)    1
#define cpu_3dnowext(s) 1
#define cpu_sse(s)      1
#define cpu_sse2(s)     1
#define cpu_sse3(s)     1
#endif

/* Ugly macros to build conditional synth function array values. */

#ifndef NO_8BIT
#define IF8(synth) synth,
#else
#define IF8(synth)
#endif

#ifndef NO_REAL
#define IFREAL(synth) synth,
#else
#define IFREAL(synth)
#endif

#ifndef NO_32BIT
#define IF32(synth) synth
#else
#define IF32(synth)
#endif

#ifndef NO_16BIT
#   define OUT_SYNTHS(synth_16, synth_8, synth_real, synth_32) { synth_16, IF8(synth_8) IFREAL(synth_real) IF32(synth_32) }
#else
#   define OUT_SYNTHS(synth_16, synth_8, synth_real, synth_32) { IF8(synth_8) IFREAL(synth_real) IF32(synth_32) }
#endif

/* The call of left and right plain synth, wrapped.
   This may be replaced by a direct stereo optimized synth. */
int synth_stereo_wrap(real *bandPtr_l, real *bandPtr_r, mpg123_handle *fr)
{
    int clip;
    clip  = (fr->synth)(bandPtr_l, 0, fr, 0);
    clip += (fr->synth)(bandPtr_r, 1, fr, 1);
    return clip;
}

const struct synth_s synth_base =
{
    { /* plain */
         OUT_SYNTHS(synth_1to1, synth_1to1_8bit, synth_1to1_real, synth_1to1_s32)
#       ifndef NO_DOWNSAMPLE
        ,OUT_SYNTHS(synth_2to1, synth_2to1_8bit, synth_2to1_real, synth_2to1_s32)
        ,OUT_SYNTHS(synth_4to1, synth_4to1_8bit, synth_4to1_real, synth_4to1_s32)
#       endif
#       ifndef NO_NTOM
        ,OUT_SYNTHS(synth_ntom, synth_ntom_8bit, synth_ntom_real, synth_ntom_s32)
#       endif
    },
    { /* stereo, by default only wrappers over plain synth */
         OUT_SYNTHS(synth_stereo_wrap, synth_stereo_wrap, synth_stereo_wrap, synth_stereo_wrap)
#       ifndef NO_DOWNSAMPLE
        ,OUT_SYNTHS(synth_stereo_wrap, synth_stereo_wrap, synth_stereo_wrap, synth_stereo_wrap)
        ,OUT_SYNTHS(synth_stereo_wrap, synth_stereo_wrap, synth_stereo_wrap, synth_stereo_wrap)
#       endif
#       ifndef NO_NTOM
        ,OUT_SYNTHS(synth_stereo_wrap, synth_stereo_wrap, synth_stereo_wrap, synth_stereo_wrap)
#       endif
    },
    { /* mono2stereo */
         OUT_SYNTHS(synth_1to1_mono2stereo, synth_1to1_8bit_mono2stereo, synth_1to1_real_mono2stereo, synth_1to1_s32_mono2stereo)
#       ifndef NO_DOWNSAMPLE
        ,OUT_SYNTHS(synth_2to1_mono2stereo, synth_2to1_8bit_mono2stereo, synth_2to1_real_mono2stereo, synth_2to1_s32_mono2stereo)
        ,OUT_SYNTHS(synth_4to1_mono2stereo, synth_4to1_8bit_mono2stereo, synth_4to1_real_mono2stereo, synth_4to1_s32_mono2stereo)
#       endif
#       ifndef NO_NTOM
        ,OUT_SYNTHS(synth_ntom_mono2stereo, synth_ntom_8bit_mono2stereo, synth_ntom_real_mono2stereo, synth_ntom_s32_mono2stereo)
#       endif
    },
    { /* mono*/
         OUT_SYNTHS(synth_1to1_mono, synth_1to1_8bit_mono, synth_1to1_real_mono, synth_1to1_s32_mono)
#       ifndef NO_DOWNSAMPLE
        ,OUT_SYNTHS(synth_2to1_mono, synth_2to1_8bit_mono, synth_2to1_real_mono, synth_2to1_s32_mono)
        ,OUT_SYNTHS(synth_4to1_mono, synth_4to1_8bit_mono, synth_4to1_real_mono, synth_4to1_s32_mono)
#       endif
#       ifndef NO_NTOM
        ,OUT_SYNTHS(synth_ntom_mono, synth_ntom_8bit_mono, synth_ntom_real_mono, synth_ntom_s32_mono)
#endif
    }
};

#ifdef OPT_X86
/* More plain synths for i386 */
const func_synth plain_i386[r_limit][f_limit] =
{ /* plain */
     OUT_SYNTHS(synth_1to1_i386, synth_1to1_8bit_i386, synth_1to1_real_i386, synth_1to1_s32_i386)
#   ifndef NO_DOWNSAMPLE
    ,OUT_SYNTHS(synth_2to1_i386, synth_2to1_8bit_i386, synth_2to1_real_i386, synth_2to1_s32_i386)
    ,OUT_SYNTHS(synth_4to1_i386, synth_4to1_8bit_i386, synth_4to1_real_i386, synth_4to1_s32_i386)
#   endif
#   ifndef NO_NTOM
    ,OUT_SYNTHS(synth_ntom, synth_ntom_8bit, synth_ntom_real, synth_ntom_s32)
#   endif
};
#endif


enum optdec defdec(void){ return defopt; }

enum optcla decclass(const enum optdec type)
{
    return (type == mmx || type == sse || type == dreidnowext || type == x86_64 ) ? mmxsse : normal;
}


static int find_synth(func_synth synth,  const func_synth synths[r_limit][f_limit])
{
    enum synth_resample ri;
    enum synth_format   fi;
    for(ri=0; ri<r_limit; ++ri)
    for(fi=0; fi<f_limit; ++fi)
    if(synth == synths[ri][fi])
    return TRUE;

    return FALSE;
}

/* Determine what kind of decoder is actually active
   This depends on runtime choices which may cause fallback to i386 or generic code. */
static int find_dectype(mpg123_handle *fr)
{
    enum optdec type = nodec;
    /* Direct and indirect usage, 1to1 stereo decoding.
       Concentrating on the plain stereo synth should be fine, mono stuff is derived. */
    func_synth basic_synth = fr->synth;
#ifndef NO_8BIT
#ifndef NO_16BIT
    if(basic_synth == synth_1to1_8bit_wrap)
    basic_synth = fr->synths.plain[r_1to1][f_16]; /* That is what's really below the surface. */
#endif
#endif

    if(FALSE) ; /* Just to initialize the else if ladder. */
#ifndef NO_16BIT
#ifdef OPT_3DNOWEXT
    else if(basic_synth == synth_1to1_3dnowext) type = dreidnowext;
#endif
#ifdef OPT_SSE
    else if(basic_synth == synth_1to1_sse) type = sse;
#endif
#ifdef OPT_3DNOW
    else if(basic_synth == synth_1to1_3dnow) type = dreidnow;
#endif
#ifdef OPT_MMX
    else if(basic_synth == synth_1to1_mmx) type = mmx;
#endif
#ifdef OPT_I586_DITHER
    else if(basic_synth == synth_1to1_i586_dither) type = ifuenf_dither;
#endif
#ifdef OPT_I586
    else if(basic_synth == synth_1to1_i586) type = ifuenf;
#endif
#ifdef OPT_ALTIVEC
    else if(basic_synth == synth_1to1_altivec) type = altivec;
#endif
#ifdef OPT_X86_64
    else if(basic_synth == synth_1to1_x86_64) type = x86_64;
#endif
#ifdef OPT_ARM
    else if(basic_synth == synth_1to1_arm) type = arm;
#endif
#ifdef OPT_GENERIC_DITHER
    else if(basic_synth == synth_1to1_dither) type = generic_dither;
#endif
#ifdef OPT_DITHER /* either i586 or generic! */
#ifndef NO_DOWNSAMPLE
    else if
    (
           basic_synth == synth_2to1_dither
        || basic_synth == synth_4to1_dither
    ) type = generic_dither;
#endif
#endif
#endif /* 16bit */

#ifndef NO_REAL
#ifdef OPT_SSE
    else if(basic_synth == synth_1to1_real_sse) type = sse;
#endif
#ifdef OPT_X86_64
    else if(basic_synth == synth_1to1_real_x86_64) type = x86_64;
#endif
#ifdef OPT_ALTIVEC
    else if(basic_synth == synth_1to1_real_altivec) type = altivec;
#endif

#endif /* real */

#ifndef NO_32BIT
#ifdef OPT_SSE
    else if(basic_synth == synth_1to1_s32_sse) type = sse;
#endif
#ifdef OPT_X86_64
    else if(basic_synth == synth_1to1_s32_x86_64) type = x86_64;
#endif
#ifdef OPT_ALTIVEC
    else if(basic_synth == synth_1to1_s32_altivec) type = altivec;
#endif
#endif /* 32bit */

#ifdef OPT_X86
    else if(find_synth(basic_synth, plain_i386))
    type = idrei;
#endif

    else if(find_synth(basic_synth, synth_base.plain))
    type = generic;



#ifdef OPT_I486
    /* i486 is special ... the specific code is in use for 16bit 1to1 stereo
       otherwise we have i386 active... but still, the distinction doesn't matter*/
    type = ivier;
#endif

    if(type != nodec)
    {
        fr->cpu_opts.type = type;
        fr->cpu_opts.class = decclass(type);

        debug3("determined active decoder type %i (%s) of class %i", type, decname[type], fr->cpu_opts.class);
        return MPG123_OK;
    }
    else
    {
        if(NOQUIET) error("Unable to determine active decoder type -- this is SERIOUS b0rkage!");

        fr->err = MPG123_BAD_DECODER_SETUP;
        return MPG123_ERR;
    }
}

/* set synth functions for current frame, optimizations handled by opt_* macros */
int set_synth_functions(mpg123_handle *fr)
{
    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.encoding & MPG123_ENC_16)
    basic_format = f_16;
#endif
#ifndef NO_8BIT
    else if(fr->af.encoding & MPG123_ENC_8)
    basic_format = f_8;
#endif
#ifndef NO_REAL
    else if(fr->af.encoding & MPG123_ENC_FLOAT)
    basic_format = f_real;
#endif
#ifndef NO_32BIT
    else if(fr->af.encoding & MPG123_ENC_32)
    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 != x86_64
#   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;
}

int frame_cpu_opt(mpg123_handle *fr, const char* cpu)
{
    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;
    /* covers any i386+ cpu; they actually differ only in the synth_1to1 function, mostly... */
#ifdef OPT_X86

#ifdef OPT_MULTI
#ifndef NO_LAYER3
#if (defined OPT_3DNOW || defined OPT_3DNOWEXT)
    fr->cpu_opts.the_dct36 = dct36;
#endif
#endif
#endif

    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 = "SSE";
            fr->cpu_opts.type = sse;
#           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 = "3DNowExt";
            fr->cpu_opts.type = dreidnowext;
#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 = "3DNow";
            fr->cpu_opts.type = dreidnow;
#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 = "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 = "i486";
        fr->cpu_opts.type = ivier;
        done = 1;
    }
    #endif
    #ifdef OPT_I386
    if(!done && (auto_choose || want_dec == idrei))
    {
        chosen = "i386";
        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_mono2stereo;
        }
#       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_X86_64
    if(!done && (auto_choose || want_dec == x86_64))
    {
        chosen = "x86-64 (SSE)";
        fr->cpu_opts.type = x86_64;
#       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_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

#   ifdef OPT_ALTIVEC
    if(!done && (auto_choose || want_dec == altivec))
    {
        chosen = "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_real_stereo_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_ARM
    if(!done && (auto_choose || want_dec == arm))
    {
        chosen = "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_GENERIC
    if(!done && (auto_choose || want_dec == generic))
    {
        chosen = "generic";
        fr->cpu_opts.type = generic;
        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_mono2stereo;
    }
#   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;
    }
}

enum optdec dectype(const char* decoder)
{
    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... */
}

#ifdef OPT_MULTI

/* same number of entries as full list, but empty at beginning */
static const char *mpg123_supported_decoder_list[] =
{
    #ifdef OPT_SSE
    NULL,
    #endif
    #ifdef OPT_3DNOWEXT
    NULL,
    #endif
    #ifdef OPT_3DNOW
    NULL,
    #endif
    #ifdef OPT_MMX
    NULL,
    #endif
    #ifdef OPT_I586
    NULL,
    #endif
    #ifdef OPT_I586_DITHER
    NULL,
    #endif
    #ifdef OPT_I486
    NULL,
    #endif
    #ifdef OPT_I386
    NULL,
    #endif
    #ifdef OPT_ALTIVEC
    NULL,
    #endif
    #ifdef OPT_X86_64
    NULL,
    #endif
    #ifdef OPT_ARM
    NULL,
    #endif
    #ifdef OPT_GENERIC_FLOAT
    NULL,
    #endif
#   ifdef OPT_GENERIC
    NULL,
#   endif
#   ifdef OPT_GENERIC_DITHER
    NULL,
#   endif
    NULL
};
#endif

static const char *mpg123_decoder_list[] =
{
    #ifdef OPT_SSE
    dn_SSE,
    #endif
    #ifdef OPT_3DNOWEXT
    dn_3DNowExt,
    #endif
    #ifdef OPT_3DNOW
    dn_3DNow,
    #endif
    #ifdef OPT_MMX
    dn_MMX,
    #endif
    #ifdef OPT_I586
    dn_i586,
    #endif
    #ifdef OPT_I586_DITHER
    dn_i586_dither,
    #endif
    #ifdef OPT_I486
    dn_i486,
    #endif
    #ifdef OPT_I386
    dn_i386,
    #endif
    #ifdef OPT_ALTIVEC
    dn_AltiVec,
    #endif
    #ifdef OPT_X86_64
    dn_x86_64,
    #endif
    #ifdef OPT_ARM
    dn_ARM,
    #endif
    #ifdef OPT_GENERIC
    dn_generic,
    #endif
    #ifdef OPT_GENERIC_DITHER
    dn_generic_dither,
    #endif
    NULL
};

void check_decoders(void )
{
#ifndef OPT_MULTI
    /* In non-multi mode, only the full list (one entry) is used. */
    return;
#else
    const char **d = mpg123_supported_decoder_list;
#ifdef OPT_X86
    getcpuflags(&cpu_flags);
    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++) = decname[sse];
#endif
#ifdef OPT_3DNOWEXT
        if(cpu_3dnowext(cpu_flags)) *(d++) = decname[dreidnowext];
#endif
#ifdef OPT_3DNOW
        if(cpu_3dnow(cpu_flags)) *(d++) = decname[dreidnow];
#endif
#ifdef OPT_MMX
        if(cpu_mmx(cpu_flags)) *(d++) = decname[mmx];
#endif
#ifdef OPT_I586
        *(d++) = decname[ifuenf];
#endif
#ifdef OPT_I586_DITHER
        *(d++) = decname[ifuenf_dither];
#endif
    }
#endif
/* just assume that the i486 built is run on a i486 cpu... */
#ifdef OPT_I486
    *(d++) = decname[ivier];
#endif
#ifdef OPT_ALTIVEC
    *(d++) = decname[altivec];
#endif
/* every supported x86 can do i386, any cpu can do generic */
#ifdef OPT_I386
    *(d++) = decname[idrei];
#endif
#ifdef OPT_X86_64
    *(d++) = decname[x86_64];
#endif
#ifdef OPT_ARM
    *(d++) = decname[arm];
#endif
#ifdef OPT_GENERIC
    *(d++) = decname[generic];
#endif
#ifdef OPT_GENERIC_DITHER
    *(d++) = decname[generic_dither];
#endif
#endif /* ndef OPT_MULTI */
}

const char* attribute_align_arg mpg123_current_decoder(mpg123_handle *mh)
{
    if(mh == NULL) return NULL;

    return decname[mh->cpu_opts.type];
}

const char attribute_align_arg **mpg123_decoders(void){ return mpg123_decoder_list; }
const char attribute_align_arg **mpg123_supported_decoders(void)
{
#ifdef OPT_MULTI
    return mpg123_supported_decoder_list;
#else
    return mpg123_decoder_list;
#endif
}