iup.c

这是一个mp3的源代码

/*-------------------------------------------------------------------------*/
static void unpack_sfs()	/* unpack scale factor selectors */
{
   int i;

   for (i = 0; i < max_sb; i++)
   {
      mac_load_check(2);
      if (ballo[i])
	 sf_dispatch[i] = mac_load(2);
      else
	 sf_dispatch[i] = 4;	/* no allo */
   }
   sf_dispatch[i] = 5;		/* terminate dispatcher */
}
/*-------------------------------------------------------------------------*/
/*--- multiply note -------------------------------------------------------*/
/*--- 16bit x 16bit mult --> 32bit >> 15 --> 16 bit  or better  -----------*/
static void unpack_sf()		/* unpack scale factor */
{				/* combine dequant and scale factors */
   int i, n;
   INT32 tmp;			/* only reason tmp is 32 bit is to get 32 bit mult result */

   i = -1;
 dispatch:switch (sf_dispatch[++i])
   {
      case 0:			/* 3 factors 012 */
	 mac_load_check(18);
	 tmp = c_value[i];
	 n = c_shift[i];
	 cs_factor[0][i] = (tmp * sf_table[mac_load(6)]) >> n;
	 cs_factor[1][i] = (tmp * sf_table[mac_load(6)]) >> n;
	 cs_factor[2][i] = (tmp * sf_table[mac_load(6)]) >> n;
	 goto dispatch;
      case 1:			/* 2 factors 002 */
	 mac_load_check(12);
	 tmp = c_value[i];
	 n = c_shift[i];
	 cs_factor[1][i] = cs_factor[0][i] =
	    (tmp * sf_table[mac_load(6)]) >> n;
	 cs_factor[2][i] = (tmp * sf_table[mac_load(6)]) >> n;
	 goto dispatch;
      case 2:			/* 1 factor 000 */
	 mac_load_check(6);
	 tmp = c_value[i];
	 n = c_shift[i];
	 cs_factor[2][i] = cs_factor[1][i] = cs_factor[0][i] =
	    (tmp * sf_table[mac_load(6)]) >> n;
	 goto dispatch;
      case 3:			/* 2 factors 022 */
	 mac_load_check(12);
	 tmp = c_value[i];
	 n = c_shift[i];
	 cs_factor[0][i] = (tmp * sf_table[mac_load(6)]) >> n;
	 cs_factor[2][i] = cs_factor[1][i] =
	    (tmp * sf_table[mac_load(6)]) >> n;
	 goto dispatch;
      case 4:			/* no allo */
	 goto dispatch;
      case 5:			/* all done */
	 ;
   }				/* end switch */
}
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
/*--- unpack multiply note ------------------------------------------------*/
/*--- 16bit x 16bit mult --> 32bit  or better required---------------------*/
#define UNPACK_N(n)                                          \
    s[k]     =  ((cs_factor[i][k]*(load(n)-((1 << (n-1)) -1)))>>(n-1));   \
    s[k+64]  =  ((cs_factor[i][k]*(load(n)-((1 << (n-1)) -1)))>>(n-1));   \
    s[k+128] =  ((cs_factor[i][k]*(load(n)-((1 << (n-1)) -1)))>>(n-1));   \
    goto dispatch;
#define UNPACK_N2(n)                                             \
    mac_load_check(3*n);                                         \
    s[k]     =  (cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
    s[k+64]  =  (cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
    s[k+128] =  (cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
    goto dispatch;
#define UNPACK_N3(n)                                             \
    mac_load_check(2*n);                                         \
    s[k]     =  (cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
    s[k+64]  =  (cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
    mac_load_check(n);                                           \
    s[k+128] =  (cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
    goto dispatch;
#define UNPACKJ_N(n)                                         \
    tmp        =  (load(n)-((1 << (n-1)) -1));                 \
    s[k]       =  (cs_factor[i][k]*tmp)>>(n-1);                       \
    s[k+1]     =  (cs_factor[i][k+1]*tmp)>>(n-1);                     \
    tmp        =  (load(n)-((1 << (n-1)) -1));                 \
    s[k+64]    =  (cs_factor[i][k]*tmp)>>(n-1);                       \
    s[k+64+1]  =  (cs_factor[i][k+1]*tmp)>>(n-1);                     \
    tmp        =  (load(n)-((1 << (n-1)) -1));                 \
    s[k+128]   =  (cs_factor[i][k]*tmp)>>(n-1);                       \
    s[k+128+1] =  (cs_factor[i][k+1]*tmp)>>(n-1);                     \
    k++;       /* skip right chan dispatch */                \
    goto dispatch;
/*-------------------------------------------------------------------------*/
static void unpack_samp()	/* unpack samples */
{
   int i, j, k;
   SAMPLEINT *s;
   int n;
   INT32 tmp;

   s = sample;
   for (i = 0; i < 3; i++)
   {				/* 3 groups of scale factors */
      for (j = 0; j < 4; j++)
      {
	 k = -1;
       dispatch:switch (samp_dispatch[++k])
	 {
	    case 0:
	       s[k + 128] = s[k + 64] = s[k] = 0;
	       goto dispatch;
	    case 1:		/* 3 levels grouped 5 bits */
	       mac_load_check(5);
	       n = mac_load(5);
	       s[k] = ((INT32) cs_factor[i][k] * group3_table[n][0]) >> 1;
	       s[k + 64] = ((INT32) cs_factor[i][k] * group3_table[n][1]) >> 1;
	       s[k + 128] = ((INT32) cs_factor[i][k] * group3_table[n][2]) >> 1;
	       goto dispatch;
	    case 2:		/* 5 levels grouped 7 bits */
	       mac_load_check(7);
	       n = mac_load(7);
	       s[k] = ((INT32) cs_factor[i][k] * group5_table[n][0]) >> 2;
	       s[k + 64] = ((INT32) cs_factor[i][k] * group5_table[n][1]) >> 2;
	       s[k + 128] = ((INT32) cs_factor[i][k] * group5_table[n][2]) >> 2;
	       goto dispatch;
	    case 3:
	       UNPACK_N2(3)	/* 7 levels */
	    case 4:		/* 9 levels grouped 10 bits */
	       mac_load_check(10);
	       n = mac_load(10);
	       s[k] = ((INT32) cs_factor[i][k] * group9_table[n][0]) >> 3;
	       s[k + 64] = ((INT32) cs_factor[i][k] * group9_table[n][1]) >> 3;
	       s[k + 128] = ((INT32) cs_factor[i][k] * group9_table[n][2]) >> 3;
	       goto dispatch;
	    case 5:
	       UNPACK_N2(4)	/* 15 levels */
	    case 6:
	       UNPACK_N2(5)	/* 31 levels */
	    case 7:
	       UNPACK_N2(6)	/* 63 levels */
	    case 8:
	       UNPACK_N2(7)	/* 127 levels */
	    case 9:
	       UNPACK_N2(8)	/* 255 levels */
	    case 10:
	       UNPACK_N3(9)	/* 511 levels */
	    case 11:
	       UNPACK_N3(10)	/* 1023 levels */
	    case 12:
	       UNPACK_N3(11)	/* 2047 levels */
	    case 13:
	       UNPACK_N3(12)	/* 4095 levels */
	    case 14:
	       UNPACK_N(13)	/* 8191 levels */
	    case 15:
	       UNPACK_N(14)	/* 16383 levels */
	    case 16:
	       UNPACK_N(15)	/* 32767 levels */
	    case 17:
	       UNPACK_N(16)	/* 65535 levels */
/* -- joint ---- */
	    case 18 + 0:
	       s[k + 128 + 1] = s[k + 128] = s[k + 64 + 1] = s[k + 64] = s[k + 1] = s[k] = 0;
	       k++;		/* skip right chan dispatch */
	       goto dispatch;
	    case 18 + 1:	/* 3 levels grouped 5 bits */
	       n = load(5);
	       s[k] = ((INT32) cs_factor[i][k] * group3_table[n][0]) >> 1;
	       s[k + 1] = ((INT32) cs_factor[i][k + 1] * group3_table[n][0]) >> 1;
	       s[k + 64] = ((INT32) cs_factor[i][k] * group3_table[n][1]) >> 1;
	       s[k + 64 + 1] = ((INT32) cs_factor[i][k + 1] * group3_table[n][1]) >> 1;
	       s[k + 128] = ((INT32) cs_factor[i][k] * group3_table[n][2]) >> 1;
	       s[k + 128 + 1] = ((INT32) cs_factor[i][k + 1] * group3_table[n][2]) >> 1;
	       k++;		/* skip right chan dispatch */
	       goto dispatch;
	    case 18 + 2:	/* 5 levels grouped 7 bits */
	       n = load(7);
	       s[k] = ((INT32) cs_factor[i][k] * group5_table[n][0]) >> 2;
	       s[k + 1] = ((INT32) cs_factor[i][k + 1] * group5_table[n][0]) >> 2;
	       s[k + 64] = ((INT32) cs_factor[i][k] * group5_table[n][1]) >> 2;
	       s[k + 64 + 1] = ((INT32) cs_factor[i][k + 1] * group5_table[n][1]) >> 2;
	       s[k + 128] = ((INT32) cs_factor[i][k] * group5_table[n][2]) >> 2;
	       s[k + 128 + 1] = ((INT32) cs_factor[i][k + 1] * group5_table[n][2]) >> 2;
	       k++;		/* skip right chan dispatch */
	       goto dispatch;
	    case 18 + 3:
	       UNPACKJ_N(3)	/* 7 levels */
	    case 18 + 4:	/* 9 levels grouped 10 bits */
	       n = load(10);
	       s[k] = ((INT32) cs_factor[i][k] * group9_table[n][0]) >> 3;
	       s[k + 1] = ((INT32) cs_factor[i][k + 1] * group9_table[n][0]) >> 3;
	       s[k + 64] = ((INT32) cs_factor[i][k] * group9_table[n][1]) >> 3;
	       s[k + 64 + 1] = ((INT32) cs_factor[i][k + 1] * group9_table[n][1]) >> 3;
	       s[k + 128] = ((INT32) cs_factor[i][k] * group9_table[n][2]) >> 3;
	       s[k + 128 + 1] = ((INT32) cs_factor[i][k + 1] * group9_table[n][2]) >> 3;
	       k++;		/* skip right chan dispatch */
	       goto dispatch;
	    case 18 + 5:
	       UNPACKJ_N(4)	/* 15 levels */
	    case 18 + 6:
	       UNPACKJ_N(5)	/* 31 levels */
	    case 18 + 7:
	       UNPACKJ_N(6)	/* 63 levels */
	    case 18 + 8:
	       UNPACKJ_N(7)	/* 127 levels */
	    case 18 + 9:
	       UNPACKJ_N(8)	/* 255 levels */
	    case 18 + 10:
	       UNPACKJ_N(9)	/* 511 levels */
	    case 18 + 11:
	       UNPACKJ_N(10)	/* 1023 levels */
	    case 18 + 12:
	       UNPACKJ_N(11)	/* 2047 levels */
	    case 18 + 13:
	       UNPACKJ_N(12)	/* 4095 levels */
	    case 18 + 14:
	       UNPACKJ_N(13)	/* 8191 levels */
	    case 18 + 15:
	       UNPACKJ_N(14)	/* 16383 levels */
	    case 18 + 16:
	       UNPACKJ_N(15)	/* 32767 levels */
	    case 18 + 17:
	       UNPACKJ_N(16)	/* 65535 levels */
/* -- end of dispatch -- */
	    case 37:
	       skip(bit_skip);
	    case 36:
	       s += 3 * 64;
	 }			/* end switch */
      }				/* end j loop */
   }				/* end i loop */


}
/*-------------------------------------------------------------------------*/
static void unpack()
{
   int prot;

/* at entry bit getter points at id, sync skipped by caller */

   load(3);			/* skip id and option (checked by init) */
   prot = load(1);		/* load prot bit */
   load(6);			/* skip to pad */
   pad = load(1);
   load(1);			/* skip to mode */
   stereo_sb = look_joint[load(4)];
   if (prot)
      load(4);			/* skip to data */
   else
      load(20);			/* skip crc */

   unpack_ba();			/* unpack bit allocation */
   unpack_sfs();		/* unpack scale factor selectors */
   unpack_sf();			/* unpack scale factor */
   unpack_samp();		/* unpack samples */


}
/*-------------------------------------------------------------------------*/
IN_OUT i_audio_decode(unsigned char *bs, signed short *pcm)
{
   int sync;
   IN_OUT in_out;

   load_init(bs);		/* initialize bit getter */
/* test sync */
   in_out.in_bytes = 0;		/* assume fail */
   in_out.out_bytes = 0;
   sync = load(12);

   if (sync != 0xFFF)
      return in_out;		/* sync fail */
/*-----------*/
   unpack_routine();


   sbt(sample, pcm, nsbt);
/*-----------*/
   in_out.in_bytes = framebytes + pad;
   in_out.out_bytes = outbytes;
   return in_out;
}
/*-------------------------------------------------------------------------*/
#include "iupini.c"		/* initialization */
#include "iupL1.c"		/* Layer 1 */
/*-------------------------------------------------------------------------*/