mp3d_synth()

MP3D_HOT void mp3d_synth	(	int32_t *	xl,
		mp3d_sample_t *	dstl,
		int	nch,
		int32_t *	lins )

Definition at line 747 of file minimp3_synth_fixed.h.

{
    int i;
    int32_t *xr = xl + 576*(nch - 1);
    mp3d_sample_t *dstr = dstl + (nch - 1);
 
    static const int32_t g_win[] = {
        -1,26,-31,208,218,401,-519,2063,2000,4788,-5517,7134,5959,35640,-39336,74992,
        -1,24,-35,202,222,347,-581,2080,1952,4425,-5879,7640,5288,33791,-41176,74856,
        -1,21,-38,196,225,294,-645,2087,1893,4063,-6237,8092,4561,31947,-43006,74630,
        -1,19,-41,190,227,244,-711,2085,1822,3705,-6589,8492,3776,30112,-44821,74313,
        -1,17,-45,183,228,197,-779,2075,1739,3351,-6935,8840,2935,28289,-46617,73908,
        -1,16,-49,176,228,153,-848,2057,1644,3004,-7271,9139,2037,26482,-48390,73415,
        -2,14,-53,169,227,111,-919,2032,1535,2663,-7597,9389,1082,24694,-50137,72835,
        -2,13,-58,161,224,72,-991,2001,1414,2330,-7910,9592,70,22929,-51853,72169,
        -2,11,-63,154,221,36,-1064,1962,1280,2006,-8209,9750,-998,21189,-53534,71420,
        -2,10,-68,147,215,2,-1137,1919,1131,1692,-8491,9863,-2122,19478,-55178,70590,
        -3,9,-73,139,208,-29,-1210,1870,970,1388,-8755,9935,-3300,17799,-56778,69679,
        -3,8,-79,132,200,-57,-1283,1817,794,1095,-8998,9966,-4533,16155,-58333,68692,
        -4,7,-85,125,189,-83,-1356,1759,605,814,-9219,9959,-5818,14548,-59838,67629,
        -4,7,-91,117,177,-106,-1428,1698,402,545,-9416,9916,-7154,12980,-61289,66494,
        -5,6,-97,111,163,-127,-1498,1634,185,288,-9585,9838,-8540,11455,-62684,65290
    };
    int32_t *zlin = lins + 15*64;
    const int32_t *w = g_win;
    /* Lane stride through the four-lane accumulator.
 
       The four lanes are (left, right) x (subband i, subband i+1). In mono
       `xr == xl` and `dstr == dstl`, so lanes 1 and 3 recompute lanes 0 and 2
       and their stores are immediately overwritten by the lane 0/2 stores that
       follow them -- half the polyphase filterbank, thrown away. Helix avoids
       it by shipping a separate PolyphaseMono; here it is the same function
       with a two-lane tap chain, which is worth 34% of a mono decode on an
       ESP32-C6 (136,546 -> 89,699 us over 60 frames of 16 kHz MPEG-2 Layer III,
       bit-identical output).
 
       Nothing else reads the odd lanes in mono. The granule's mono carry loop
       (`for (i = 0; i < 15*64; i += 2)`) already saves only even indices, so
       the odd lanes of the history are stale in mono either way -- today they
       are read and discarded, which is exactly the work this removes.
 
       The lane step is a literal in each of two copies of the tap chain rather
       than a variable in one copy. One copy with `j += jstep` was tried first,
       on the reasoning that riscv32 -Os does not unroll the four-lane loop
       anyway (mp3d_synth_granule has exactly 32 `mulh` -- 8 taps x 4 products,
       not 8 x 4 x 4), so the step ought to have been free. Measured on the C6
       it was not: the stereo Layer III path went 46,294 -> 47,665 us, +3.0%,
       against a helix reference that moved 0.01% between the same two runs.
       Two chains with literal steps cost .text and nothing else. */
#if MP3D_HAVE_INT_SIMD
    const int use_simd = MP3D_SIMD_AVAILABLE();
#endif
 
    zlin[4*15]     = xl[18*16];
    zlin[4*15 + 2] = xl[0];
 
    zlin[4*31]     = xl[1 + 18*16];
    zlin[4*31 + 2] = xl[1];
 
    if (nch == 2)
    {
        zlin[4*15 + 1] = xr[18*16];
        zlin[4*15 + 3] = xr[0];
        zlin[4*31 + 1] = xr[1 + 18*16];
        zlin[4*31 + 3] = xr[1];
 
        mp3d_synth_pair(dstr, nch, lins + 4*15 + 1);
        mp3d_synth_pair(dstr + 32*nch, nch, lins + 4*15 + 64 + 1);
    }
    mp3d_synth_pair(dstl, nch, lins + 4*15);
    mp3d_synth_pair(dstl + 32*nch, nch, lins + 4*15 + 64);
 
    for (i = 14; i >= 0; i--)
    {
/* One tap of one lane pair. S0/S1/S2 are the original chain unchanged: S0
   opens the accumulators, S1 adds and S2 adds with the `a` operands swapped.
   The arithmetic, the operand order and the accumulation order are identical
   to the four-lane form these replaced, which is why the PCM checksum does
   not move.
 
   Two things changed, and only the second one is arithmetic-free by accident.
 
   The chain used to carry all four lanes -- eight int64 accumulators, held in
   `int64_t a[4], b[4]` -- across the whole eight-tap run. On riscv32 -Os that
   array is a stack slot, and the tap body paid eight memory operations per
   tap per lane to reload and rewrite it: of its 35 instructions, four loads
   and four stores were accumulator traffic and nothing else.
 
   Halving the live set is necessary but not sufficient. `int64_t a[2], b[2]`
   with the lane loop left rolled spills exactly as badly, because at -Os gcc
   does not unroll a two-iteration loop and a variable index into a local array
   has to be memory. The lanes are therefore written out as named scalars,
   which is what actually lets the accumulators live in registers.
 
   One lane at a time was tried too. It removes the spill just as completely
   but re-reads the window pair and recomputes the two zlin base addresses
   four times per tap instead of twice, which costs 3.2% on an x86-64 host
   that had registers to spare and was never paying the spill. The pair keeps
   both ends. */
#define LOAD(k) const int32_t w0 = w[2*(k)]; const int32_t w1 = w[2*(k) + 1]; const int32_t *vz = &zlin[4*i + g - (k)*64]; const int32_t *vy = &zlin[4*i + g - (15 - (k))*64];
#define S0(k, st) { LOAD(k);                                                   \
        b0  = (int64_t)vz[0]*w1 + (int64_t)vy[0]*w0;                           \
        a0  = (int64_t)vz[0]*w0 - (int64_t)vy[0]*w1;                           \
        if (st == 1) {                                                         \
        b1  = (int64_t)vz[1]*w1 + (int64_t)vy[1]*w0;                           \
        a1  = (int64_t)vz[1]*w0 - (int64_t)vy[1]*w1; } }
#define S1(k, st) { LOAD(k);                                                   \
        b0 += (int64_t)vz[0]*w1 + (int64_t)vy[0]*w0;                           \
        a0 += (int64_t)vz[0]*w0 - (int64_t)vy[0]*w1;                           \
        if (st == 1) {                                                         \
        b1 += (int64_t)vz[1]*w1 + (int64_t)vy[1]*w0;                           \
        a1 += (int64_t)vz[1]*w0 - (int64_t)vy[1]*w1; } }
#define S2(k, st) { LOAD(k);                                                   \
        b0 += (int64_t)vz[0]*w1 + (int64_t)vy[0]*w0;                           \
        a0 += (int64_t)vy[0]*w1 - (int64_t)vz[0]*w0;                           \
        if (st == 1) {                                                         \
        b1 += (int64_t)vz[1]*w1 + (int64_t)vy[1]*w0;                           \
        a1 += (int64_t)vy[1]*w1 - (int64_t)vz[1]*w0; } }
/* Lane pair g writes (a, b) to (15 - i, 17 + i) for g == 0 and to the same
   pair plus 32 samples for g == 2; within the pair, lane 0 is the left
   channel and lane 1 is dstr, which is dstl + (nch - 1). Both are address
   arithmetic on the pair index rather than four copies of the chain.
 
   In mono the odd lane recomputes the even one into the same address, so the
   step is 2 and lane 1 never runs at all -- a1 and b1 are dead, not merely
   redundant, and the zeroing below is what tells the compiler so rather than
   a value anything reads. */
#define MP3D_SYNTH_CHAIN(st)                                                   \
        {                                                                      \
            int g;                                                             \
            for (g = 0; g < 4; g += 2)                                         \
            {                                                                  \
                mp3d_sample_t *d = dstl + g*16*nch;                            \
                int64_t a0, b0, a1 = 0, b1 = 0;                                \
                S0(0, st) S2(1, st) S1(2, st) S2(3, st)                        \
                S1(4, st) S2(5, st) S1(6, st) S2(7, st)                        \
                if (st == 1)                                                   \
                {                                                              \
                    d[(15 - i)*nch + 1] = mp3d_scale_pcm(a1);                  \
                    d[(17 + i)*nch + 1] = mp3d_scale_pcm(b1);                  \
                }                                                              \
                d[(15 - i)*nch] = mp3d_scale_pcm(a0);                          \
                d[(17 + i)*nch] = mp3d_scale_pcm(b0);                          \
            }                                                                  \
        }
 
        zlin[4*i]     = xl[18*(31 - i)];
        zlin[4*i + 2] = xl[1 + 18*(31 - i)];
        zlin[4*(i + 16)]   = xl[1 + 18*(1 + i)];
        zlin[4*(i - 16) + 2] = xl[18*(1 + i)];
        if (nch == 2)
        {
            zlin[4*i + 1] = xr[18*(31 - i)];
            zlin[4*i + 3] = xr[1 + 18*(31 - i)];
            zlin[4*(i + 16) + 1] = xr[1 + 18*(1 + i)];
            zlin[4*(i - 16) + 3] = xr[18*(1 + i)];
        }
 
#if MP3D_HAVE_INT_SIMD
        if (use_simd)
        {
            /* The vector kernel still produces all four lanes at once, so it
               keeps the array form and the store block that goes with it. */
            int64_t a[4], b[4];
            mp3d_synth_taps(zlin, w, i, a, b);
            if (nch == 2)
            {
                dstr[(15 - i)*nch] = mp3d_scale_pcm(a[1]);
                dstr[(17 + i)*nch] = mp3d_scale_pcm(b[1]);
                dstr[(47 - i)*nch] = mp3d_scale_pcm(a[3]);
                dstr[(49 + i)*nch] = mp3d_scale_pcm(b[3]);
            }
            dstl[(15 - i)*nch] = mp3d_scale_pcm(a[0]);
            dstl[(17 + i)*nch] = mp3d_scale_pcm(b[0]);
            dstl[(47 - i)*nch] = mp3d_scale_pcm(a[2]);
            dstl[(49 + i)*nch] = mp3d_scale_pcm(b[2]);
        }
        else
#endif
        /* In mono the odd lanes recompute the even ones into the same
           addresses, so the step is 2 and lanes 1 and 3 never run. */
        if (nch == 1)
        {
            MP3D_SYNTH_CHAIN(2)
        }
        else
        {
            MP3D_SYNTH_CHAIN(1)
        }
        w += 16;
    }
}

References FL_NO_EXCEPT, mp3d_scale_pcm(), MP3D_SYNTH_CHAIN, and mp3d_synth_pair().

Referenced by mp3d_synth_granule().

Here is the call graph for this function:

Here is the caller graph for this function: