IMDCT36()

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

static

Definition at line 381 of file imdct.hpp.

{
    int32_t i, es;
    int32_t xBuf[18], xPrevWin[18];
    int32_t acc1, acc2, s, d, t, mOut;
    int32_t xo, xe, c, *xp, yLo, yHi;
    const int32_t *cp, *wp;
 
    acc1 = acc2 = 0;
    xCurr += 17;
 
    /* 7 gb is always adequate for antialias + accumulator loop + idct9 */
    if (gb < 7) {
        /* rarely triggered - 5% to 10% of the time on normal clips (with Q25 input) */
        es = 7 - gb;
        for (i = 8; i >= 0; i--) {  
            acc1 = ((*xCurr--) >> es) - acc1;
            acc2 = acc1 - acc2;
            acc1 = ((*xCurr--) >> es) - acc1;
            xBuf[i+9] = acc2;   /* odd */
            xBuf[i+0] = acc1;   /* even */
            xPrev[i] >>= es;
        }
    } else {
        es = 0;
        /* max gain = 18, assume adequate guard bits */
        for (i = 8; i >= 0; i--) {  
            acc1 = (*xCurr--) - acc1;
            acc2 = acc1 - acc2;
            acc1 = (*xCurr--) - acc1;
            xBuf[i+9] = acc2;   /* odd */
            xBuf[i+0] = acc1;   /* even */
        }
    }
    /* xEven[0] and xOdd[0] scaled by 0.5 */
    xBuf[9] >>= 1;
    xBuf[0] >>= 1;
 
    /* do 9-point IDCT on even and odd */
    idct9(xBuf+0); /* even */
    idct9(xBuf+9); /* odd */
 
    xp = xBuf + 8;
    cp = c18 + 8;
    mOut = 0;
    if (btPrev == 0 && btCurr == 0) {
        /* fast path - use symmetry of sin window to reduce windowing multiplies to 18 (N/2) */
        wp = fastWin36;
        for (i = 0; i < 9; i++) {
            /* do ARM-style pointer arithmetic (i still needed for y[] indexing - compiler spills if 2 y pointers) */
            c = *cp--;  xo = *(xp + 9);     xe = *xp--;
            /* gain 2 int bits here */
            xo = MULSHIFT32(c, xo);           /* 2*c18*xOdd (mul by 2 implicit in scaling)  */
            xe >>= 2;
 
            s = -(*xPrev);      /* sum from last block (always at least 2 guard bits) */
            d = -(xe - xo);     /* gain 2 int bits, don't shift xo (effective << 1 to eat sign bit, << 1 for mul by 2) */
            (*xPrev++) = xe + xo;           /* symmetry - xPrev[i] = xPrev[17-i] for long blocks */
            t = s - d;
 
            yLo = (d + (MULSHIFT32(t, *wp++) * 4L));
            yHi = (s + (MULSHIFT32(t, *wp++) * 4L));
            y[(i)*NBANDS]    =   yLo;
            y[(17-i)*NBANDS] =  yHi;
            mOut |= FASTABS(yLo);
            mOut |= FASTABS(yHi);
        }
    } else {
        /* slower method - either prev or curr is using window type != 0 so do full 36-point window 
         * output xPrevWin has at least 3 guard bits (xPrev has 2, gain 1 in WinPrevious)
         */
        WinPrevious(xPrev, xPrevWin, btPrev);
 
        wp = imdctWin[btCurr];
        for (i = 0; i < 9; i++) {
            c = *cp--;  xo = *(xp + 9);     xe = *xp--;
            /* gain 2 int bits here */
            xo = MULSHIFT32(c, xo);           /* 2*c18*xOdd (mul by 2 implicit in scaling)  */
            xe >>= 2;
 
            d = xe - xo;
            (*xPrev++) = xe + xo;   /* symmetry - xPrev[i] = xPrev[17-i] for long blocks */
 
            yLo = (xPrevWin[i]    + MULSHIFT32(d, wp[i])) * 4L;
            yHi = (xPrevWin[17-i] + MULSHIFT32(d, wp[17-i])) * 4L;
            y[(i)*NBANDS]    = yLo;
            y[(17-i)*NBANDS] = yHi;
            mOut |= FASTABS(yLo);
            mOut |= FASTABS(yHi);
        }
    }
 
    xPrev -= 9;
    mOut |= FreqInvertRescale(y, xPrev, blockIdx, es);
 
    return mOut;
}

References c18, FASTABS(), fastWin36, FL_NOEXCEPT, FreqInvertRescale(), idct9(), imdctWin, MULSHIFT32(), NBANDS, fl::t, WinPrevious(), and fl::y.

Referenced by HybridTransform().

Here is the call graph for this function:

Here is the caller graph for this function: