huffman.c

tcpmp.src.0.72RC1 优秀的多媒体播放器TCPMP的源代码

    if (cb < 16 || cb > 31)
        return;

    max = vcb11_LAV_tab[cb - 16];

    if ((abs(sp[0]) > max) || (abs(sp[1]) > max))
    {
        sp[0] = 0;
        sp[1] = 0;
    }
}

uint8_t huffman_spectral_data1(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=4)
    /* 2-step method for data quadruples */
        err = huffman_2step_quad(1, ld, sp);
	return err;
}

uint8_t huffman_spectral_data2(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=4)
    /* 2-step method for data quadruples */
        err = huffman_2step_quad(2, ld, sp);
	return err;
}

uint8_t huffman_spectral_data3(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=4)
    /* binary search for data quadruples */
        err = huffman_binary_quad_sign(3, ld, sp);
	return err;
}

uint8_t huffman_spectral_data4(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=4)
    /* 2-step method for data quadruples */
        err = huffman_2step_quad_sign(4, ld, sp);
	return err;
}

uint8_t huffman_spectral_data5(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=2)
    /* binary search for data pairs */
        err = huffman_binary_pair(5, ld, sp);
	return err;
}

uint8_t huffman_spectral_data6(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=2)
    /* 2-step method for data pairs */
        err = huffman_2step_pair(6, ld, sp);
	return err;
}

uint8_t huffman_spectral_data7(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=2)
    /* binary search for data pairs */
        err = huffman_binary_pair_sign(7, ld, sp);
	return err;
}

uint8_t huffman_spectral_data9(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=2)
    /* binary search for data pairs */
        err = huffman_binary_pair_sign(9, ld, sp);
	return err;
}

uint8_t huffman_spectral_data8(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=2)
    /* 2-step method for data pairs */
        err = huffman_2step_pair_sign(8, ld, sp);
	return err;
}

uint8_t huffman_spectral_data10(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=2)
    /* 2-step method for data pairs */
        err = huffman_2step_pair_sign(10, ld, sp);
	return err;
}

uint8_t huffman_spectral_data12(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=2)
	{
        err = huffman_2step_pair(11, ld, sp);
        sp[0] = huffman_codebook(0); sp[1] = huffman_codebook(1); 
	}
    return err; 
}

uint8_t huffman_spectral_data11(bitfile *ld, int16_t *sp, int16_t *spe)
{
	uint8_t err = 0;
	for (;sp!=spe && !err;sp+=2)
    {
        err = huffman_2step_pair_sign(11, ld, sp);
        sp[0] = huffman_getescape(ld, sp[0]);
        sp[1] = huffman_getescape(ld, sp[1]);
    }
    return err;
}

uint8_t huffman_spectral_data(uint8_t cb, bitfile *ld, int16_t *sp, int16_t *spe)
{
#ifdef ERROR_RESILIENCE
    /* VCB11 uses codebook 11 */
    if (cb >= 16 && cb < 32)
    {
		uint8_t err = 0;
		for (;sp != spe; sp += 2)
		{
			err = huffman_2step_pair_sign(11, ld, sp);
			if (err>0) break;
			sp[0] = huffman_getescape(ld, sp[0]);
			sp[1] = huffman_getescape(ld, sp[1]);

			/* check LAV (Largest Absolute Value) */
			/* this finds errors in the ESCAPE signal */
			vcb11_check_LAV(cb, sp);
		}
        return err;
    }
#endif
    /* Non existent codebook number, something went wrong */
    return 11;
}


#ifdef ERROR_RESILIENCE

/* Special version of huffman_spectral_data
Will not read from a bitfile but a bits_t structure.
Will keep track of the bits decoded and return the number of bits remaining.
Do not read more than ld->len, return -1 if codeword would be longer */

int8_t huffman_spectral_data_2(uint8_t cb, bits_t *ld, int16_t *sp)
{
    uint32_t cw;
    uint16_t offset = 0;
    uint8_t extra_bits;
    uint8_t i, vcb11 = 0;


    switch (cb)
    {
    case 1: /* 2-step method for data quadruples */
    case 2:
    case 4:

        cw = showbits_hcr(ld, hcbN[cb]);
        offset = hcb_table[cb][cw].offset;
        extra_bits = hcb_table[cb][cw].extra_bits;

        if (extra_bits)
        {
            /* we know for sure it's more than hcbN[cb] bits long */
            if ( flushbits_hcr(ld, hcbN[cb]) ) return -1;
            offset += (uint16_t)showbits_hcr(ld, extra_bits);
            if ( flushbits_hcr(ld, hcb_2_quad_table[cb][offset].bits - hcbN[cb]) ) return -1;
        } else {
            if ( flushbits_hcr(ld, hcb_2_quad_table[cb][offset].bits) ) return -1;
        }

        sp[0] = hcb_2_quad_table[cb][offset].x;
        sp[1] = hcb_2_quad_table[cb][offset].y;
        sp[2] = hcb_2_quad_table[cb][offset].v;
        sp[3] = hcb_2_quad_table[cb][offset].w;
        break;

    case 6: /* 2-step method for data pairs */
    case 8:
    case 10:
    case 11:
    /* VCB11 uses codebook 11 */
    case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23:
    case 24: case 25: case 26: case 27: case 28: case 29: case 30: case 31:

        if (cb >= 16)
        {
            /* store the virtual codebook */
            vcb11 = cb;
            cb = 11;
        }
            
        cw = showbits_hcr(ld, hcbN[cb]);
        offset = hcb_table[cb][cw].offset;
        extra_bits = hcb_table[cb][cw].extra_bits;

        if (extra_bits)
        {
            /* we know for sure it's more than hcbN[cb] bits long */
            if ( flushbits_hcr(ld, hcbN[cb]) ) return -1;
            offset += (uint16_t)showbits_hcr(ld, extra_bits);
            if ( flushbits_hcr(ld, hcb_2_pair_table[cb][offset].bits - hcbN[cb]) ) return -1;
        } else {
            if ( flushbits_hcr(ld, hcb_2_pair_table[cb][offset].bits) ) return -1;
        }
        sp[0] = hcb_2_pair_table[cb][offset].x;
        sp[1] = hcb_2_pair_table[cb][offset].y;
        break;

    case 3: /* binary search for data quadruples */

        while (!hcb3[offset].is_leaf)
        {
            uint8_t b;
            
            if ( get1bit_hcr(ld, &b) ) return -1;
            offset += hcb3[offset].data[b];
        }

        sp[0] = hcb3[offset].data[0];
        sp[1] = hcb3[offset].data[1];
        sp[2] = hcb3[offset].data[2];
        sp[3] = hcb3[offset].data[3];

        break;

    case 5: /* binary search for data pairs */
    case 7:
    case 9:

        while (!hcb_bin_table[cb][offset].is_leaf)
        {
            uint8_t b;
            
            if (get1bit_hcr(ld, &b) ) return -1;
            offset += hcb_bin_table[cb][offset].data[b];
        }

        sp[0] = hcb_bin_table[cb][offset].data[0];
        sp[1] = hcb_bin_table[cb][offset].data[1];

        break;
    }

	/* decode sign bits */
    if (unsigned_cb[cb])
    {
        for(i = 0; i < ((cb < FIRST_PAIR_HCB) ? QUAD_LEN : PAIR_LEN); i++)
        {
            if(sp[i])
            {
            	uint8_t b;
                if ( get1bit_hcr(ld, &b) ) return -1;
                if (b != 0) {
                    sp[i] = -sp[i];
                }
           }
        }
    }

    /* decode huffman escape bits */
    if ((cb == ESC_HCB) || (cb >= 16))
    {
        uint8_t k;
        for (k = 0; k < 2; k++)
        {
            if ((sp[k] == 16) || (sp[k] == -16))
            {
                uint8_t neg, i;
                int32_t j;
                uint32_t off;

                neg = (sp[k] < 0) ? 1 : 0; 

                for (i = 4; ; i++)
                {
                    uint8_t b;
                    if (get1bit_hcr(ld, &b))
                        return -1;
                    if (b == 0)
                        break;
                }

                if (getbits_hcr(ld, i, &off))
                    return -1;
                j = off + (1<<i);
                sp[k] = (int16_t)((neg) ? -j : j);
            }
        }

        if (vcb11 != 0)
        {
            /* check LAV (Largest Absolute Value) */
            /* this finds errors in the ESCAPE signal */
            vcb11_check_LAV(vcb11, sp);
        }
    }    
    return ld->len;
}

#endif