FDCT32()

void fl::third_party::FDCT32	(	int32_t *	x,
		int32_t *	d,
		int32_t	offset,
		int32_t	oddBlock,
		int32_t	gb )

Definition at line 151 of file dct32.hpp.

{
    int32_t i, s, tmp, es;
    const int32_t *cptr = dcttab;
    int32_t a0, a1, a2, a3, a4, a5, a6, a7;
    int32_t b0, b1, b2, b3, b4, b5, b6, b7;
    int32_t *d;
 
    /* scaling - ensure at least 6 guard bits for DCT 
     * (in practice this is already true 99% of time, so this code is
     *  almost never triggered)
     */
    es = 0;
    if (gb < 6) {
        es = 6 - gb;
        for (i = 0; i < 32; i++)
            buf[i] >>= es;
    }
 
    /* first pass */    
    D32FP(0, 1, 5, 1);
    D32FP(1, 1, 3, 1);
    D32FP(2, 1, 3, 1);
    D32FP(3, 1, 2, 1);
    D32FP(4, 1, 2, 1);
    D32FP(5, 1, 1, 2);
    D32FP(6, 1, 1, 2);
    D32FP(7, 1, 1, 4);
 
    /* second pass */
    for (i = 4; i > 0; i--) {
        a0 = buf[0];        a7 = buf[7];        a3 = buf[3];        a4 = buf[4];
        b0 = a0 + a7;       b7 = MULSHIFT32(*cptr++, a0 - a7) * 2L;
        b3 = a3 + a4;       b4 = MULSHIFT32(*cptr++, a3 - a4) * 8L;
        a0 = b0 + b3;       a3 = MULSHIFT32(*cptr,   b0 - b3) * 2L;
        a4 = b4 + b7;       a7 = MULSHIFT32(*cptr++, b7 - b4) * 2L;
 
        a1 = buf[1];        a6 = buf[6];        a2 = buf[2];        a5 = buf[5];
        b1 = a1 + a6;       b6 = MULSHIFT32(*cptr++, a1 - a6) * 2L;
        b2 = a2 + a5;       b5 = MULSHIFT32(*cptr++, a2 - a5) * 2L;
        a1 = b1 + b2;       a2 = MULSHIFT32(*cptr,   b1 - b2) * 4L;
        a5 = b5 + b6;       a6 = MULSHIFT32(*cptr++, b6 - b5) * 4L;
 
        b0 = a0 + a1;       b1 = MULSHIFT32(COS4_0, a0 - a1) * 2L;
        b2 = a2 + a3;       b3 = MULSHIFT32(COS4_0, a3 - a2) * 2L;
        buf[0] = b0;        buf[1] = b1;
        buf[2] = b2 + b3;   buf[3] = b3;
 
        b4 = a4 + a5;       b5 = MULSHIFT32(COS4_0, a4 - a5) * 2L;
        b6 = a6 + a7;       b7 = MULSHIFT32(COS4_0, a7 - a6) * 2L;
        b6 += b7;
        buf[4] = b4 + b6;   buf[5] = b5 + b7;
        buf[6] = b5 + b6;   buf[7] = b7;
 
        buf += 8;
    }
    buf -= 32;  /* reset */
 
    /* sample 0 - always delayed one block */
    d = dest + 64*16 + ((offset - oddBlock) & 7) + (oddBlock ? 0 : VBUF_LENGTH);
    s = buf[ 0];                d[0] = d[8] = s;
    
    /* samples 16 to 31 */
    d = dest + offset + (oddBlock ? VBUF_LENGTH  : 0);
 
    s = buf[ 1];                d[0] = d[8] = s;    d += 64;
 
    tmp = buf[25] + buf[29];
    s = buf[17] + tmp;          d[0] = d[8] = s;    d += 64;
    s = buf[ 9] + buf[13];      d[0] = d[8] = s;    d += 64;
    s = buf[21] + tmp;          d[0] = d[8] = s;    d += 64;
 
    tmp = buf[29] + buf[27];
    s = buf[ 5];                d[0] = d[8] = s;    d += 64;
    s = buf[21] + tmp;          d[0] = d[8] = s;    d += 64;
    s = buf[13] + buf[11];      d[0] = d[8] = s;    d += 64;
    s = buf[19] + tmp;          d[0] = d[8] = s;    d += 64;
 
    tmp = buf[27] + buf[31];
    s = buf[ 3];                d[0] = d[8] = s;    d += 64;
    s = buf[19] + tmp;          d[0] = d[8] = s;    d += 64;
    s = buf[11] + buf[15];      d[0] = d[8] = s;    d += 64;
    s = buf[23] + tmp;          d[0] = d[8] = s;    d += 64;
 
    tmp = buf[31];
    s = buf[ 7];                d[0] = d[8] = s;    d += 64;
    s = buf[23] + tmp;          d[0] = d[8] = s;    d += 64;
    s = buf[15];                d[0] = d[8] = s;    d += 64;
    s = tmp;                    d[0] = d[8] = s;
 
    /* samples 16 to 1 (sample 16 used again) */
    d = dest + 16 + ((offset - oddBlock) & 7) + (oddBlock ? 0 : VBUF_LENGTH);
 
    s = buf[ 1];                d[0] = d[8] = s;    d += 64;
 
    tmp = buf[30] + buf[25];
    s = buf[17] + tmp;          d[0] = d[8] = s;    d += 64;
    s = buf[14] + buf[ 9];      d[0] = d[8] = s;    d += 64;
    s = buf[22] + tmp;          d[0] = d[8] = s;    d += 64;
    s = buf[ 6];                d[0] = d[8] = s;    d += 64;
 
    tmp = buf[26] + buf[30];
    s = buf[22] + tmp;          d[0] = d[8] = s;    d += 64;
    s = buf[10] + buf[14];      d[0] = d[8] = s;    d += 64;
    s = buf[18] + tmp;          d[0] = d[8] = s;    d += 64;
    s = buf[ 2];                d[0] = d[8] = s;    d += 64;
 
    tmp = buf[28] + buf[26];
    s = buf[18] + tmp;          d[0] = d[8] = s;    d += 64;
    s = buf[12] + buf[10];      d[0] = d[8] = s;    d += 64;
    s = buf[20] + tmp;          d[0] = d[8] = s;    d += 64;
    s = buf[ 4];                d[0] = d[8] = s;    d += 64;
 
    tmp = buf[24] + buf[28];
    s = buf[20] + tmp;          d[0] = d[8] = s;    d += 64;
    s = buf[ 8] + buf[12];      d[0] = d[8] = s;    d += 64;
    s = buf[16] + tmp;          d[0] = d[8] = s;
 
    /* this is so rarely invoked that it's not worth making two versions of the output
     *   shuffle code (one for no shift, one for clip + variable shift) like in IMDCT
     * here we just load, clip, shift, and store on the rare instances that es != 0
     */
    if (es) {
        d = dest + 64*16 + ((offset - oddBlock) & 7) + (oddBlock ? 0 : VBUF_LENGTH);
        s = d[0];   CLIP_2N(s, 31 - es); d[0] = d[8] = (s << es);
    
        d = dest + offset + (oddBlock ? VBUF_LENGTH  : 0);
        for (i = 16; i <= 31; i++) {
            s = d[0];   CLIP_2N(s, 31 - es); d[0] = d[8] = (s << es);    d += 64;
        }
 
        d = dest + 16 + ((offset - oddBlock) & 7) + (oddBlock ? 0 : VBUF_LENGTH);
        for (i = 15; i >= 0; i--) {
            s = d[0];   CLIP_2N(s, 31 - es); d[0] = d[8] = (s << es);    d += 64;
        }
    }
}

References CLIP_2N, COS4_0, D32FP, dcttab, FL_NOEXCEPT, MULSHIFT32(), offset(), and VBUF_LENGTH.

Referenced by Subband().

Here is the call graph for this function:

Here is the caller graph for this function: