layer3.c

xmms-1.2.10.tar.gz学习使用的就下吧

	int *me;

	int num = mpg123_getbitoffset();
	long mask;
	/* we must split this, because for num==0 the shift is undefined if you do it in one step */
	mask = ((unsigned long) mpg123_getbits(num)) << BITSHIFT;
	mask <<= 8 - num;
	part2remain -= num;

	{
		int bv = gr_info->big_values;
		int region1 = gr_info->region1start;
		int region2 = gr_info->region2start;

		l3 = ((576 >> 1) - bv) >> 1;
/*
 * we may lose the 'odd' bit here !! 
 * check this later again 
 */
		if (bv <= region1)
		{
			l[0] = bv;
			l[1] = 0;
			l[2] = 0;
		}
		else
		{
			l[0] = region1;
			if (bv <= region2)
			{
				l[1] = bv - l[0];
				l[2] = 0;
			}
			else
			{
				l[1] = region2 - l[0];
				l[2] = bv - region2;
			}
		}
	}

	if (gr_info->block_type == 2)
	{
		/*
		 * decoding with short or mixed mode BandIndex table 
		 */
		int i, max[4];
		int step = 0, lwin = 3, cb = 0;
		register real v = 0.0;
		register int *m, mc;

		if (gr_info->mixed_block_flag)
		{
			max[3] = -1;
			max[0] = max[1] = max[2] = 2;
			m = map[sfreq][0];
			me = mapend[sfreq][0];
		}
		else
		{
			max[0] = max[1] = max[2] = max[3] = -1;
			/* max[3] not really needed in this case */
			m = map[sfreq][1];
			me = mapend[sfreq][1];
		}

		mc = 0;
		for (i = 0; i < 2; i++)
		{
			int lp = l[i];
			struct newhuff *h = ht + gr_info->table_select[i];

			for (; lp; lp--, mc--)
			{
				register int x, y;
				if ((!mc))
				{
					mc = *m++;
					xrpnt = ((real *) xr) + (*m++);
					lwin = *m++;
					cb = *m++;
					if (lwin == 3)
					{
						v = gr_info->pow2gain[(*scf++) << shift];
						step = 1;
					}
					else
					{
						v = gr_info->full_gain[lwin][(*scf++) << shift];
						step = 3;
					}
				}
				{
					register short *val = h->table;

					REFRESH_MASK();
					while ((y = *val++) < 0)
					{
						if (mask < 0)
							val -= y;
						num--;
						mask <<= 1;
					}
					x = y >> 4;
					y &= 0xf;
				}
				if (x == 15 && h->linbits)
				{
					max[lwin] = cb;
					REFRESH_MASK();
					x += ((unsigned long) mask) >> (BITSHIFT + 8 - h->linbits);
					num -= h->linbits + 1;
					mask <<= h->linbits;
					if (mask < 0)
						*xrpnt = -ispow[x] * v;
					else
						*xrpnt = ispow[x] * v;
					mask <<= 1;
				}
				else if (x)
				{
					max[lwin] = cb;
					if (mask < 0)
						*xrpnt = -ispow[x] * v;
					else
						*xrpnt = ispow[x] * v;
					num--;
					mask <<= 1;
				}
				else
					*xrpnt = 0.0;
				xrpnt += step;
				if (y == 15 && h->linbits)
				{
					max[lwin] = cb;
					REFRESH_MASK();
					y += ((unsigned long) mask) >> (BITSHIFT + 8 - h->linbits);
					num -= h->linbits + 1;
					mask <<= h->linbits;
					if (mask < 0)
						*xrpnt = -ispow[y] * v;
					else
						*xrpnt = ispow[y] * v;
					mask <<= 1;
				}
				else if (y)
				{
					max[lwin] = cb;
					if (mask < 0)
						*xrpnt = -ispow[y] * v;
					else
						*xrpnt = ispow[y] * v;
					num--;
					mask <<= 1;
				}
				else
					*xrpnt = 0.0;
				xrpnt += step;
			}
		}

		for (; l3 && (part2remain + num > 0); l3--)
		{
			struct newhuff *h = htc + gr_info->count1table_select;
			register short *val = h->table, a;

			REFRESH_MASK();
			while ((a = *val++) < 0)
			{
				if (mask < 0)
					val -= a;
				num--;
				mask <<= 1;
			}
			if (part2remain + num <= 0)
			{
				num -= part2remain + num;
				break;
			}

			for (i = 0; i < 4; i++)
			{
				if (!(i & 1))
				{
					if (!mc)
					{
						mc = *m++;
						xrpnt =	((real *) xr) + (*m++);
						lwin = *m++;
						cb = *m++;
						if (lwin == 3)
						{
							v = gr_info->pow2gain[(*scf++) << shift];
							step = 1;
						}
						else
						{
							v = gr_info->full_gain[lwin][(*scf++) << shift];
							step = 3;
						}
					}
					mc--;
				}
				if ((a & (0x8 >> i)))
				{
					max[lwin] = cb;
					if (part2remain + num <= 0)
					{
						break;
					}
					if (mask < 0)
						*xrpnt = -v;
					else
						*xrpnt = v;
					num--;
					mask <<= 1;
				}
				else
					*xrpnt = 0.0;
				xrpnt += step;
			}
		}

		if (lwin < 3)
		{		/* short band? */
			while (1)
			{
				/* HACK Prevent overflowing the xr buffer */
				if (mc * 6 > &xr[SBLIMIT][SSLIMIT] - xrpnt)
					return 1;
					
				for (; mc > 0; mc--)
				{
					*xrpnt = 0.0;
					xrpnt += 3;	/* short band -> step=3 */
					*xrpnt = 0.0;
					xrpnt += 3;
				}
				if (m >= me)
					break;
				mc = *m++;
				xrpnt = ((real *) xr) + *m++;
				if (*m++ == 0)
					break;	/* optimize: field will be set to zero at the end of the function */
				m++;	/* cb */
			}
		}

		gr_info->maxband[0] = max[0] + 1;
		gr_info->maxband[1] = max[1] + 1;
		gr_info->maxband[2] = max[2] + 1;
		gr_info->maxbandl = max[3] + 1;

		{
			int rmax = max[0] > max[1] ? max[0] : max[1];

			rmax = (rmax > max[2] ? rmax : max[2]) + 1;
			gr_info->maxb = rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3] + 1];
		}

	}
	else
	{
		/*
		 * decoding with 'long' BandIndex table (block_type != 2)
		 */
		int *pretab = gr_info->preflag ? pretab1 : pretab2;
		int i, max = -1;
		int cb = 0;
		int *m = map[sfreq][2];
		register real v = 0.0;
		int mc = 0;

		/*
		 * long hash table values
		 */
		for (i = 0; i < 3; i++)
		{
			int lp = l[i];
			struct newhuff *h = ht + gr_info->table_select[i];

			for (; lp; lp--, mc--)
			{
				int x, y;

				if (!mc)
				{
					mc = *m++;
					cb = *m++;
/*  					if (cb == 21) */
/*  						v = 0.0; */
/*  					else */
						v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];

				}
				{
					register short *val = h->table;
					REFRESH_MASK();
					while ((y = *val++) < 0)
					{
						if (mask < 0)
							val -= y;
						num--;
						mask <<= 1;
					}
					x = y >> 4;
					y &= 0xf;
				}

				if (x == 15 && h->linbits)
				{
					max = cb;
					REFRESH_MASK();
					x += ((unsigned long) mask) >> (BITSHIFT + 8 - h->linbits);
					num -= h->linbits + 1;
					mask <<= h->linbits;
					if (mask < 0)
						*xrpnt++ = -ispow[x] * v;
					else
						*xrpnt++ = ispow[x] * v;
					mask <<= 1;
				}
				else if (x)
				{
					max = cb;
					if (mask < 0)
						*xrpnt++ = -ispow[x] * v;
					else
						*xrpnt++ = ispow[x] * v;
					num--;
					mask <<= 1;
				}
				else
					*xrpnt++ = 0.0;

				if (y == 15 && h->linbits)
				{
					max = cb;
					REFRESH_MASK();
					y += ((unsigned long) mask) >> (BITSHIFT + 8 - h->linbits);
					num -= h->linbits + 1;
					mask <<= h->linbits;
					if (mask < 0)
						*xrpnt++ = -ispow[y] * v;
					else
						*xrpnt++ = ispow[y] * v;
					mask <<= 1;
				}
				else if (y)
				{
					max = cb;
					if (mask < 0)
						*xrpnt++ = -ispow[y] * v;
					else
						*xrpnt++ = ispow[y] * v;
					num--;
					mask <<= 1;
				}
				else
					*xrpnt++ = 0.0;
			}
		}

		/*
		 * short (count1table) values
		 */
		for (; l3 && (part2remain + num > 0); l3--)
		{
			struct newhuff *h = htc + gr_info->count1table_select;
			register short *val = h->table, a;

			REFRESH_MASK();
			while ((a = *val++) < 0)
			{
				if (mask < 0)
					val -= a;
				num--;
				mask <<= 1;
			}
			if (part2remain + num <= 0)
			{
				num -= part2remain + num;
				break;
			}

			for (i = 0; i < 4; i++)
			{
				if (!(i & 1))
				{
					if (!mc)
					{
						mc = *m++;
						cb = *m++;
/*  						if (cb == 21) */
/*  							v = 0.0; */
/*  						else */
							v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
					}
					mc--;
				}
				if ((a & (0x8 >> i)))
				{
					max = cb;
					if (part2remain + num <= 0)
					{
						break;
					}
					if (mask < 0)
						*xrpnt++ = -v;
					else
						*xrpnt++ = v;
					num--;
					mask <<= 1;
				}
				else
					*xrpnt++ = 0.0;
			}
		}

		gr_info->maxbandl = max + 1;
		gr_info->maxb = longLimit[sfreq][gr_info->maxbandl];
	}

	part2remain += num;
	mpg123_backbits(num);
	num = 0;

	while (xrpnt < &xr[SBLIMIT][0])
		*xrpnt++ = 0.0;

	while (part2remain > 16)
	{
		mpg123_getbits(16);	/* Dismiss stuffing Bits */
		part2remain -= 16;
	}
	if (part2remain > 0)
		mpg123_getbits(part2remain);
	else if (part2remain < 0)
	{
/*  		fprintf(stderr, "mpg123: Can't rewind stream by %d bits!\n", */
/*  			-part2remain); */
		return 1;	/* -> error */
	}
	return 0;
}

/* 
 * III_stereo: calculate real channel values for Joint-I-Stereo-mode
 */
static void III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT], int *scalefac, struct gr_info_s *gr_info, int sfreq, int ms_stereo, int lsf)
{
	real(*xr)[SBLIMIT * SSLIMIT] = (real(*)[SBLIMIT * SSLIMIT]) xr_buf;
	struct bandInfoStruct *bi = &bandInfo[sfreq];

	const real *tab1, *tab2;

#if 1
	int tab;
	static const real *tabs[3][2][2] = {
		{{tan1_1, tan2_1}, {tan1_2, tan2_2}},
		{{pow1_1[0], pow2_1[0]}, {pow1_2[0], pow2_2[0]}},
		{{pow1_1[1], pow2_1[1]}, {pow1_2[1], pow2_2[1]}}
	};

	tab = lsf + (gr_info->scalefac_compress & lsf);
	tab1 = tabs[tab][ms_stereo][0];
	tab2 = tabs[tab][ms_stereo][1];
#else
	if (lsf)
	{
		int p = gr_info->scalefac_compress & 0x1;

		if (ms_stereo)
		{
			tab1 = pow1_2[p];
			tab2 = pow2_2[p];
		}
		else
		{
			tab1 = pow1_1[p];
			tab2 = pow2_1[p];
		}
	}
	else
	{
		if (ms_stereo)
		{
			tab1 = tan1_2;
			tab2 = tan2_2;
		}
		else
		{
			tab1 = tan1_1;
			tab2 = tan2_1;
		}
	}
#endif

	if (gr_info->block_type == 2)
	{
		int lwin, do_l = 0;

		if (gr_info->mixed_block_flag)
			do_l = 1;

		for (lwin = 0; lwin < 3; lwin++)
		{	/* process each window */
			/* get first band with zero values */
			int is_p, sb, idx, sfb = gr_info->maxband[lwin];	/* sfb is minimal 3 for mixed mode */

			if (sfb > 3)
				do_l = 0;

			for (; sfb < 12; sfb++)
			{
				is_p = scalefac[sfb * 3 + lwin - gr_info->mixed_block_flag];	/* scale: 0-15 */
				if (is_p != 7)
				{
					real t1, t2;

					sb = bi->shortDiff[sfb];
					idx = bi->shortIdx[sfb] + lwin;
					t1 = tab1[is_p];
					t2 = tab2[is_p];
					for (; sb > 0; sb--, idx += 3)
					{
						real v = xr[0][idx];

						xr[0][idx] = v * t1;
						xr[1][idx] = v * t2;
					}
				}
			}

#if 1
/* in the original: copy 10 to 11 , here: copy 11 to 12 
   maybe still wrong??? (copy 12 to 13?) */
			is_p = scalefac[11 * 3 + lwin - gr_info->mixed_block_flag];	/* scale: 0-15 */
			sb = bi->shortDiff[12];
			idx = bi->shortIdx[12] + lwin;
#else
			is_p = scalefac[10 * 3 + lwin - gr_info->mixed_block_flag];	/* scale: 0-15 */
			sb = bi->shortDiff[11];
			idx = bi->shortIdx[11] + lwin;
#endif
			if (is_p != 7)
			{
				real t1, t2;
				t1 = tab1[is_p];
				t2 = tab2[is_p];
				for (; sb > 0; sb--, idx += 3)
				{
					real v = xr[0][idx];
					xr[0][idx] = v * t1;
					xr[1][idx] = v * t2;
				}
			}
		}		/* end for(lwin; .. ; . ) */

/* also check l-part, if ALL bands in the three windows are 'empty'
 * and mode = mixed_mode 
 */
		if (do_l)
		{
			int sfb = gr_info->maxbandl;
			int idx = bi->longIdx[sfb];

			for (; sfb < 8; sfb++)
			{
				int sb = bi->longDiff[sfb];
				int is_p = scalefac[sfb];	/* scale: 0-15 */

				if (is_p != 7)
				{
					real t1, t2;

					t1 = tab1[is_p];
					t2 = tab2[is_p];
					for (; sb > 0; sb--, idx++)
					{
						real v = xr[0][idx];

						xr[0][idx] = v * t1;
						xr[1][idx] = v * t2;
					}
				}
				else
					idx += sb;
			}
		}
	}
	else
	{			/* ((gr_info->block_type != 2)) */
		int sfb = gr_info->maxbandl;
		int is_p, idx = bi->longIdx[sfb];

/* hmm ... maybe the maxbandl stuff for i-stereo is buggy? */
		if (sfb <= 21)
 		{
			for (; sfb < 21; sfb++)
			{
				int sb = bi->longDiff[sfb];

				is_p = scalefac[sfb];	/* scale: 0-15 */
				if (is_p != 7)
				{
					real t1, t2;
					t1 = tab1[is_p];
					t2 = tab2[is_p];
					for (; sb > 0; sb--, idx++)
					{
						real v = xr[0][idx];
						xr[0][idx] = v * t1;
						xr[1][idx] = v * t2;
					}
				}
				else
					idx += sb;
			}

			is_p = scalefac[20];
			if (is_p != 7)
			{		/* copy l-band 20 to l-band 21 */
				int sb;
				real t1 = tab1[is_p], t2 = tab2[is_p];

				for (sb = bi->longDiff[21]; sb > 0; sb--, idx++)
				{
					real v = xr[0][idx];

					xr[0][idx] = v * t1;
					xr[1][idx] = v * t2;
				}
			}
		}
	}		/* ... */
}

static void III_antialias(real xr[SBLIMIT][SSLIMIT], struct gr_info_s *gr_info)
{
	int sblim;

	if (gr_info->block_type == 2)
	{
		if (!gr_info->mixed_block_flag)
			return;
		sblim = 1;
	}
	else
	{
		sblim = gr_info->maxb - 1;
	}