DequantChannel()

int32_t fl::third_party::DequantChannel	(	int32_t *	sampleBuf,
		int32_t *	workBuf,
		int32_t *	nonZeroBound,
		FrameHeader *	fh,
		SideInfoSub *	sis,
		ScaleFactorInfoSub *	sfis,
		CriticalBandInfo *	cbi )

Definition at line 252 of file dqchan.hpp.

{
    int32_t i, j, w, cb;
    int32_t cbEndL, cbStartS, cbEndS;
    int32_t nSamps, nonZero, sfactMultiplier, gbMask;
    int32_t globalGain, gainI;
    int32_t cbMax[3];
    ARRAY3 *buf;    /* short block reorder */
    
    /* set default start/end points for short/long blocks - will update with non-zero cb info */
    if (sis->blockType == 2) {
        if (sis->mixedBlock) { 
            cbEndL = (fh->ver == MPEG1 ? 8 : 6); 
            cbStartS = 3; 
        } else {
            cbEndL = 0; 
            cbStartS = 0;
        }
        cbEndS = 13;
    } else {
        /* long block */
        cbEndL =   22;
        cbStartS = 13;
        cbEndS =   13;
    }
    cbMax[2] = cbMax[1] = cbMax[0] = 0;
    gbMask = 0;
    i = 0;
 
    /* sfactScale = 0 --> quantizer step size = 2
     * sfactScale = 1 --> quantizer step size = sqrt(2)
     *   so sfactMultiplier = 2 or 4 (jump through globalGain by powers of 2 or sqrt(2))
     */
    sfactMultiplier = 2 * (sis->sfactScale + 1);
 
    /* offset globalGain by -2 if midSide enabled, for 1/sqrt(2) used in MidSideProc()
     *  (DequantBlock() does 0.25 * gainI so knocking it down by two is the same as 
     *   dividing every sample by sqrt(2) = multiplying by 2^-.5)
     */
    globalGain = sis->globalGain;
    if (fh->modeExt >> 1)
         globalGain -= 2;
    globalGain += IMDCT_SCALE;       /* scale everything by sqrt(2), for fast IMDCT36 */
 
    /* long blocks */
    for (cb = 0; cb < cbEndL; cb++) {
 
        nonZero = 0;
        nSamps = fh->sfBand->l[cb + 1] - fh->sfBand->l[cb];
        gainI = 210 - globalGain + sfactMultiplier * (sfis->l[cb] + (sis->preFlag ? (int)preTab[cb] : 0));
 
        nonZero |= DequantBlock(sampleBuf + i, sampleBuf + i, nSamps, gainI);
        i += nSamps;
 
        /* update highest non-zero critical band */
        if (nonZero) 
            cbMax[0] = cb;
        gbMask |= nonZero;
 
        if (i >= *nonZeroBound) 
            break;
    }
 
    /* set cbi (Type, EndS[], EndSMax will be overwritten if we proceed to do short blocks) */
    cbi->cbType = 0;          /* long only */
    cbi->cbEndL  = cbMax[0];
    cbi->cbEndS[0] = cbi->cbEndS[1] = cbi->cbEndS[2] = 0;
    cbi->cbEndSMax = 0;
 
    /* early exit if no short blocks */
    if (cbStartS >= 12) 
        return CLZ(gbMask) - 1;
    
    /* short blocks */
    cbMax[2] = cbMax[1] = cbMax[0] = cbStartS;
    for (cb = cbStartS; cb < cbEndS; cb++) {
 
        nSamps = fh->sfBand->s[cb + 1] - fh->sfBand->s[cb];
        for (w = 0; w < 3; w++) {
            nonZero =  0;
            gainI = 210 - globalGain + 8*sis->subBlockGain[w] + sfactMultiplier*(sfis->s[cb][w]);
 
            nonZero |= DequantBlock(sampleBuf + i + nSamps*w, workBuf + nSamps*w, nSamps, gainI);
 
            /* update highest non-zero critical band */
            if (nonZero)
                cbMax[w] = cb;
            gbMask |= nonZero;
        }
 
        /* reorder blocks */
        buf = (ARRAY3 *)(sampleBuf + i);
        i += 3*nSamps;
        for (j = 0; j < nSamps; j++) {
            buf[j][0] = workBuf[0*nSamps + j];
            buf[j][1] = workBuf[1*nSamps + j];
            buf[j][2] = workBuf[2*nSamps + j];
        }
 
        ASSERT(3*nSamps <= MAX_REORDER_SAMPS);
 
        if (i >= *nonZeroBound) 
            break;
    }
 
    /* i = last non-zero INPUT sample processed, which corresponds to highest possible non-zero 
     *     OUTPUT sample (after reorder)
     * however, the original nzb is no longer necessarily true
     *   for each cb, buf[][] is updated with 3*nSamps samples (i increases 3*nSamps each time)
     *   (buf[j + 1][0] = 3 (input) samples ahead of buf[j][0])
     * so update nonZeroBound to i
     */
    *nonZeroBound = i;
 
    ASSERT(*nonZeroBound <= MAX_NSAMP);
 
    cbi->cbType = (sis->mixedBlock ? 2 : 1);    /* 2 = mixed short/long, 1 = short only */
 
    cbi->cbEndS[0] = cbMax[0];
    cbi->cbEndS[1] = cbMax[1];
    cbi->cbEndS[2] = cbMax[2];
 
    cbi->cbEndSMax = cbMax[0];
    cbi->cbEndSMax = MAX(cbi->cbEndSMax, cbMax[1]);
    cbi->cbEndSMax = MAX(cbi->cbEndSMax, cbMax[2]);
 
    return CLZ(gbMask) - 1;
}

References ASSERT, CLZ(), DequantBlock(), FL_NOEXCEPT, IMDCT_SCALE, MAX, MAX_NSAMP, MAX_REORDER_SAMPS, MPEG1, and preTab.

Referenced by Dequantize().

Here is the call graph for this function:

Here is the caller graph for this function: