HybridTransform()

static int32_t fl::third_party::HybridTransform ( int32_t * xCurr, int32_t * xPrev, int32_t y[BLOCK_SIZE][NBANDS], SideInfoSub * sis, BlockCount * bc )

static

Definition at line 634 of file imdct.hpp.

{
    int32_t xPrevWin[18];
    int32_t currWinIdx, prevWinIdx;
    int32_t i, j, nBlocksOut, nonZero, mOut;
    int32_t xp;
 
    ASSERT(bc->nBlocksLong  <= NBANDS);
    ASSERT(bc->nBlocksTotal <= NBANDS);
    ASSERT(bc->nBlocksPrev  <= NBANDS);
 
    mOut = 0;
 
    /* do long blocks, if any */
    for(i = 0; i < bc->nBlocksLong; i++) {
        /* currWinIdx picks the right window for long blocks (if mixed, long blocks use window type 0) */
        currWinIdx = sis->blockType;
        if (sis->mixedBlock && i < bc->currWinSwitch) 
            currWinIdx = 0;
 
        prevWinIdx = bc->prevType;
        if (i < bc->prevWinSwitch)
             prevWinIdx = 0;
 
        /* do 36-point IMDCT, including windowing and overlap-add */
        mOut |= IMDCT36(xCurr, xPrev, &(y[0][i]), currWinIdx, prevWinIdx, i, bc->gbIn);
        xCurr += 18;
        xPrev += 9;
    }
 
    /* do short blocks (if any) */
    for (   ; i < bc->nBlocksTotal; i++) {
        ASSERT(sis->blockType == 2);
 
        prevWinIdx = bc->prevType;
        if (i < bc->prevWinSwitch)
             prevWinIdx = 0;
        
        mOut |= IMDCT12x3(xCurr, xPrev, &(y[0][i]), prevWinIdx, i, bc->gbIn);
        xCurr += 18;
        xPrev += 9;
    }
    nBlocksOut = i;
    
    /* window and overlap prev if prev longer that current */
    for (   ; i < bc->nBlocksPrev; i++) {
        prevWinIdx = bc->prevType;
        if (i < bc->prevWinSwitch)
             prevWinIdx = 0;
        WinPrevious(xPrev, xPrevWin, prevWinIdx);
 
        nonZero = 0;
        /* sign_bit = -1 for odd i, 0 for even i */
        int32_t sign_bit = ((i & 1) ? (int32_t)(-1) : 0);
            for (j = 0; j < 9; j++) {
            xp = xPrevWin[2*j+0] * 4L;  /* * 4 temp for scaling */
            nonZero |= xp;
            y[2*j+0][i] = xp;
            mOut |= FASTABS(xp);
 
            /* frequency inversion on odd blocks/odd samples (flip sign if i odd, j odd) */
            xp = xPrevWin[2*j+1] * 4L;
            xp = (xp ^ sign_bit) + (i & 0x01);
            nonZero |= xp;
            y[2*j+1][i] = xp;
            mOut |= FASTABS(xp);
 
            xPrev[j] = 0;
        }
        xPrev += 9;
        if (nonZero)
            nBlocksOut = i;
    }
    
    /* clear rest of blocks */
    for (   ; i < 32; i++) {
        for (j = 0; j < 18; j++) 
            y[j][i] = 0;
    }
 
    bc->gbOut = CLZ(mOut) - 1;
 
    return nBlocksOut;
}

References ASSERT, BLOCK_SIZE, CLZ(), FASTABS(), FL_NOEXCEPT, IMDCT12x3(), IMDCT36(), NBANDS, WinPrevious(), and fl::y.

Referenced by IMDCT().

Here is the call graph for this function:

Here is the caller graph for this function: