decode.c

ISO mp3 sources (distribution 10) Layer 1/2/3, C Source, 512 k Sources of the Mpeg 1,2 layer 1,2

			fraction[k][i][j][*z] += d[(*alloc)[i][bit_alloc[k][i]].quant];
			fraction[k][i][j][*z] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
		    }
		    else   /* 21.07.94 Ralf Schwalbe dyn. cross mode */
		    {
			if (fr_ps->dyn_cross_bits == 4  &&
			    ((fr_ps->header->dyn_cross_mode[sbgr]==0) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==1  && k!=4) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==2  && k!=3) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==3  && k!=2) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==8  && k!=4) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==9  && k!=3) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==10 && k!=4)))
			{
			    x = 0;
#ifndef MSDOS
			    while ((1L << x) < (*alloc)[i][bit_alloc[k][i]].steps)
				x++;
#else
			    /* microsoft C thinks an int is a short */
			    while (((unsigned long) (1L << (long) x) <
				    (unsigned long) ((*alloc)[i][bit_alloc[k][i]].steps)) &&
				   (x < 16))
				x++;
#endif
			    /* MSB inversion */
			    if (((sample[k][j][i] >> (x-1)) & 1) == 1)
				fraction[k][i][j][*z] = 0.0;
			    else
				fraction[k][i][j][*z] = -1.0;

			    /* Form a 2's complement sample */
			    fraction[k][i][j][*z] += (double) (sample[k][j][i] & ((1<<(x-1))-1)) /
						    (double) (1L<<(x-1));

			    /* Dequantize the sample */
			    fraction[k][i][j][*z] += d[(*alloc)[i][bit_alloc[k][i]].quant];
			    fraction[k][i][j][*z] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
			}  /* end if 2-channel dyn-cross mode */

			if (fr_ps->dyn_cross_bits != 4 ||
			    ((fr_ps->header->dyn_cross_mode[sbgr]==4  && k==2) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==5  && k==3) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==6  && k==4) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==11 && k==2) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==12 && k==2) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==13 && k==3) ||
			     (fr_ps->header->dyn_cross_mode[sbgr]==14 && k==2))) 
			{
			     if ((fr_ps->dyn_cross_bits == 3 && ((fr_ps->header->dyn_cross_mode[sbgr] == 1 && k==3) ||
								 (fr_ps->header->dyn_cross_mode[sbgr] == 2 && k==2) ||
								 fr_ps->header->dyn_cross_mode[sbgr] == 3 ||
								 (fr_ps->header->dyn_cross_mode[sbgr] == 4 && k==3)
								)) ||
				 (fr_ps->dyn_cross_bits == 1 && fr_ps->header->dyn_cross_mode[sbgr] == 1 && k == 2) ||
				 (fr_ps->header->surround == 3 && fr_ps->header->dyn_second_stereo[sbgr] == 1 &&
				  ((fr_ps->header->center != 0 && j == 4) || (fr_ps->header->center == 0 && j == 3))))
			     {
				     /* no samples to dequantize */
			     }
			     else
			     {
				x = 0;
#ifndef MSDOS
				while ((1L << x) < (*alloc)[i][bit_alloc[k][i]].steps)
				    x++;
#else
				/* microsoft C thinks an int is a short */
				while (((unsigned long) (1L << (long) x) <
					(unsigned long) ((*alloc)[i][bit_alloc[k][i]].steps)) &&
				       (x < 16))
				    x++;
#endif
				/* MSB inversion */
				if (((sample[k][j][i] >> (x-1)) & 1) == 1)
				    fraction[k][i][j][*z] = 0.0;
				else
				    fraction[k][i][j][*z] = -1.0;

				/* Form a 2's complement sample */
				fraction[k][i][j][*z] += (double) (sample[k][j][i] & ((1<<(x-1))-1)) /
							(double) (1L<<(x-1));

				/* Dequantize the sample */
				fraction[k][i][j][*z] += d[(*alloc)[i][bit_alloc[k][i]].quant];
				fraction[k][i][j][*z] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
			    } /* end if ..bits */
			}   /* end if 1-channel dyn-cross mode */
		    } /* end if dyn-cross on */
		} /* if bit_alloc */
	  	else
		    fraction[k][i][j][*z] = 0.0;
    }
    for (i = sblimit; i < SBLIMIT; i++)
	for (j = 0; j < 3; j++)
	    for (k = ch_start; k < channels; k++)
		fraction[k][i][j][*z] = 0.0;
}

#ifdef Augmentation_7ch
void II_dequantize_sample_aug (unsigned int sample[7][3][SBLIMIT],
			       unsigned int bit_alloc[7][SBLIMIT],
			       double fraction[7][SBLIMIT][3][12],
			       frame_params *fr_ps, int *z)
{
   int i, j, k, x,sbgr,l;
   int sblimit = fr_ps->sblimit_mc;
   al_table *alloc = fr_ps->alloc_mc;

   for (i = 0; i < sblimit; i++)
   {
	if( i == 0) sbgr = 0 ;
	else
	   for(l = 1; l < 12; l++)
		if((sb_groups[l-1] < i) && (i <= sb_groups[l]))
		{
		    sbgr = l; break;
		}
	for (j = 0; j < 3; j++)
	   for ( k = 5; k < 7; k++)
		if (bit_alloc[k][i])
		{
		   if ((fr_ps->header->dyn_cross_aug_mode[sbgr]== 0) ||
		       (fr_ps->header->dyn_cross_aug_mode[sbgr]== 1 && k==5) ||
		       (fr_ps->header->dyn_cross_aug_mode[sbgr]== 2 && k==5) ||
		       (fr_ps->header->dyn_cross_aug_mode[sbgr]== 3 && k==5) ||
		       (fr_ps->header->dyn_cross_aug_mode[sbgr]== 4 && k==5) ||
		       (fr_ps->header->dyn_cross_aug_mode[sbgr]== 5 && k==6) ||
		       (fr_ps->header->dyn_cross_aug_mode[sbgr]==10 && k==6) ||
		       (fr_ps->header->dyn_cross_aug_mode[sbgr]==14 && k==6))
		   {
			x = 0;
#ifndef MSDOS
			while ((1L<<x) < (*alloc)[i][bit_alloc[k][i]].steps) x++;
#else
			/* microsoft C thinks an int is a short */
			while (( (unsigned long) (1L<<(long)x) <
			(unsigned long)( (*alloc)[i][bit_alloc[k][i]].steps)) && ( x < 16) ) x++;
#endif
			/* MSB inversion */
			if (((sample[k][j][i] >> (x-1)) & 1) == 1)
			      fraction[k][i][j][*z] = 0.0;
			else  fraction[k][i][j][*z] = -1.0;

			/* Form a 2's complement sample */
			fraction[k][i][j][*z] += (double) (sample[k][j][i] & ((1<<(x-1))-1)) /
						(double) (1L<<(x-1));

			/* Dequantize the sample */
			fraction[k][i][j][*z] += d[(*alloc)[i][bit_alloc[k][i]].quant];
			fraction[k][i][j][*z] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
		   }  /* end if 2-channel dyn-cross mode */
		} /* if bit_alloc */
		else
		   fraction[k][i][j][*z] = 0.0;
   }
   for (i = sblimit; i < SBLIMIT; i++)
	  for (j = 0; j < 3; j++)
		 for(k = 5; k < 7; k++)
			 fraction[k][i][j][*z] = 0.0;
}
#endif

/*************************************************************************/
/* JMZ 09/03/1995 Multilingual */

void II_dequantize_sample_ml(unsigned int sample_ml[7][3][SBLIMIT],
			     unsigned int bit_alloc_ml[7][SBLIMIT],
			     double fraction_ml[7][SBLIMIT][3][12],
			     frame_params *fr_ps,
			     int *n_ml_ch,
			     int *z)
{
   int i, j, k, x,sbgr,l;
   int sblimit_ml = fr_ps->sblimit_ml;
   al_table *alloc_ml = fr_ps->alloc_ml;

   for (i = 0; i < sblimit_ml; i++)
   {
	  for (j = 0; j < 3; j++)
		 for ( k = 0; k < *n_ml_ch; k++)
			if (bit_alloc_ml[k][i])
			{
			  /* JR: ditto */
			  /* locate MSB in the sample */
			   x = 0;
#ifndef MSDOS
			   while ((1L<<x) < (*alloc_ml)[i][bit_alloc_ml[k][i]].steps) x++;
#else
			   /* microsoft C thinks an int is a short */
			   while (( (unsigned long) (1L<<(long)x) <
				(unsigned long)( (*alloc_ml)[i][bit_alloc_ml[k][i]].steps)
			   ) && ( x < 16) ) x++;
#endif
			   /* MSB inversion */
			   if (((sample_ml[k][j][i] >> (x-1)) & 1) == 1)
					fraction_ml[k][i][j][*z] = 0.0;
			   else  fraction_ml[k][i][j][*z] = -1.0;

			   /* Form a 2's complement sample */
			   fraction_ml[k][i][j][*z] += (double) (sample_ml[k][j][i] & ((1<<(x-1))-1)) /
							(double) (1L<<(x-1));

			   /* Dequantize the sample */
			   fraction_ml[k][i][j][*z] += d[(*alloc_ml)[i][bit_alloc_ml[k][i]].quant];
			   fraction_ml[k][i][j][*z] *= c[(*alloc_ml)[i][bit_alloc_ml[k][i]].quant];
			} /* if bit_alloc */
			else fraction_ml[k][i][j][*z] = 0.0;
   }
   for (i = sblimit_ml; i < SBLIMIT; i++)
	  for (j = 0; j < 3; j++)
		 for(k = 0; k < *n_ml_ch; k++)
			 fraction_ml[k][i][j][*z] = 0.0;
}

/**************************************************************************
II_lfe_calc();  R.Schwalbe 
**************************************************************************/
void II_lfe_calc(frame_params *fr_ps)
{
   layer *info = fr_ps->header;
   int x,i;
   al_table *alloc = fr_ps->alloc_mc;

   for(i = 0; i < 12; i++)
   {
	x = 0;
#ifndef MSDOS
   	while ((1L<<x) < (*alloc)[0][info->lfe_alloc].steps) x++;
#else
   	/* microsoft C thinks an int is a short */
   	while (( (unsigned long) (1L<<(long)x) <
   	(unsigned long)( (*alloc)[0][info->lfe_alloc].steps)) && ( x < 16) ) x++;
#endif
   	/* MSB inversion */
   	if (((info->lfe_spl[i] >> (x-1)) & 1) == 1)
     		info->lfe_spl_fraction[i] = 0.0;
   	else 	info->lfe_spl_fraction[i] = -1.0;

   	/* Form a 2's complement sample */
   	info->lfe_spl_fraction[i] += (double) (info->lfe_spl[i] & ((1<<(x-1))-1)) /
	 			(double) (1L<<(x-1));

   	/* Dequantize the sample */
   	info->lfe_spl_fraction[i] += d[(*alloc)[0][info->lfe_alloc].quant];
   	info->lfe_spl_fraction[i] *= c[(*alloc)[0][info->lfe_alloc].quant];

   	/* Denormalize the sample */
   	info->lfe_spl_fraction[i] *= multiple[info->lfe_scf];
    }
}

/************************************************************
/*
/*   Restore the original value of the sample ie multiply
/*    the fraction value by its scalefactor.
/*
/************************* Layer II Stuff **********************/

void I_denormalize_sample (double fraction[7][SBLIMIT][3][12],
			   unsigned int scale_index[7][3][SBLIMIT],
			   int part,
			   frame_params *fr_ps,
			   int *z)
{
   int i, j, k, gr_id, gr_sam;
   int stereo = fr_ps->stereo;
   int sblimit = fr_ps->sblimit;

   gr_id = 4*part + (*z / 3);
   gr_sam = *z % 3;

   for (i=0; i<SBLIMIT; i++)
      for (j=0; j<stereo; j++)
	 fraction[j][i][gr_sam][gr_id] *= multiple[scale_index[j][part][i]];
}

void II_denormalize_sample(double fraction[7][SBLIMIT][3][12],
			   unsigned int scale_index[7][3][SBLIMIT],
			   frame_params *fr_ps,
			   int x,
			   int *z)
{
   int i,j,k;
   int stereo = fr_ps->stereo;
   int sblimit = fr_ps->sblimit;

   for (i=0;i<sblimit;i++)
	for (j = 0;j < stereo; j++)
	{
	  fraction[j][i][0][*z] *= multiple[scale_index[j][x][i]];
	  fraction[j][i][1][*z] *= multiple[scale_index[j][x][i]];
	  fraction[j][i][2][*z] *= multiple[scale_index[j][x][i]];
	}
}

/************************* MC Layer II Stuff **********************/

void II_denormalize_sample_mc(double fraction[7][SBLIMIT][3][12],
			     unsigned int scale_index[7][3][SBLIMIT],
			     frame_params *fr_ps,
			     int x, int ch_start, int channels, int *z)
{
   int i,j,k,sbgr,l,bl=0;
   int sblimit = fr_ps->sblimit_mc;

   for (i = 0; i < sblimit; i++)
   {
      if (i == 0) sbgr = 0 ;
      else
	for (l = 1; l < 12; l++)
		if ((sb_groups[l-1] < i) && (i <= sb_groups[l]))
		{
			sbgr = l; break;
		}

      /* 960821 FdB new setup for dyn. crosstalk modes */
      for (bl = 0; bl < 3; bl++)	  		
	if (fr_ps->header->dyn_cross_on == 0)
		for (j = ch_start; j < channels; j++)
			fraction[j][i][bl][*z] *= multiple[scale_index[j][x][i]];
	else if (fr_ps->dyn_cross_bits == 0)   /* for channel mode 2/0 (+2/0) */
	{
		if (fr_ps->header->surround == 3)	/* 2/0 + 2/0 and 1/0 + 2/0 */
		{
			fraction[ch_start][i][bl][*z] *= multiple[scale_index[ch_start][x][i]];
			if (fr_ps->header->dyn_second_stereo[sbgr] == 0)
				fraction[ch_start+1][i][bl][*z] *= multiple[scale_index[ch_start+1][x][i]];
			else
				fraction[ch_start+1][i][bl][*z] = (fraction[ch_start][i][bl][*z] / multiple[scale_index[ch_start][x][i]])
									 * multiple[scale_index[ch_start+1][x][i]];
		}
	}
	else if (fr_ps->dyn_cross_bits == 1)   /* for channel mode 3/0 (+2/0) and 2/1 */
	{
		switch (fr_ps->header->dyn_cross_mode[sbgr])
		{
		  case 0 :	fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
				if (fr_ps->header->surround == 3)		/* 3/0 + 2/0 */
				{
					fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
					if (fr_ps->header->dyn_second_stereo[sbgr] == 0)
						fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
					else
						fraction[4][i][bl][*z] = (fraction[3][i][bl][*z] / multiple[scale_index[3][x][i]])
											 * multiple[scale_index[4][x][i]];
				}
			  	break;
		  case 1 :	if (fr_ps->header->tc_alloc[sbgr] == 0)
					if (fr_ps->header->dyn_cross_LR)	/* C,S from R0 */ 
						fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
							 					 * multiple[scale_index[2][x][i]];
				    	else					/* C,S from L0 */
						fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
												 * multiple[scale_index[2][x][i]];
				if (fr_ps->header->tc_alloc[sbgr] == 1)
					fraction[2][i][bl][*z] = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
											 * multiple[scale_index[2][x][i]];
				if (fr_ps->header->tc_alloc[sbgr] == 2)
					fraction[2][i][bl][*z] = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
											 * multiple[scale_index[2][x][i]];
				if (fr_ps->header->surround == 3)		/* 3/0 + 2/0 */
				{
					fraction[3][i][bl][*z] *= multiple[scale_index[3][x][i]];
					if (fr_ps->header->dyn_second_stereo[sbgr] == 0)
						fraction[4][i][bl][*z] *= multiple[scale_index[4][x][i]];
					else
						fraction[4][i][bl][*z] = (fraction[3][i][bl][*z] / multiple[scale_index[3][x][i]])
											 * multiple[scale_index[4][x][i]];
				}
		  	break;
		}
	}
	else if (fr_ps->dyn_cross_bits == 3)   /* for channel mode 3/1 and 2/2 */
	{
		switch (fr_ps->header->dyn_cross_mode[sbgr])
		{
		  case 0 :	for (j = ch_start; j < channels; j++)
					fraction[j][i][bl][*z] *= multiple[scale_index[j][x][i]];
			  	break;
		  case 1 :	fraction[2][i][bl][*z] *= multiple[scale_index[2][x][i]];
				if (fr_ps->header->surround == 2 ||		/* 2/2 mode */
				    fr_ps->header->tc_alloc[sbgr] == 4 ||	/* 3/1 mode */
				    fr_ps->header->tc_alloc[sbgr] == 5 ||	/* 3/1 mode, matrix mode 2 */
				    (fr_ps->header->tc_alloc[sbgr] != 3 && fr_ps->header->dyn_cross_LR))
					/* S, R or Rs from R0 */
					fraction[3][i][bl][*z]  = (fraction[1][i][bl][*z] / multiple[scale_index[1][x][i]])
											  * multiple[scale_index[3][x][i]];
				else
					/* S, L or Ls from L0 */
					fraction[3][i][bl][*z]  = (fraction[0][i][bl][*z] / multiple[scale_index[0][x][i]])
											  * multiple[scale_index[3][x][i]];
			  	break;
		  case 2 :	frac