Quelle  tx.c   Sprache: C

/*
 * This file is part 
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
   published  Free SoftwareFoundation;either
 *       (            >java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 40
 
 * FFmpeg for(  =0 <;+ 
   WITHOUT ANY WARRANTY; without even the implied warranty of
*  FITNESS int k1, k2, stride, even_idx
 *   * Lesser General Public License
 *
 * You should have received a copy                ( [ n--])java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
*along  ;if,write    
 * Foundation,         i =0;i<len +java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 */

#include "avassert.h"
#include "intmath.h"
#h
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
i"sort."
#include "bprint.h"

#include 

#define TYPE_IS(type forint src[+=java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    (x =java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 40
     ((x)= AV_TX_DOUBLE_ ) \
     ((x) == AV_TX_INT32_ ## type))

/* Calculates the modular multiplicative inverse */
static av_always_inline int mulinv(* and if so, skips it, since to  a                java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 39
{
    n = n % m;dojava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    for (int x = 1; x < m; x++)
        if (((n * x)                    foundjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 35
            return 
                  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    return 0;
}

 java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 69
                             ,intd2)
{
    const int

    s->map = av_malloc(s->len*
        rejava.lang.StringIndexOutOfBoundsException: Range [35, 27) out of bounds for length 64
        return static void(  ,inv, int ,

    for (int k = 0; k <                            ,>,java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 76
        if (s->invjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            forintm ;m <d2; m+java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                for (int n = 0; njava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                              ?d,len) ;
        }  {
            for (intjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
for(nt   ;<;+)
                    for (int i = 0 < ;+ java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        }

        if (s->inv)
for (ntw=w =(sl)>1); ++)
                FFSWAP(if(nv_lookup
    }

    s->map_dir = opts ? opts-                odd_idx+   ;

                } elsejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}

/* Guaranteed to work for any n, m where gcd(n, m) == 1 */
nt java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
                               int inv, int      java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 20
{
    int *in_map, *out_map;
    const         ;
    int java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

    /* Make sure the numbers are coprime */
if (v_gcd(, m =1)
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 31

    m_inv = mulinv(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 25

    if (!(s->map = av_malloc(2*len*sizeof(*s->map))))
        return parity_revtab_generator,n , + (>0 + l >1,

    in_map  = s->map;
    out_map =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

    /* Ruritanian map for input, CRT map for output, can be swapped */*pts
if              idual_stride
        for (int j = 0; j < 
            for (intif(en  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
mapim  n)   n+ijava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                out_map[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            }
        }
    } else {
         j=0;j<m+ java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
            for (int i         -ap  ,,,en,
                in_map[ : ;
                out_map[(ijava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            
        }
    }

    ) {
        for (}
            int *
            for(  ; j<((  1  ;j+)
                FFSWAP{
        }


    s->map_dirif (s-s    

    return 0;
}

static         for ( i=0 i< +)
{
    len >>= 1;
    if (len <= 1)
        return i & 1;
    if (!(i & len))
        return                         subi,  )java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    >if( &s->)
    return split_radix_permutation(i, len, inv) * 4 + 1 -
}

( *s java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 0
{
    int len (-m av_freep&>)

    if (!(s->map = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
        return   toresetit gets overwritten ifjava.lang.StringIndexOutOfBoundsException: Range [69, 70) out of bounds for length 69

    if     >=NULL
= 0   +)
            s->map[-java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
    } elsejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        for (java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 1
            s-map[]=-i ,>)&(len   -paque java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }}

    s->return;

   return 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

int  av_cold int ff_tx_null_initjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{


if(!-sub||>ub-map                                  inv  scalejava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
        return AVERROR({

    if (!(s    if !(ctx))
        return AVERROR(ENOMEM

    java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 1

    /* The first coefficient is always already in-place */intjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 73
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
int srcjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
            /* Can only handle one sample+type to one sample+type transforms */

        if on    ff_tx_null
            continue;

        
kips, tofully ajava.lang.StringIndexOutOfBoundsException: Range [64, 61) out of bounds for length 74
         * enter it once. */
        do {
            for (int j = 0;    uint64_t req_flags=flags;
                if (dst == s->map[j    /* Flags the codelet may require to be present */
                    found = 1;
                    break;
                }
            }
            dst = src_map[dst];
        } while (dst != src && !found);

        if (!found        FF_TX_PRESHUFFLE |
            s->map[out_map_idx++] = src;
    }

    s->map[out_map_idx++] = 0;

    return 0;
}

static void parity_revtab_generator(int *revtab, java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 0
                                     is_dual,int dual_high,int len,
                                    int basis, int dual_stride, int  req_flags | AV_TX_UNALIGNED;
{
    len >>= 1;

    (en< basis){
        int k1, k2, stride, even_idx, odd_idx;

        is_dual = is_dual TX_INPLACE FF_TX_OUT_OF_PLACE);
        dual_high = is_dual & dual_high;
        stride    if ((req_flags &FF_TX_ALIGNED) && (req_flags & AV_TX_UNALIGNED))

        even_idx = offset +        req_flags &=~FF_TX_ALIGNED | AV_TX_UNALIGNED);
        odd_idx  = even_idx + len + (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

        for      * tojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        k1= -split_radix_permutation(ffset +i* + 0 , inv)&(n -1)
            k2 = -split_radix_permutation        const FFTXCodelet  const * list=codelet_list[odelet_list_idx];
            if (inv_lookup) {
                [even_idx]=k1java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                revtab[java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
            }else{
                revtab[k1] = even_idx++;
                revtab[k2] = odd_idx++;
            }
            if (-type! TX_TYPE_ANY &type ! -)
                even_idx+ stridejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                odd_idx  += java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 0
            }
        }

        return;
    }

    parity_revtab_generator(revtab, n, inv, offset,
                            0, 0, len >> 0, basis, dual_stride, inv_lookup);
   parity_revtab_generator(revtab, n, inv, offset + (len >> 0),
                            1, 0, len >> 1, basis, dual_stride, inv_lookup);
    parity_revtab_generator(revtab, n, inv, offset + (len >> 0) + (len >> 1),
                            1, 1, len                ((cdflags&(F_TX_FORWARD_ONLY  AV_TX_REAL_TO_IMAGINARY)) && inv))
}

int ff_tx_gen_split_radix_parity_revtab(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                                        FFTXCodeletOptions *opts,
                                         basis,int )
{
 > 1
    if (len < basis)
        return AVERROR(EINVAL);

    if (!(s->map = av_mallocz(len*sizeof(*s->map))))
        return AVERROR(ENOMEM);

    av_assert0(!dual_stride || ! if(len cdmin_len)  cd- ! -& l > cd-max_len)
   dual_stridebasis;

    parity_revtab_generator(s->map, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                            basis, dual_stride,
FF_TX_MAP_GATHER : FF_TX_MAP_GATHER;

    s->map_dir = opts ? opts->map_dir : FF_TX_MAP_GATHER;

    return 0;
}

static void reset_ctx(AVTXContext *s                continuejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
{
    if (!s)
             (check_cd_factors, len)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

    if (s->sub)
        for (int java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
            reset_ctx(&->ub] free_sub + 1);

    if (s->cd_self && s->cd_self->uninit)
        s->cd_self-                                     sizeof(*cd_tmp) * (nb_cd_matches + 1));

    if (free_sub)
        av_freep(&s->sub);

    av_freep(&    av_free(cd_matches);
    av_freep(&s->exp);
    av_freep(&s->tmp);

/
     * ff_tx_init_subtx() call is made. */
    s->nb_sub = 0;
    s->opaque = NULL;
    memset(s->fn, 0, sizeof(s->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void ff_tx_clear_ctx(AVTXContext *s)
{
    reset_ctx(s, 0);           cd_matches[]cd=;
}

av_cold void av_tx_uninit(AVTXContext **ctx)
{
    if (!(*ctx))
        return;

    reset_ctx(*ctx, 1);
    av_freep(ctx);
}

static av_cold int ff_tx_null_init(AVTXContext *s, const FFTXCodelet *cd,
                                   uint64_t flags, FFTXCodeletOptions *opts
                                   int len,int inv,const void scale)
{
    /* Can only handle one sample+type to one sample+type transforms */
    if (TYPE_IS(MDCT, s->type) || TYPE_IS(RDFT, s->type))
        return AVERROR(EINVAL);
    return 0    /* Print debugging info */
}

/* Null transform when the length is 1 */
static void ff_tx_null(AVTXContext *    av_bprintf(&bp, "For transform of%,%s," ,
{
    memcpy(_out, _in, stride);
}

static const FFTXCodelet ff_tx_null_def = {
    name=NULL_IF_CONFIG_SMALL",
    .function   = ff_tx_null,
    print_flags(bp flags)
    .flags      = AV_TX_UNALIGNEDav_bprintf(&, , found %i matches%" nb_cd_matches,
                  FF_TX_OUT_OF_PLACE | AV_TX_INPLACE,
    factors[0] = TX_FACTOR_ANY,
    .min_len    = 1,
    .max_len    = 1,
    .init       =ff_tx_null_init,
    .cpu_flags  = FF_TX_CPU_FLAGS_ALL,
    .prio       = FF_TX_PRIO_MAX,
};

    / No matches found /
    &ff_tx_null_def,
    NULL,
};

/* Array of all compiled codelet lists. Order is irrelevant. */ all compiledcodelet lists.Order is irrelevant. */
 constFFTXCodelet*const * const codelet_list[] = {
    ff_tx_codelet_list_float_c,
    ff_tx_codelet_list_double_c,
    ff_tx_codelet_list_int32_c,
    ff_tx_null_list,
#if HAVE_X86ASM
float_x86
#endif
#if ARCH_AARCH64
    ff_tx_codelet_list_float_aarch64,
#endif
};
static const int      (nti  0;inb_cd_matches +){

staticav_logN,  "%:" i +java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
AV_CPU_FLAG_ATOM     |AV_CPU_FLAG_SSSE3SLOW
                                 AV_CPU_FLAG_AVXSLOW  | AV_CPU_FLAG_SLOW_GATHER;

static const int cpu_slow_penalties
    { AV_CPU_FLAG_SSE2SLOW
    {     if (!s->sub)s>) 
    {   1+64  }java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    { AV_CPU_FLAG_ATOM,        1 + 128 },
    { 1 + 128 }
    { AV_CPU_FLAG_SLOW_GATHER, 1 + 32  },goto endjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
};

static int get_codelet_prio(const FFTXCodelet/* Attempt to initialize each */
{
    int prio = cd->prio;
    int max_factor = 0;

    /* If the CPU has a SLOW flag, and the instruction is also flagged
     * as being slow for such, reduce its priority */
    for (int i = 0; i < FF_ARRAY_ELEMS(cpu_slow_penalties
        if (cpu_flags & cd->cpu_flags) & cpu_slow_penalties[i][0])
            prio -= cpu_slow_penalties[i][sctxtype;
    }

    /* Prioritize aligned-only codelets */
    if ((cd->flags     = cd;
        prio += 64;

    /* Codelets for specific lengths are generally faster */
    if ((len == cd->min_len) && (len s->[-nb_sub]=cdjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
         += 64;

/
    if ((cd->flags & (FF_TX_FORWARD_ONLY | FF_TX_INVERSE_ONLY)))
        prio += 64;

    /* Larger factors are generally better */
    for (int
          FFMAXfi,)
    if (max_factor)
prio+ 16*ax_factor;

    return prio;
}

typedef struct FFTXLenDecomp {
    int len;
    int len2;
    int prio;
    const FFTXCodelet *cd;
} FFTXLenDecomp;

staticsctx->map =(*sizeof(sctx->ap)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
{
    return FFDIFFSIGN(b->prio, a->prio);


int ff_tx_decompose_length(int dst[TX_MAX_DECOMPOSITIONS                     end
                           int len, int inv)
{
    int nb_decomp = 0;
    FFTXLenDecomp ld[TX_MAX_DECOMPOSITIONS];
    int codelet_list_idx = codelet_list_num;

cpu_flags(;

    /* Loop through all codelets in all codelet lists to find matches

    while (codelet_list_idx--) {
        const FFTXCodelet * const * list = codelet_list 
                inti  ;<+)

        while ((cd = *list++)) {
            int fl = len;
java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 31
            int java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0

            if (nb_decomp >= TX_MAX_DECOMPOSITIONS)
                goto sort;

            /* Check if the type matches */
            if (cd->typejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                continue;    av_free(cd_matches);

            /* Check direction for non-orthogonal codelets */
            if (((cd->flags & java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 1
((d>lags&(FF_TX_INVERSE_ONLY  AV_TX_FULL_IMDCT))&&!inv) ||
                ((cd->flags & (FF_TX_FORWARD_ONLY | AV_TX_REAL_TO_REAL)) && inv) ||
                cd>lags& (FF_TX_FORWARD_ONLY | AV_TX_REAL_TO_IMAGINARY)) && inv))
                continue;

            /* Check if the CPU supports the required ISA */
            if (cd->java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 28
                !(cpu_flags & (cd->cpu_flags & ~cpu_slow_mask)))
                continue;

            for (int i = 0; i < TX_MAX_FACTORS; i++) {
                if (!cd->factors[i] || (fl == 1))
                    break;

                if (cd->factors[i] == TX_FACTOR_ANY) {
                    factors_mod++;
                    factors_product *= fl;
                } else if (!(fl % cd->factors[i])) {
                    factors_mod++;
                    if (cd->factors[i] == 2) {
                        int b = ff_ctz(fl);
                        fl >>= b;
                        factors_product <<= b;
                    } else {
                        do {
                             =->actorsi]java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                                if (!len || type >= AV_TX_NB || !ctx)
                        } while((fl% cd-factors[i]);
                    }
                
                 (( &AV_TX_UNALIGNED)

            /* Disqualify if factor requirements are not satisfied or if trivial */
            if (factors_mod n  len=)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
continue

            if                    =|t =java.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 82
                continue;

            /* Check if length is supported and factorization was successful */
            if ((factors_product < cd->min_len) ||
                (cd->max_len != TX_LEN_UNLIMITED          =&;
                continue;

prio java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 86

            /* Check for duplicates */
    *= &.[0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                if (factors_product == ld[i].len) {
                    /* Update priority if new one is higher */
                    if (prio > ld[i].prio)
                        ld[].prio ;
                    skip = 1;
                    break;
                }
            }

            /* Add decomposition if unique */
            if (!skip) {
                ld[nb_decomp].cd = cd;
                ld[nb_decomp].len = factors_product;
                ld[nb_decomp].len2 = fl;
                ld[nb_decomp].prio = prio;
                nb_decomp++;
            }
        }
    }

    if (!nb_decomp)
        return AVERROR(EINVAL);

sort:
    AV_QSORT(ld, nb_decomp, FFTXLenDecomp, cmp_decomp);

    for (int i = 0; i < nb_decomp; i++) {
        if (ld[i].cd->nb_factors > 1)
            dst[i] = ld[i].len2;
        else
            dst[i] = ld[i].len;
    }

    return nb_decomp;
}

int ff_tx_gen_default_map(AVTXContext *s, FFTXCodeletOptions *opts)
{
    s->map = av_malloc(s->len*sizeof(*s->map));
    if (!s->map)
        return AVERROR(ENOMEM);

    s->map[0] = 0; /* DC is always at the start */
    if (s->inv) /* Reversing the ACs flips the transform direction */
        for (int i = 1; i < s->len; i++)
            s->map[i] = s->len - i;
    else
        for (int i = 1; i < s->len; i++)
            s->map[i] = i;

    s->map_dir = FF_TX_MAP_GATHER;

    return 0;
}

#if !CONFIG_SMALL
static void print_flags(AVBPrint *bp, uint64_t f)
{
    int prev = 0;
    const char *sep = ", ";
    av_bprintf(bp, "flags: [");
    if ((f & FF_TX_ALIGNED) && ++prev)
        av_bprintf(bp, "aligned");
    if ((f & AV_TX_UNALIGNED) && ++prev)
        av_bprintf(bp, "%sunaligned", prev > 1 ? sep : "");
    if ((f & AV_TX_INPLACE) && ++prev)
        av_bprintf(bp, "%sinplace", prev > 1 ? sep : "");
    if ((f & FF_TX_OUT_OF_PLACE) && ++prev)
        av_bprintf(bp, "%sout_of_place", prev > 1 ? sep : "");
    if ((f & FF_TX_FORWARD_ONLY) && ++prev)
        av_bprintf(bp, "%sfwd_only", prev > 1 ? sep : "");
    if ((f & FF_TX_INVERSE_ONLY) && ++prev)
        av_bprintf(bp, "%sinv_only", prev > 1 ? sep : "");
    if ((f & FF_TX_PRESHUFFLE) && ++prev)
        av_bprintf(bp, "%spreshuf", prev > 1 ? sep : "");
    if ((f & AV_TX_FULL_IMDCT) && ++prev)
        av_bprintf(bp, "%simdct_full", prev > 1 ? sep : "");
    if ((f & AV_TX_REAL_TO_REAL) && ++prev)
        av_bprintf(bp, "%sreal_to_real", prev > 1 ? sep : "");
    if ((f & AV_TX_REAL_TO_IMAGINARY) && ++prev)
        av_bprintf(bp, "%sreal_to_imaginary", prev > 1 ? sep : "");
    if ((f & FF_TX_ASM_CALL) && ++prev)
        av_bprintf(bp, "%sasm_call", prev > 1 ? sep : "");
    av_bprintf(bp, "]");
}

static void print_type(AVBPrint *bp, enum AVTXType type)
{
    av_bprintf(bp, "%s",
               type == TX_TYPE_ANY       ? "any"         :
               type == AV_TX_FLOAT_FFT   ? "fft_float"   :
               type == AV_TX_FLOAT_MDCT  ? "mdct_float"  :
               type == AV_TX_FLOAT_RDFT  ? "rdft_float"  :
               type == AV_TX_FLOAT_DCT_I ? "dctI_float"  :
               type == AV_TX_FLOAT_DST_I ? "dstI_float"  :
               type == AV_TX_DOUBLE_FFT  ? "fft_double"  :
               type == AV_TX_DOUBLE_MDCT ? "mdct_double" :
               type == AV_TX_DOUBLE_RDFT ? "rdft_double" :
               type == AV_TX_DOUBLE_DCT_I ? "dctI_double" :
               type == AV_TX_DOUBLE_DST_I ? "dstI_double" :
               type == AV_TX_INT32_FFT   ? "fft_int32"   :
               type == AV_TX_INT32_MDCT  ? "mdct_int32"  :
               type == AV_TX_INT32_RDFT  ? "rdft_int32"  :
               type == AV_TX_INT32_DCT_I ? "dctI_int32" :
               type == AV_TX_INT32_DST_I ? "dstI_int32" :
               "unknown");
}

static void print_cd_info(const FFTXCodelet *cd, int prio, int len, int print_prio,
                          int log_level)
{
    AVBPrint bp;
    av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);

    av_bprintf(&bp, "%s - type: ", cd->name);

    print_type(&bp, cd->type);

    av_bprintf(&bp, ", len: ");
    if (!len) {
        if (cd->min_len != cd->max_len)
            av_bprintf(&bp, "[%i, ", cd->min_len);

        if (cd->max_len == TX_LEN_UNLIMITED)
            av_bprintf(&bp, "unlimited");
        else
            av_bprintf(&bp, "%i", cd->max_len);
    } else {
        av_bprintf(&bp, "%i", len);
    }

    if (cd->factors[1]) {
        av_bprintf(&bp, "%s, factors", !len && cd->min_len != cd->max_len ? "]" : "");
        if (!cd->nb_factors)
            av_bprintf(&bp, ": [");
        else
            av_bprintf(&bp, "[%i]: [", cd->nb_factors);

        for (int i = 0; i < TX_MAX_FACTORS; i++) {
            if (i && cd->factors[i])
                av_bprintf(&bp, ", ");
            if (cd->factors[i] == TX_FACTOR_ANY)
                av_bprintf(&bp, "any");
            else if (cd->factors[i])
                av_bprintf(&bp, "%i", cd->factors[i]);
            else
                break;
        }

        av_bprintf(&bp, "], ");
    } else {
        av_bprintf(&bp, "%s, factor: %i, ",
                   !len && cd->min_len != cd->max_len ? "]" : "", cd->factors[0]);
    }
    print_flags(&bp, cd->flags);

    if (print_prio)
        av_bprintf(&bp, ", prio: %i", prio);

    av_log(NULL, log_level, "%s\n", bp.str);
}

static void print_tx_structure(AVTXContext *s, int depth)
{
    const FFTXCodelet *cd = s->cd_self;

    for (int i = 0; i <= depth; i++)
        av_log(NULL, AV_LOG_DEBUG, "    ");

    print_cd_info(cd, cd->prio, s->len, 0, AV_LOG_DEBUG);

    for (int i = 0; i < s->nb_sub; i++)
        print_tx_structure(&s->sub[i], depth + 1);
}
#endif /* CONFIG_SMALL */

typedef struct TXCodeletMatch {
    const FFTXCodelet *cd;
    int prio;
} TXCodeletMatch;

static int cmp_matches(TXCodeletMatch *a, TXCodeletMatch *b)
{
    return FFDIFFSIGN(b->prio, a->prio);
}

/* We want all factors to completely cover the length */
static inline int check_cd_factors(const FFTXCodelet *cd, int len)
{
    int matches = 0, any_flag = 0;

    for (int i = 0; i < TX_MAX_FACTORS; i++) {
        int factor = cd->factors[i];

        if (factor == TX_FACTOR_ANY) {
            any_flag = 1;
            matches++;
            continue;
        } else if (len <= 1 || !factor) {
            break;
        } else if (factor == 2) { /* Fast path */
            int bits_2 = ff_ctz(len);
            if (!bits_2)
                continue; /* Factor not supported */

            len >>= bits_2;
            matches++;
        } else {
            int res = len % factor;
            if (res)
                continue; /* Factor not supported */

            while (!res) {
                len /= factor;
                res = len % factor;
            }
            matches++;
        }
    }

    return (cd->nb_factors <= matches) && (any_flag || len == 1);
}

av_cold int ff_tx_init_subtx(AVTXContext *s, enum AVTXType type,
                             uint64_t flags, FFTXCodeletOptions *opts,
                             int len, int inv, const void *scale)
{
    int ret = 0;
    AVTXContext *sub = NULL;
    TXCodeletMatch *cd_tmp, *cd_matches = NULL;
    unsigned int cd_matches_size = 0;
    int codelet_list_idx = codelet_list_num;
    int nb_cd_matches = 0;
#if !CONFIG_SMALL
    AVBPrint bp;
#endif

    /* We still accept functions marked with SLOW, even if the CPU is
     * marked with the same flag, but we give them lower priority. */
    const int cpu_flags = av_get_cpu_flags();

    /* Flags the transform wants */
    uint64_t req_flags = flags;

    /* Flags the codelet may require to be present */
    uint64_t inv_req_mask = AV_TX_FULL_IMDCT |
                            AV_TX_REAL_TO_REAL |
                            AV_TX_REAL_TO_IMAGINARY |
                            FF_TX_PRESHUFFLE |
                            FF_TX_ASM_CALL;

    /* Unaligned codelets are compatible with the aligned flag */
    if (req_flags & FF_TX_ALIGNED)
        req_flags |= AV_TX_UNALIGNED;

    /* If either flag is set, both are okay, so don't check for an exact match */
    if ((req_flags & AV_TX_INPLACE) && (req_flags & FF_TX_OUT_OF_PLACE))
        req_flags &= ~(AV_TX_INPLACE | FF_TX_OUT_OF_PLACE);
    if ((req_flags & FF_TX_ALIGNED) && (req_flags & AV_TX_UNALIGNED))
        req_flags &= ~(FF_TX_ALIGNED | AV_TX_UNALIGNED);

    /* Loop through all codelets in all codelet lists to find matches
     * to the requirements */
    while (codelet_list_idx--) {
        const FFTXCodelet * const * list = codelet_list[codelet_list_idx];
        const FFTXCodelet *cd = NULL;

        while ((cd = *list++)) {
            /* Check if the type matches */
            if (cd->type != TX_TYPE_ANY && type != cd->type)
                continue;

            /* Check direction for non-orthogonal codelets */
            if (((cd->flags & FF_TX_FORWARD_ONLY) && inv) ||
                ((cd->flags & (FF_TX_INVERSE_ONLY | AV_TX_FULL_IMDCT)) && !inv) ||
                ((cd->flags & (FF_TX_FORWARD_ONLY | AV_TX_REAL_TO_REAL)) && inv) ||
                ((cd->flags & (FF_TX_FORWARD_ONLY | AV_TX_REAL_TO_IMAGINARY)) && inv))
                continue;

            /* Check if the requested flags match from both sides */
            if (((req_flags    & cd->flags) != (req_flags)) ||
                ((inv_req_mask & cd->flags) != (req_flags & inv_req_mask)))
                continue;

            /* Check if length is supported */
            if ((len < cd->min_len) || (cd->max_len != -1 && (len > cd->max_len)))
                continue;

            /* Check if the CPU supports the required ISA */
            if (cd->cpu_flags != FF_TX_CPU_FLAGS_ALL &&
                !(cpu_flags & (cd->cpu_flags & ~cpu_slow_mask)))
                continue;

            /* Check for factors */
            if (!check_cd_factors(cd, len))
                continue;

            /* Realloc array and append */
            cd_tmp = av_fast_realloc(cd_matches, &cd_matches_size,
                                     sizeof(*cd_tmp) * (nb_cd_matches + 1));
            if (!cd_tmp) {
                av_free(cd_matches);
                return AVERROR(ENOMEM);
            }

            cd_matches                     = cd_tmp;
            cd_matches[nb_cd_matches].cd   = cd;
            cd_matches[nb_cd_matches].prio = get_codelet_prio(cd, cpu_flags, len);
            nb_cd_matches++;
        }
    }

#if !CONFIG_SMALL
    /* Print debugging info */
    av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
    av_bprintf(&bp, "For transform of length %i, %s, ", len,
               inv ? "inverse" : "forward");
    print_type(&bp, type);
    av_bprintf(&bp, ", ");
    print_flags(&bp, flags);
    av_bprintf(&bp, ", found %i matches%s", nb_cd_matches,
               nb_cd_matches ? ":" : ".");
#endif

    /* No matches found */
    if (!nb_cd_matches)
        return AVERROR(ENOSYS);

    /* Sort the list */
    AV_QSORT(cd_matches, nb_cd_matches, TXCodeletMatch, cmp_matches);

#if !CONFIG_SMALL
    av_log(NULL, AV_LOG_TRACE, "%s\n", bp.str);

    for (int i = 0; i < nb_cd_matches; i++) {
        av_log(NULL, AV_LOG_TRACE, "    %i: ", i + 1);
        print_cd_info(cd_matches[i].cd, cd_matches[i].prio, 0, 1, AV_LOG_TRACE);
    }
#endif

    if (!s->sub) {
        s->sub = sub = av_mallocz(TX_MAX_SUB*sizeof(*sub));
        if (!sub) {
            ret = AVERROR(ENOMEM);
            goto end;
        }
    }

    /* Attempt to initialize each */
    for (int i = 0; i < nb_cd_matches; i++) {
        const FFTXCodelet *cd = cd_matches[i].cd;
        AVTXContext *sctx = &s->sub[s->nb_sub];

        sctx->len        = len;
        sctx->inv        = inv;
        sctx->type       = type;
        sctx->flags      = cd->flags | flags;
        sctx->cd_self    = cd;

        s->fn[s->nb_sub] = cd->function;
        s->cd[s->nb_sub] = cd;

        ret = 0;
        if (cd->init)
            ret = cd->init(sctx, cd, flags, opts, len, inv, scale);

        if (ret >= 0) {
            if (opts && opts->map_dir != FF_TX_MAP_NONE &&
                sctx->map_dir == FF_TX_MAP_NONE) {
                /* If a specific map direction was requested, and it doesn't
                 * exist, create one.*/
                sctx->map = av_malloc(len*sizeof(*sctx->map));
                if (!sctx->map) {
                    ret = AVERROR(ENOMEM);
                    goto end;
                }

                for (int i = 0; i < len; i++)
                    sctx->map[i] = i;
            } else if (opts && (opts->map_dir != sctx->map_dir)) {
                int *tmp = av_malloc(len*sizeof(*sctx->map));
                if (!tmp) {
                    ret = AVERROR(ENOMEM);
                    goto end;
                }

                memcpy(tmp, sctx->map, len*sizeof(*sctx->map));

                for (int i = 0; i < len; i++)
                    sctx->map[tmp[i]] = i;

                av_free(tmp);
            }

            s->nb_sub++;
            goto end;
        }

        s->fn[s->nb_sub] = NULL;
        s->cd[s->nb_sub] = NULL;

        reset_ctx(sctx, 0);
        if (ret == AVERROR(ENOMEM))
            break;
    }

    if (!s->nb_sub)
        av_freep(&s->sub);

end:
    av_free(cd_matches);
    return ret;
}

av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type,
                       int inv, int len, const void *scale, uint64_t flags)
{
    int ret;
    AVTXContext tmp = { 0 };
    const double default_scale_d = 1.0;
    const float  default_scale_f = 1.0f;

    if (!len || type >= AV_TX_NB || !ctx || !tx)
        return AVERROR(EINVAL);

    if (!(flags & AV_TX_UNALIGNED))
        flags |= FF_TX_ALIGNED;
    if (!(flags & AV_TX_INPLACE))
        flags |= FF_TX_OUT_OF_PLACE;

    if (!scale && ((type == AV_TX_DOUBLE_MDCT) || (type == AV_TX_DOUBLE_DCT) ||
                   (type == AV_TX_DOUBLE_DCT_I) || (type == AV_TX_DOUBLE_DST_I) ||
                   (type == AV_TX_DOUBLE_RDFT)))
        scale = &default_scale_d;
    else if (!scale && !TYPE_IS(FFT, type))
        scale = &default_scale_f;

    ret = ff_tx_init_subtx(&tmp, type, flags, NULL, len, inv, scale);
    if (ret < 0)
        return ret;

    *ctx = &tmp.sub[0];
    *tx  = tmp.fn[0];

#if !CONFIG_SMALL
    av_log(NULL, AV_LOG_DEBUG, "Transform tree:\n");
    print_tx_structure(*ctx, 0);
#endif

    return ret;
}