decode.c

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

   /* 31/10/95 Ralf Schwalbe LFE */
   /* 961003 FdB LFE number of bits corrected */
   if(info->lfe && info->lfe_alloc > 0)
	info->lfe_spl[gr] = (unsigned int) getbits (bs, info->lfe_alloc+1);

   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 = ch_start; j < channels; j++)
	 {
	   if (bit_alloc[j][i])
	   {
	     transmitted = 1;
	     if (fr_ps->header->dyn_cross_on == 1)
	     {
		if (fr_ps->dyn_cross_bits == 4 && (
			(fr_ps->header->dyn_cross_mode[sbgr]==1  && j==4) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==2  && j==3) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==3  && j==2) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==4  && j!=2) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==5  && j!=3) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==6  && j!=4) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==7) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==8  && j==4) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==9  && j==3) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==10 && j==4) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==11 && j!=2) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==12 && j!=2) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==13 && j!=3) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==14 && j!=2)
					          ))
		   transmitted = 0;		/* 3/2 */
		if (fr_ps->dyn_cross_bits == 3 && (
			(fr_ps->header->dyn_cross_mode[sbgr]==1  && j==3) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==2  && j==2) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==3) ||
			(fr_ps->header->dyn_cross_mode[sbgr]==4  && j==3)
						  ))
		   transmitted = 0;		/* 3/1 and 2/2 */
		if (fr_ps->dyn_cross_bits == 1 && fr_ps->header->dyn_cross_mode[sbgr]==1 && j==2)
		   transmitted = 0;		/* 3/0 (+2/0) and 2/1 */
		if (fr_ps->header->surround == 3 && fr_ps->header->dyn_second_stereo[sbgr] == 1)
		{
		   if ((fr_ps->header->center == 1 || fr_ps->header->center == 3) && j == 4)
	              transmitted = 0;
	           else if (fr_ps->header->center == 0 && j == 3)
	              transmitted = 0;
		}
	     }
	   }
	   else
	      transmitted = 0;

	   if (transmitted == 1)
	   {
		/* check for grouping in subband */
		if ((*alloc)[i][bit_alloc[j][i]].group==3)
		{
			for (m=0;m<3;m++)
			{
				k = (*alloc)[i][bit_alloc[j][i]].bits;
				sample[j][m][i] = (unsigned int) getbits (bs, k);
			}
		}
		else
		{	/* bit_alloc = 3, 5, 9 */
			nlevels = (*alloc)[i][bit_alloc[j][i]].steps;
			k=(*alloc)[i][bit_alloc[j][i]].bits;
			c = (unsigned int) getbits (bs, k);
			for (k=0;k<3;k++)
			{
				sample[j][k][i] = c % nlevels;
				c /= nlevels;
			}
		}
	   }
	   else   /* no samples transmitted */
	      for (k=0; k<3; k++)
		 sample[j][k][i] = 0;
	 }  /* for channel loop */
   }  /* for sblimit loop */

   for (i = sblimit; i < SBLIMIT; i++)
	 for (j = ch_start; j < channels; j++)
		for (k = 0; k < 3; k++)  sample[j][k][i] = 0;
}

#ifdef Augmentation_7ch
void II_buffer_sample_aug(Bit_stream *bs,
			frame_params *fr_ps,
			unsigned int sample[7][3][SBLIMIT],
			unsigned int bit_alloc[7][SBLIMIT],
			int gr)
{
   int i,j,k,m,sbgr,l;
   unsigned int nlevels, c=0;
   int sblimit = fr_ps->sblimit_mc;
   int transmitted;
   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 = 5; j < 7; j++)
      {
	 if (bit_alloc[j][i])
	 {
	    transmitted = 1;
	    if (fr_ps->header->aug_dyn_cross_on == 1)
	    {
	       if (j == 5)
	       {
		  if (fr_ps->header->dyn_cross_aug_mode[sbgr] > 4)
		     transmitted = 0;
	       }
	       else
	       {
		  transmitted = 0;
		  switch (fr_ps->header->dyn_cross_aug_mode[sbgr])
		  {
		  case  0:
		  case  5:
		  case 10:
		  case 14:
			   transmitted = 1;
			   break;
		  }
	       }
	    }
	 }
	 else
	    transmitted = 0;

	 if (transmitted == 1)
	 {
	      /* check for grouping in subband */
	      if ((*alloc)[i][bit_alloc[j][i]].group==3)
	      {
		      for (m=0;m<3;m++)
		      {
			      k = (*alloc)[i][bit_alloc[j][i]].bits;
			      sample[j][m][i] = (unsigned int) getbits (bs, k);
		      }
	      }
	      else
	      {	/* bit_alloc = 3, 5, 9 */
		      nlevels = (*alloc)[i][bit_alloc[j][i]].steps;
		      k=(*alloc)[i][bit_alloc[j][i]].bits;
		      c = (unsigned int) getbits (bs, k);
		      for (k=0;k<3;k++)
		      {
			      sample[j][k][i] = c % nlevels;
			      c /= nlevels;
		      }
	      }
	 }
	 else   /* no samples transmitted */
	    for (k=0; k<3; k++)
	       sample[j][k][i] = 0;
      }  /* for channel loop */
   }  /* for sblimit loop */

   for (i = sblimit; i < SBLIMIT; i++)
	 for (j = 5; j < 7; j++)
		for (k = 0; k < 3; k++)  sample[j][k][i] = 0;
}
#endif

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

/***************************************************************/
/* 15/03/1995 JMZ */

void II_buffer_sample_ml(Bit_stream *bs,
			 frame_params *fr_ps,
			 unsigned int sample_ml[7][3][SBLIMIT],
			 unsigned int bit_alloc_ml[7][SBLIMIT],
			 int *n_ml_ch)
{
   int i,j,k,m,sbgr,l;
   unsigned int nlevels, c=0;
   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 < *n_ml_ch; j++)
	 {
	   if (bit_alloc_ml[j][i])
	   {
		/* JR: no dynamic crosstalk for multilingual channels */
		/* check for grouping in subband */
		if ((*alloc_ml)[i][bit_alloc_ml[j][i]].group==3)
		{

			for (m=0;m<3;m++)
			{
				k = (*alloc_ml)[i][bit_alloc_ml[j][i]].bits;
				sample_ml[j][m][i] = (unsigned int) getbits (bs, k);
			}

		}
		else
		{    /* bit_alloc = 3, 5, 9 */
		  nlevels = (*alloc_ml)[i][bit_alloc_ml[j][i]].steps;
		  k=(*alloc_ml)[i][bit_alloc_ml[j][i]].bits;
		  c = (unsigned int) getbits (bs, k);
		  for (k=0;k<3;k++)
		  {
			sample_ml[j][k][i] = c % nlevels;
			c /= nlevels;
		  }
		}
	   }
	   else
	   {      /* for no sample transmitted */
		 for (k=0;k<3;k++) sample_ml[j][k][i] = 0;
	   }
	 }
   }

   for (i = sblimit_ml; i < SBLIMIT; i++)
	 for (j = 0; j < *n_ml_ch; j++)
		for (k = 0; k < 3; k++)
		   sample_ml[j][k][i] = 0;
}

/**************************************************************
/*
/*   Restore the compressed sample to a factional number.
/*   first complement the MSB of the sample
/*    for layer I :
/*    Use s = (s' + 2^(-nb+1) ) * 2^nb / (2^nb-1)
/*   for Layer II :
/*   Use the formula s = s' * c + d
/*
/**************************************************************/

static double c[17] = { 1.33333333333, 1.60000000000, 1.14285714286,
						1.77777777777, 1.06666666666, 1.03225806452,
						1.01587301587, 1.00787401575, 1.00392156863,
						1.00195694716, 1.00097751711, 1.00048851979,
						1.00024420024, 1.00012208522, 1.00006103888,
						1.00003051851, 1.00001525902 };

static double d[17] = { 0.500000000, 0.500000000, 0.250000000, 0.500000000,
						0.125000000, 0.062500000, 0.031250000, 0.015625000,
						0.007812500, 0.003906250, 0.001953125, 0.0009765625,
						0.00048828125, 0.00024414063, 0.00012207031,
						0.00006103516, 0.00003051758 };

/************************** Layer II stuff ************************/

void I_dequantize_sample (unsigned int sample[7][3][SBLIMIT],
			  int part,
			  unsigned int bit_alloc[7][SBLIMIT],
			  double fraction[7][SBLIMIT][3][12],
			  frame_params *fr_ps, int *z)
{
   int i, nb, 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 (k=0; k<stereo; k++)
	 if (bit_alloc[k][i])
	 {
	    nb = bit_alloc[k][i] + 1;
	    if (((sample[k][0][i] >> nb-1) & 1) == 1)
	       fraction[k][i][gr_sam][gr_id] = 0.0;
	    else
	       fraction[k][i][gr_sam][gr_id] = -1.0;

	    fraction[k][i][gr_sam][gr_id] += (double) (sample[k][0][i] & ((1<<nb-1)-1)) /
		 (double) (1L<<nb-1);

	    fraction[k][i][gr_sam][gr_id] =
		 (double) (fraction[k][i][gr_sam][gr_id] + 1.0 / (double)(1L<<nb-1)) *
		     (double) (1L<<nb) / (double) ((1L<<nb)-1);
	 }
	 else
	    fraction[k][i][gr_sam][gr_id] = 0.0;
}
void II_dequantize_sample (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;
   int stereo = fr_ps->stereo;
   int sblimit = fr_ps->sblimit;
   al_table *alloc = fr_ps->alloc;

   for (i=0;i<sblimit;i++)  for (j=0;j<3;j++) for (k = 0; k < stereo ; k++)
	 if (bit_alloc[k][i])
	 {
	   /* locate MSB in the sample */
	   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];
	 }
	 else fraction[k][i][j][*z] = 0.0;

   for (i=sblimit;i<SBLIMIT;i++)
	  for (j=0;j<3;j++)
		 for(k = 0; k < stereo; k++)
			 fraction[k][i][j][*z] = 0.0;
}


/************************** MC Layer II stuff ************************/

void II_dequantize_sample_mc (unsigned int sample[7][3][SBLIMIT],
			      unsigned int bit_alloc[7][SBLIMIT],
			      double fraction[7][SBLIMIT][3][12],
			      frame_params *fr_ps, int ch_start, int channels, 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 = ch_start; k < channels; k++)
		if (bit_alloc[k][i])
		{
		    if (fr_ps->header->dyn_cross_on == 0)
		    {
			/* locate MSB in the sample */
			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 */