mp3d_DCT_II()

static MP3D_KERNEL void mp3d_DCT_II ( int32_t * grbuf, int n )

static

Definition at line 470 of file minimp3_synth_fixed.h.

{
    int i, k = 0;
#if MP3D_HAVE_INT_SIMD
    if (MP3D_SIMD_AVAILABLE())
    {
        for (; k + 4 <= n; k += 4)
        {
            mp3d_dct2_bands4(grbuf, k);
        }
    }
#endif
    for (; k < n; k++)
    {
        int32_t t[4][8], *x, *y = grbuf + k;
 
        /* Pass 1, spelled out rather than written as a loop over i.
 
           gcc unrolls it either way -- it was 443 riscv32 instructions inside
           the k loop before this, with no backward branch -- so the unroll is
           not what this buys. What it buys is `i` being a template argument,
           which makes g_sec_q27[3*i + k] a constant expression and lets each
           of the four multiplies use mp3d_mulshift_k. Written as a loop the
           secant is an int32 the compiler happens to know the value of, which
           is not the same thing: a template argument can pick the integer and
           fractional parts apart at compile time, and a value cannot.
 
           g_sec_q27 stays the single definition of these numbers -- the
           coefficients are read from it here, not transcribed -- which is why
           it is `constexpr`. The SIMD kernel still indexes it at run time. */
#define MP3D_DCT_PASS1(I)                                                      \
        do {                                                                   \
            const int32_t x0 = y[(I)*18];                                      \
            const int32_t x1 = y[(15 - (I))*18];                               \
            const int32_t x2 = y[(16 + (I))*18];                               \
            const int32_t x3 = y[(31 - (I))*18];                               \
            const int32_t t0 = mp3d_add_sat(x0, x3);                           \
            const int32_t t1 = mp3d_add_sat(x1, x2);                           \
            const int32_t t2 = mp3d_mulshift_k<27, g_sec_q27[3*(I) + 0]>(      \
                mp3d_sub_sat(x1, x2));                                         \
            const int32_t t3 = mp3d_mulshift_k<27, g_sec_q27[3*(I) + 1]>(      \
                mp3d_sub_sat(x0, x3));                                         \
            t[0][I] = mp3d_add_sat(t0, t1);                                    \
            t[1][I] = mp3d_mulshift_k<27, g_sec_q27[3*(I) + 2]>(               \
                mp3d_sub_sat(t0, t1));                                         \
            t[2][I] = mp3d_add_sat(t3, t2);                                    \
            t[3][I] = mp3d_mulshift_k<27, g_sec_q27[3*(I) + 2]>(               \
                mp3d_sub_sat(t3, t2));                                         \
        } while (0)
        MP3D_DCT_PASS1(0);
        MP3D_DCT_PASS1(1);
        MP3D_DCT_PASS1(2);
        MP3D_DCT_PASS1(3);
        MP3D_DCT_PASS1(4);
        MP3D_DCT_PASS1(5);
        MP3D_DCT_PASS1(6);
        MP3D_DCT_PASS1(7);
#undef MP3D_DCT_PASS1
        for (x = t[0], i = 0; i < 4; i++, x += 8)
        {
            int32_t x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3];
            int32_t x4 = x[4], x5 = x[5], x6 = x[6], x7 = x[7], xt;
            xt = mp3d_sub_sat(x0, x7); x0 = mp3d_add_sat(x0, x7);
            x7 = mp3d_sub_sat(x1, x6); x1 = mp3d_add_sat(x1, x6);
            x6 = mp3d_sub_sat(x2, x5); x2 = mp3d_add_sat(x2, x5);
            x5 = mp3d_sub_sat(x3, x4); x3 = mp3d_add_sat(x3, x4);
            x4 = mp3d_sub_sat(x0, x3); x0 = mp3d_add_sat(x0, x3);
            x3 = mp3d_sub_sat(x1, x2); x1 = mp3d_add_sat(x1, x2);
            x[0] = mp3d_add_sat(x0, x1);
            x[4] = mp3d_mulshift_k<31, MP3D_Q31_COS_PI_4>(mp3d_sub_sat(x0, x1));
            x5 = mp3d_add_sat(x5, x6);
            x6 = mp3d_mulshift_k<31, MP3D_Q31_COS_PI_4>(mp3d_add_sat(x6, x7));
            x7 = mp3d_add_sat(x7, xt);
            x3 = mp3d_mulshift_k<31, MP3D_Q31_COS_PI_4>(mp3d_add_sat(x3, x4));
            /* rotate by PI/8 */
            x5 = mp3d_sub_sat(x5, mp3d_mulshift_k<31, MP3D_Q31_TAN_PI_16>(x7));
            x7 = mp3d_add_sat(x7, mp3d_mulshift_k<31, MP3D_Q31_SIN_PI_8>(x5));
            x5 = mp3d_sub_sat(x5, mp3d_mulshift_k<31, MP3D_Q31_TAN_PI_16>(x7));
            x0 = mp3d_sub_sat(xt, x6); xt = mp3d_add_sat(xt, x6);
            x[1] = mp3d_mulshift_k<29, MP3D_Q29_SEC_PI_16>(mp3d_add_sat(xt, x7));
            x[2] = mp3d_mulshift_k<29, MP3D_Q29_SEC_PI_8>(mp3d_add_sat(x4, x3));
            x[3] = mp3d_mulshift_k<29, MP3D_Q29_SEC_3PI_16>(mp3d_sub_sat(x0, x5));
            x[5] = mp3d_mulshift_k<29, MP3D_Q29_SEC_5PI_16>(mp3d_add_sat(x0, x5));
            x[6] = mp3d_mulshift_k<29, MP3D_Q29_SEC_3PI_8>(mp3d_sub_sat(x4, x3));
            x[7] = mp3d_mulshift_k<29, MP3D_Q29_SEC_7PI_16>(mp3d_sub_sat(xt, x7));
        }
        for (i = 0; i < 7; i++, y += 4*18)
        {
            y[0*18] = t[0][i];
            y[1*18] = mp3d_add_sat(mp3d_add_sat(t[2][i], t[3][i]), t[3][i + 1]);
            y[2*18] = mp3d_add_sat(t[1][i], t[1][i + 1]);
            y[3*18] = mp3d_add_sat(mp3d_add_sat(t[2][i + 1], t[3][i]), t[3][i + 1]);
        }
        y[0*18] = t[0][7];
        y[1*18] = mp3d_add_sat(t[2][7], t[3][7]);
        y[2*18] = t[1][7];
        y[3*18] = t[3][7];
    }
}

References FL_NO_EXCEPT, MP3D_DCT_PASS1, t, x, and y.

Referenced by mp3d_synth_granule().

Here is the caller graph for this function: