IMDCT12x3()

static int32_t fl::third_party::IMDCT12x3 ( int32_t * xCurr, int32_t * xPrev, int32_t * y, int32_t btPrev, int32_t blockIdx, int32_t gb )

static

Definition at line 551 of file imdct.hpp.

{
    int32_t i, es, mOut;
    int32_t yLo, xBuf[18], xPrevWin[18]; /* need temp buffer for reordering short blocks */
    const int32_t *wp;
 
    es = 0;
    /* 7 gb is always adequate for accumulator loop + idct12 + window + overlap */
    if (gb < 7) {
        es = 7 - gb;
        for (i = 0; i < 18; i+=2) {
            xCurr[i+0] >>= es;
            xCurr[i+1] >>= es;
            *xPrev++ >>= es;
        }
        xPrev -= 9;
    }
 
    /* requires 4 input guard bits for each imdct12 */
    imdct12(xCurr + 0, xBuf + 0);
    imdct12(xCurr + 1, xBuf + 6);
    imdct12(xCurr + 2, xBuf + 12);
 
    /* window previous from last time */
    WinPrevious(xPrev, xPrevWin, btPrev);
 
    /* could unroll this for speed, minimum loads (short blocks usually rare, so doesn't make much overall difference) 
     * xPrevWin[i] << 2 still has 1 gb always, max gain of windowed xBuf stuff also < 1.0 and gain the sign bit
     * so y calculations won't overflow
     */
    wp = imdctWin[2];
    mOut = 0;
    for (i = 0; i < 3; i++) {
        yLo = (xPrevWin[ 0+i] * 4L);
        mOut |= FASTABS(yLo);    y[( 0+i)*NBANDS] = yLo;
        yLo = (xPrevWin[ 3+i] * 4L);
        mOut |= FASTABS(yLo);    y[( 3+i)*NBANDS] = yLo;
        yLo = (xPrevWin[ 6+i] * 4L) + (MULSHIFT32(wp[0+i], xBuf[3+i]));
        mOut |= FASTABS(yLo);    y[( 6+i)*NBANDS] = yLo;
        yLo = (xPrevWin[ 9+i] * 4L) + (MULSHIFT32(wp[3+i], xBuf[5-i]));
        mOut |= FASTABS(yLo);    y[( 9+i)*NBANDS] = yLo;
        yLo = (xPrevWin[12+i] * 4L) + (MULSHIFT32(wp[6+i], xBuf[2-i]) + MULSHIFT32(wp[0+i], xBuf[(6+3)+i]));
        mOut |= FASTABS(yLo);    y[(12+i)*NBANDS] = yLo;
        yLo = (xPrevWin[15+i] * 4L) + (MULSHIFT32(wp[9+i], xBuf[0+i]) + MULSHIFT32(wp[3+i], xBuf[(6+5)-i]));
        mOut |= FASTABS(yLo);    y[(15+i)*NBANDS] = yLo;
    }
 
    /* save previous (unwindowed) for overlap - only need samples 6-8, 12-17 */
    for (i = 6; i < 9; i++)
        *xPrev++ = xBuf[i] >> 2;
    for (i = 12; i < 18; i++)
        *xPrev++ = xBuf[i] >> 2;
 
    xPrev -= 9;
    mOut |= FreqInvertRescale(y, xPrev, blockIdx, es);
 
    return mOut;
}

References FASTABS(), FL_NOEXCEPT, FreqInvertRescale(), imdct12(), imdctWin, MULSHIFT32(), NBANDS, WinPrevious(), and fl::y.

Referenced by HybridTransform().

Here is the call graph for this function:

Here is the caller graph for this function: