spcadecoder.c

凌阳SPCA5XX解码芯片USB驱动源代码

}
static int dec_readmarker(struct in *in)

{
	int m;

	in->left = fillbits(in, in->left, in->bits);
	if ((m = in->marker) == 0)
		return 0;
	in->left = 0;
	in->marker = 0;
	return m;
}

static int dec_checkmarker(void)
{
	int i;

	if (dec_readmarker(&in) != info.rm)
		return -1;
	info.nm = info.dri;
	info.rm = (info.rm + 1) & ~0x08;
	for (i = 0; i < info.ns; i++)
		dscans[i].dc = 0;
	return 0;
}

static int
dec_rec2 (struct in *in, struct dec_hufftbl *hu, int *runp, int c, int i)
{
	int le, bi;

	le = in->left;
	bi = in->bits;
	if (i) {
		UNGETBITS (in, i & 127);
		*runp = i >> 8 & 15;
		i >>= 16;
	} else {
		for (i = DECBITS;
		     (c = ((c << 1) | GETBITS (in, 1))) >= (hu->maxcode[i]);
		     i++) ;
		if (i >= 16) {
			in->marker = M_BADHUFF;
			return 0;
		}
		i = hu->vals[hu->valptr[i] + c - hu->maxcode[i - 1] * 2];
		*runp = i >> 4;
		i &= 15;
	}
	if (i == 0) {		/* sigh, 0xf0 is 11 bit */
		LEBI_PUT (in);
		return 0;
	}
	/* receive part */
	c = GETBITS (in, i);
	if (c < (1 << (i - 1)))
		c += (-1 << i) + 1;
	LEBI_PUT (in);
	return c;
}

#define DEC_REC(in, hu, r, i)	 (	\
  r = GETBITS(in, DECBITS),		\
  i = hu->llvals[r],			\
  i & 128 ?				\
    (					\
      UNGETBITS(in, i & 127),		\
      r = i >> 8 & 15,			\
      i >> 16				\
    )					\
  :					\
    (					\
      LEBI_PUT(in),			\
      i = dec_rec2(in, hu, &r, r, i),	\
      LEBI_GET(in),			\
      i					\
    )					\
)

inline static void
decode_mcus (struct in *in, int *dct, int n, struct scan *sc, int *maxp)
{
	struct dec_hufftbl *hu;
	int i, r, t;
	int le, bi;

	memset (dct, 0, n * 64 * sizeof (*dct));
	le = in->left;
	bi = in->bits;

	while (n-- > 0) {
		hu = sc->hudc.dhuff;
		*dct++ = (sc->dc += DEC_REC (in, hu, r, t));

		hu = sc->huac.dhuff;
		i = 63;
		while (i > 0) {
			t = DEC_REC (in, hu, r, t);
			if (t == 0 && r == 0) {
				dct += i;
				break;
			}
			dct += r;
			*dct++ = t;
			i -= r + 1;
		}
		*maxp++ = 64 - i;
		if (n == sc->next)
			sc++;
	}
	LEBI_PUT (in);
}

static void
dec_makehuff (struct dec_hufftbl *hu, int *hufflen, unsigned char *huffvals)
{
	int code, k, i, j, d, x, c, v;

	for (i = 0; i < (1 << DECBITS); i++)
		hu->llvals[i] = 0;

/*
 * llvals layout:
 *
 * value v already known, run r, backup u bits:
 *  vvvvvvvvvvvvvvvv 0000 rrrr 1 uuuuuuu
 * value unknown, size b bits, run r, backup u bits:
 *  000000000000bbbb 0000 rrrr 0 uuuuuuu
 * value and size unknown:
 *  0000000000000000 0000 0000 0 0000000
 */
	code = 0;
	k = 0;
	for (i = 0; i < 16; i++, code <<= 1) {	/* sizes */
		hu->valptr[i] = k;
		for (j = 0; j < hufflen[i]; j++) {
			hu->vals[k] = *huffvals++;
			if (i < DECBITS) {
				c = code << (DECBITS - 1 - i);
				v = hu->vals[k] & 0x0f;	/* size */
				for (d = 1 << (DECBITS - 1 - i); --d >= 0;) {
					if (v + i < DECBITS) {	/* both fit in table */
						x = d >> (DECBITS - 1 - v - i);
						if (v && x < (1 << (v - 1)))
							x += (-1 << v) + 1;
						x = x << 16 | (hu->
							       vals[k] & 0xf0)
							<< 4 | (DECBITS -
								(i + 1 +
								 v)) | 128;
					} else
						x = v << 16 | (hu->
							       vals[k] & 0xf0)
							<< 4 | (DECBITS -
								(i + 1));
					hu->llvals[c | d] = x;
				}
			}
			code++;
			k++;
		}
		hu->maxcode[i] = code;
	}
	hu->maxcode[16] = 0x20000;	/* always terminate decode */
}

/****************************************************************/
/**************             idct                  ***************/
/****************************************************************/


#define S22 ((long)IFIX(2 * 0.382683432))
#define C22 ((long)IFIX(2 * 0.923879532))
#define IC4 ((long)IFIX(1 / 0.707106781))

static unsigned char zig2[64] = {
	0, 2, 3, 9, 10, 20, 21, 35,
	14, 16, 25, 31, 39, 46, 50, 57,
	5, 7, 12, 18, 23, 33, 37, 48,
	27, 29, 41, 44, 52, 55, 59, 62,
	15, 26, 30, 40, 45, 51, 56, 58,
	1, 4, 8, 11, 19, 22, 34, 36,
	28, 42, 43, 53, 54, 60, 61, 63,
	6, 13, 17, 24, 32, 38, 47, 49
};

inline static void
idct (int *in, int *out, int *quant, long off, int max)
{
	long t0, t1, t2, t3, t4, t5, t6, t7;	// t ;
	long tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
	long tmp[64], *tmpp;
	int i, j, te;
	unsigned char *zig2p;

	t0 = off;
	if (max == 1) {
		t0 += in[0] * quant[0];
		for (i = 0; i < 64; i++)
			out[i] = ITOINT (t0);
		return;
	}
	zig2p = zig2;
	tmpp = tmp;
	for (i = 0; i < 8; i++) {
		j = *zig2p++;
		t0 += in[j] * (long) quant[j];
		j = *zig2p++;
		t5 = in[j] * (long) quant[j];
		j = *zig2p++;
		t2 = in[j] * (long) quant[j];
		j = *zig2p++;
		t7 = in[j] * (long) quant[j];
		j = *zig2p++;
		t1 = in[j] * (long) quant[j];
		j = *zig2p++;
		t4 = in[j] * (long) quant[j];
		j = *zig2p++;
		t3 = in[j] * (long) quant[j];
		j = *zig2p++;
		t6 = in[j] * (long) quant[j];


		if ((t1 | t2 | t3 | t4 | t5 | t6 | t7) == 0) {

			tmpp[0 * 8] = t0;
			tmpp[1 * 8] = t0;
			tmpp[2 * 8] = t0;
			tmpp[3 * 8] = t0;
			tmpp[4 * 8] = t0;
			tmpp[5 * 8] = t0;
			tmpp[6 * 8] = t0;
			tmpp[7 * 8] = t0;

			tmpp++;
			t0 = 0;
			continue;
		}
		//IDCT;
		tmp0 = t0 + t1;
		t1 = t0 - t1;
		tmp2 = t2 - t3;
		t3 = t2 + t3;
		tmp2 = IMULT (tmp2, IC4) - t3;
		tmp3 = tmp0 + t3;
		t3 = tmp0 - t3;
		tmp1 = t1 + tmp2;
		tmp2 = t1 - tmp2;
		tmp4 = t4 - t7;
		t7 = t4 + t7;
		tmp5 = t5 + t6;
		t6 = t5 - t6;
		tmp6 = tmp5 - t7;
		t7 = tmp5 + t7;
		tmp5 = IMULT (tmp6, IC4);
		tmp6 = IMULT ((tmp4 + t6), S22);
		tmp4 = IMULT (tmp4, (C22 - S22)) + tmp6;
		t6 = IMULT (t6, (C22 + S22)) - tmp6;
		t6 = t6 - t7;
		t5 = tmp5 - t6;
		t4 = tmp4 - t5;

		tmpp[0 * 8] = tmp3 + t7;	//t0;
		tmpp[1 * 8] = tmp1 + t6;	//t1;
		tmpp[2 * 8] = tmp2 + t5;	//t2;
		tmpp[3 * 8] = t3 + t4;	//t3;
		tmpp[4 * 8] = t3 - t4;	//t4;
		tmpp[5 * 8] = tmp2 - t5;	//t5;
		tmpp[6 * 8] = tmp1 - t6;	//t6;
		tmpp[7 * 8] = tmp3 - t7;	//t7;
		tmpp++;
		t0 = 0;
	}
	for (i = 0, j = 0; i < 8; i++) {
		t0 = tmp[j + 0];
		t1 = tmp[j + 1];
		t2 = tmp[j + 2];
		t3 = tmp[j + 3];
		t4 = tmp[j + 4];
		t5 = tmp[j + 5];
		t6 = tmp[j + 6];
		t7 = tmp[j + 7];
		if ((t1 | t2 | t3 | t4 | t5 | t6 | t7) == 0) {
			te = ITOINT (t0);
			out[j + 0] = te;
			out[j + 1] = te;
			out[j + 2] = te;
			out[j + 3] = te;
			out[j + 4] = te;
			out[j + 5] = te;
			out[j + 6] = te;
			out[j + 7] = te;
			j += 8;
			continue;
		}
		//IDCT;
		tmp0 = t0 + t1;
		t1 = t0 - t1;
		tmp2 = t2 - t3;
		t3 = t2 + t3;
		tmp2 = IMULT (tmp2, IC4) - t3;
		tmp3 = tmp0 + t3;
		t3 = tmp0 - t3;
		tmp1 = t1 + tmp2;
		tmp2 = t1 - tmp2;
		tmp4 = t4 - t7;
		t7 = t4 + t7;
		tmp5 = t5 + t6;
		t6 = t5 - t6;
		tmp6 = tmp5 - t7;
		t7 = tmp5 + t7;
		tmp5 = IMULT (tmp6, IC4);
		tmp6 = IMULT ((tmp4 + t6), S22);
		tmp4 = IMULT (tmp4, (C22 - S22)) + tmp6;
		t6 = IMULT (t6, (C22 + S22)) - tmp6;
		t6 = t6 - t7;
		t5 = tmp5 - t6;
		t4 = tmp4 - t5;

		out[j + 0] = ITOINT (tmp3 + t7);
		out[j + 1] = ITOINT (tmp1 + t6);
		out[j + 2] = ITOINT (tmp2 + t5);
		out[j + 3] = ITOINT (t3 + t4);
		out[j + 4] = ITOINT (t3 - t4);
		out[j + 5] = ITOINT (tmp2 - t5);
		out[j + 6] = ITOINT (tmp1 - t6);
		out[j + 7] = ITOINT (tmp3 - t7);
		j += 8;
	}

}

static unsigned char zig[64] = {
	0, 1, 5, 6, 14, 15, 27, 28,
	2, 4, 7, 13, 16, 26, 29, 42,
	3, 8, 12, 17, 25, 30, 41, 43,
	9, 11, 18, 24, 31, 40, 44, 53,
	10, 19, 23, 32, 39, 45, 52, 54,
	20, 22, 33, 38, 46, 51, 55, 60,
	21, 34, 37, 47, 50, 56, 59, 61,
	35, 36, 48, 49, 57, 58, 62, 63
};

static int aaidct[8] = {
	IFIX (0.3535533906), IFIX (0.4903926402),
	IFIX (0.4619397663), IFIX (0.4157348062),
	IFIX (0.3535533906), IFIX (0.2777851165),
	IFIX (0.1913417162), IFIX (0.0975451610)
};


inline static void
idctqtab (unsigned char *qin, int *qout)
{
	int i, j;

	for (i = 0; i < 8; i++)
		for (j = 0; j < 8; j++)
			qout[zig[i * 8 + j]] = qin[zig[i * 8 + j]] *
				IMULT (aaidct[i], aaidct[j]);
}

inline static void
scaleidctqtab (int *q, int sc)
{
	int i;

	for (i = 0; i < 64; i++)
		q[i] = IMULT (q[i], sc);
}

/* Reduce to the necessary minimum. FIXME */
void
init_jpeg_decoder (unsigned int qIndex)
{
	unsigned int i, j, k, l;
	//unsigned int qIndex = 1; // 2;
	int tc, th, tt, tac, tdc;
	unsigned char *ptr;

	/* set up a quantization table */
	for (i = 0; i < 2; i++) {
		for (j = 0; j < 64; j++) {
			quant[i][j] = GsmartQTable[qIndex * 2 + i][j];
		}
	}

	/* set up the huffman table */
	ptr = (unsigned char *) GsmartJPEGHuffmanTable;
	l = GSMART_JPG_HUFFMAN_TABLE_LENGTH;
	while (l > 0) {
		int hufflen[16];
		unsigned char huffvals[256];

		tc = *ptr++;
		th = tc & 15;
		tc >>= 4;
		tt = tc * 2 + th;
		if (tc > 1 || th > 1) {
			//printf("died whilst setting up huffman table.\n");
			//abort();
		}
		for (i = 0; i < 16; i++)
			hufflen[i] = *ptr++;
		l -= 1 + 16;
		k = 0;
		for (i = 0; i < 16; i++) {
			for (j = 0; j < (unsigned int) hufflen[i]; j++)
				huffvals[k++] = *ptr++;
			l -= hufflen[i];
		}
		dec_makehuff (dhuff + tt, hufflen, huffvals);
	}

	/* set up the scan table */
	ptr = (unsigned char *) GsmartJPEGScanTable;
	for (i = 0; i < 3; i++) {
		dscans[i].cid = *ptr++;
		tdc = *ptr++;
		tac = tdc & 15;
		tdc >>= 4;
		if (tdc > 1 || tac > 1) {
			//printf("died whilst setting up scan table.\n");
			//abort();
		}
		/* for each component */
		for (j = 0; j < 3; j++)
			if (comps[j].cid == dscans[i].cid)
				break;

		dscans[i].hv = comps[j].hv;
		dscans[i].tq = comps[j].tq;
		dscans[i].hudc.dhuff = dec_huffdc + tdc;
		dscans[i].huac.dhuff = dec_huffac + tac;
	}

	if (dscans[0].cid != 1 || dscans[1].cid != 2 || dscans[2].cid != 3) {
		//printf("invalid cid found.\n");
		//abort();
	}

	if (dscans[0].hv != 0x22 || dscans[1].hv != 0x11
	    || dscans[2].hv != 0x11) {
		//printf("invalid hv found.\n");
		//abort();
	}

	idctqtab (quant[dscans[0].tq], dquant[0]);
	idctqtab (quant[dscans[1].tq], dquant[1]);
	idctqtab (quant[dscans[2].tq], dquant[2]);
	/* rescale qtab */
	scaleidctqtab (dquant[0], IFIX (0.7));
	scaleidctqtab (dquant[1], IFIX (0.7));
	scaleidctqtab (dquant[2], IFIX (0.7));

	dscans[0].next = 6 - 4;
	dscans[1].next = 6 - 4 - 1;
	dscans[2].next = 6 - 4 - 1 - 1;	/* 411 encoding */

}