/* * NAME:	III_sideinfo() * DESCRIPTION:	decode frame side information from a bitstream */staticenum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch,			    int lsf, struct sideinfo *si,			    unsigned int *data_bitlen,			    unsigned int *priv_bitlen){  unsigned int ngr, gr, ch, i;  enum mad_error result = MAD_ERROR_NONE;  *data_bitlen = 0;  *priv_bitlen = lsf ? ((nch == 1) ? 1 : 2) : ((nch == 1) ? 5 : 3);  si->main_data_begin = mad_bit_read(ptr, lsf ? 8 : 9);  si->private_bits    = mad_bit_read(ptr, *priv_bitlen);  ngr = 1;  if (!lsf) {    ngr = 2;    for (ch = 0; ch < nch; ++ch)      si->scfsi[ch] = mad_bit_read(ptr, 4);  }  for (gr = 0; gr < ngr; ++gr) {    struct granule *granule = &si->gr[gr];    for (ch = 0; ch < nch; ++ch) {      struct channel *channel = &granule->ch[ch];      channel->part2_3_length    = mad_bit_read(ptr, 12);      channel->big_values        = mad_bit_read(ptr, 9);      channel->global_gain       = mad_bit_read(ptr, 8);      channel->scalefac_compress = mad_bit_read(ptr, lsf ? 9 : 4);      *data_bitlen += channel->part2_3_length;      if (channel->big_values > 288 && result == 0)	result = MAD_ERROR_BADBIGVALUES;      channel->flags = 0;      /* window_switching_flag */      if (mad_bit_read(ptr, 1)) {	channel->block_type = mad_bit_read(ptr, 2);	if (channel->block_type == 0 && result == 0)	  result = MAD_ERROR_BADBLOCKTYPE;	if (!lsf && channel->block_type == 2 && si->scfsi[ch] && result == 0)	  result = MAD_ERROR_BADSCFSI;	channel->region0_count = 7;	channel->region1_count = 36;	if (mad_bit_read(ptr, 1))	  channel->flags |= mixed_block_flag;	else if (channel->block_type == 2)	  channel->region0_count = 8;	for (i = 0; i < 2; ++i)	  channel->table_select[i] = mad_bit_read(ptr, 5);# if defined(DEBUG)	channel->table_select[2] = 4;  /* not used */# endif	for (i = 0; i < 3; ++i)	  channel->subblock_gain[i] = mad_bit_read(ptr, 3);      }      else {	channel->block_type = 0;	for (i = 0; i < 3; ++i)	  channel->table_select[i] = mad_bit_read(ptr, 5);	channel->region0_count = mad_bit_read(ptr, 4);	channel->region1_count = mad_bit_read(ptr, 3);      }      /* [preflag,] scalefac_scale, count1table_select */      channel->flags |= mad_bit_read(ptr, lsf ? 2 : 3);    }  }  return result;}/* * NAME:	III_scalefactors_lsf() * DESCRIPTION:	decode channel scalefactors for LSF from a bitstream */staticunsigned int III_scalefactors_lsf(struct mad_bitptr *ptr,				  struct channel *channel,				  struct channel *gr1ch, int mode_extension){  struct mad_bitptr start;  unsigned int scalefac_compress, index, slen[4], part, n, i;  unsigned char const *nsfb;  start = *ptr;  scalefac_compress = channel->scalefac_compress;  index = (channel->block_type == 2) ?    ((channel->flags & mixed_block_flag) ? 2 : 1) : 0;  if (!((mode_extension & I_STEREO) && gr1ch)) {    if (scalefac_compress < 400) {      slen[0] = (scalefac_compress >> 4) / 5;      slen[1] = (scalefac_compress >> 4) % 5;      slen[2] = (scalefac_compress % 16) >> 2;      slen[3] =  scalefac_compress %  4;      nsfb = nsfb_table[0][index];    }    else if (scalefac_compress < 500) {      scalefac_compress -= 400;      slen[0] = (scalefac_compress >> 2) / 5;      slen[1] = (scalefac_compress >> 2) % 5;      slen[2] =  scalefac_compress %  4;      slen[3] = 0;      nsfb = nsfb_table[1][index];    }    else {      scalefac_compress -= 500;      slen[0] = scalefac_compress / 3;      slen[1] = scalefac_compress % 3;      slen[2] = 0;      slen[3] = 0;      channel->flags |= preflag;      nsfb = nsfb_table[2][index];    }    n = 0;    for (part = 0; part < 4; ++part) {      for (i = 0; i < nsfb[part]; ++i)	channel->scalefac[n++] = mad_bit_read(ptr, slen[part]);    }    while (n < 39)      channel->scalefac[n++] = 0;  }  else {  /* (mode_extension & I_STEREO) && gr1ch (i.e. ch == 1) */    scalefac_compress >>= 1;    if (scalefac_compress < 180) {      slen[0] =  scalefac_compress / 36;      slen[1] = (scalefac_compress % 36) / 6;      slen[2] = (scalefac_compress % 36) % 6;      slen[3] = 0;      nsfb = nsfb_table[3][index];    }    else if (scalefac_compress < 244) {      scalefac_compress -= 180;      slen[0] = (scalefac_compress % 64) >> 4;      slen[1] = (scalefac_compress % 16) >> 2;      slen[2] =  scalefac_compress %  4;      slen[3] = 0;      nsfb = nsfb_table[4][index];    }    else {      scalefac_compress -= 244;      slen[0] = scalefac_compress / 3;      slen[1] = scalefac_compress % 3;      slen[2] = 0;      slen[3] = 0;      nsfb = nsfb_table[5][index];    }    n = 0;    for (part = 0; part < 4; ++part) {      unsigned int max, is_pos;      max = (1 << slen[part]) - 1;      for (i = 0; i < nsfb[part]; ++i) {	is_pos = mad_bit_read(ptr, slen[part]);	channel->scalefac[n] = is_pos;	gr1ch->scalefac[n++] = (is_pos == max);      }    }    while (n < 39) {      channel->scalefac[n] = 0;      gr1ch->scalefac[n++] = 0;  /* apparently not illegal */    }  }  return mad_bit_length(&start, ptr);}/* * NAME:	III_scalefactors() * DESCRIPTION:	decode channel scalefactors of one granule from a bitstream */staticunsigned int III_scalefactors(struct mad_bitptr *ptr, struct channel *channel,			      struct channel const *gr0ch, unsigned int scfsi){  struct mad_bitptr start;  unsigned int slen1, slen2, sfbi;  start = *ptr;  slen1 = sflen_table[channel->scalefac_compress].slen1;  slen2 = sflen_table[channel->scalefac_compress].slen2;  if (channel->block_type == 2) {    unsigned int nsfb;    sfbi = 0;    nsfb = (channel->flags & mixed_block_flag) ? 8 + 3 * 3 : 6 * 3;    while (nsfb--)      channel->scalefac[sfbi++] = mad_bit_read(ptr, slen1);    nsfb = 6 * 3;    while (nsfb--)      channel->scalefac[sfbi++] = mad_bit_read(ptr, slen2);    nsfb = 1 * 3;    while (nsfb--)      channel->scalefac[sfbi++] = 0;  }  else {  /* channel->block_type != 2 */    if (scfsi & 0x8) {      for (sfbi = 0; sfbi < 6; ++sfbi)	channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];    }    else {      for (sfbi = 0; sfbi < 6; ++sfbi)	channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);    }    if (scfsi & 0x4) {      for (sfbi = 6; sfbi < 11; ++sfbi)	channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];    }    else {      for (sfbi = 6; sfbi < 11; ++sfbi)	channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);    }    if (scfsi & 0x2) {      for (sfbi = 11; sfbi < 16; ++sfbi)	channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];    }    else {      for (sfbi = 11; sfbi < 16; ++sfbi)	channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);    }    if (scfsi & 0x1) {      for (sfbi = 16; sfbi < 21; ++sfbi)	channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];    }    else {      for (sfbi = 16; sfbi < 21; ++sfbi)	channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);    }    channel->scalefac[21] = 0;  }  return mad_bit_length(&start, ptr);}/* * The Layer III formula for requantization and scaling is defined by * section 2.4.3.4.7.1 of ISO/IEC 11172-3, as follows: * *   long blocks: *   xr[i] = sign(is[i]) * abs(is[i])^(4/3) * *           2^((1/4) * (global_gain - 210)) * *           2^-(scalefac_multiplier * *               (scalefac_l[sfb] + preflag * pretab[sfb])) * *   short blocks: *   xr[i] = sign(is[i]) * abs(is[i])^(4/3) * *           2^((1/4) * (global_gain - 210 - 8 * subblock_gain[w])) * *           2^-(scalefac_multiplier * scalefac_s[sfb][w]) * *   where: *   scalefac_multiplier = (scalefac_scale + 1) / 2 * * The routines III_exponents() and III_requantize() facilitate this * calculation. *//* * NAME:	III_exponents() * DESCRIPTION:	calculate scalefactor exponents */staticvoid III_exponents(struct channel const *channel,		   unsigned char const *sfbwidth, signed int exponents[39]){  signed int gain;  unsigned int scalefac_multiplier, sfbi;  gain = (signed int) channel->global_gain - 210;  scalefac_multiplier = (channel->flags & scalefac_scale) ? 2 : 1;  if (channel->block_type == 2) {    unsigned int l;    signed int gain0, gain1, gain2;    sfbi = l = 0;    if (channel->flags & mixed_block_flag) {      unsigned int premask;      premask = (channel->flags & preflag) ? ~0 : 0;      /* long block subbands 0-1 */      while (l < 36) {	exponents[sfbi] = gain -	  (signed int) ((channel->scalefac[sfbi] + (pretab[sfbi] & premask)) <<			scalefac_multiplier);	l += sfbwidth[sfbi++];      }    }    /* this is probably wrong for 8000 Hz short/mixed blocks */    gain0 = gain - 8 * (signed int) channel->subblock_gain[0];    gain1 = gain - 8 * (signed int) channel->subblock_gain[1];    gain2 = gain - 8 * (signed int) channel->subblock_gain[2];    while (l < 576) {      exponents[sfbi + 0] = gain0 -	(signed int) (channel->scalefac[sfbi + 0] << scalefac_multiplier);      exponents[sfbi + 1] = gain1 -	(signed int) (channel->scalefac[sfbi + 1] << scalefac_multiplier);      exponents[sfbi + 2] = gain2 -	(signed int) (channel->scalefac[sfbi + 2] << scalefac_multiplier);      l    += 3 * sfbwidth[sfbi];      sfbi += 3;    }  }  else {  /* channel->block_type != 2 */    if (channel->flags & preflag) {      for (sfbi = 0; sfbi < 22; ++sfbi) {	exponents[sfbi] = gain -	  (signed int) ((channel->scalefac[sfbi] + pretab[sfbi]) <<			scalefac_multiplier);      }    }    else {      for (sfbi = 0; sfbi < 22; ++sfbi) {	exponents[sfbi] = gain -	  (signed int) (channel->scalefac[sfbi] << scalefac_multiplier);      }    }  }}/* * NAME:	III_requantize() * DESCRIPTION:	requantize one (positive) value */staticmad_fixed_t III_requantize(unsigned int value, signed int exp){  mad_fixed_t requantized;  signed int frac;  struct fixedfloat const *power;  frac = exp % 4;  /* assumes sign(frac) == sign(exp) */  exp /= 4;  power = &rq_table[value];  requantized = power->mantissa;  exp += power->exponent;  if (exp < 0) {    if (-exp >= sizeof(mad_fixed_t) * CHAR_BIT) {      /* underflow */      requantized = 0;    }    else {      requantized += 1L << (-exp - 1);      requantized >>= -exp;    }  }  else {    if (exp >= 5) {      /* overflow */# if defined(DEBUG)      fprintf(stderr, "requantize overflow (%f * 2^%d)\n",	      mad_f_todouble(requantized), exp);# endif      requantized = MAD_F_MAX;    }    else      requantized <<= exp;  }  return frac ? mad_f_mul(requantized, root_table[3 + frac]) : requantized;}/* we must take care that sz >= bits and sz < sizeof(long) lest bits == 0 */# define MASK(cache, sz, bits)	\    (((cache) >> ((sz) - (bits))) & ((1 << (bits)) - 1))# define MASK1BIT(cache, sz)  \    ((cache) & (1 << ((sz) - 1)))/* * NAME:	III_huffdecode() * DESCRIPTION:	decode Huffman code words of one channel of one granule */staticenum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xr[576],			      struct channel *channel,			      unsigned char const *sfbwidth,			      unsigned int part2_length){  signed int exponents[39], exp;  signed int const *expptr;  struct mad_bitptr peek;  signed int bits_left, cachesz;  register mad_fixed_t *xrptr;  mad_fixed_t const *sfbound;  register unsigned long bitcache;  bits_left = (signed) channel->part2_3_length - (signed) part2_length;  if (bits_left < 0)    return MAD_ERROR_BADPART3LEN;  III_exponents(channel, sfbwidth, exponents);  peek = *ptr;  mad_bit_skip(ptr, bits_left);  /* align bit reads to byte boundaries */  cachesz  = mad_bit_bitsleft(&peek);  cachesz += ((32 - 1 - 24) + (24 - cachesz)) & ~7;  bitcache   = mad_bit_read(&peek, cachesz);  bits_left -= cachesz;  xrptr = &xr[0];  /* big_values */  {    unsigned int region, rcount;    struct hufftable const *entry;    union huffpair const *table;    unsigned int linbits, startbits, big_values, reqhits;    mad_fixed_t reqcache[16];    sfbound = xrptr + *sfbwidth++;    rcount  = channel->region0_count + 1;    entry     = &mad_huff_pair_table[channel->table_select[region = 0]];    table     = entry->table;    linbits   = entry->linbits;    startbits = entry->startbits;    if (table == 0)      return MAD_ERROR_BADHUFFTABLE;    expptr  = &exponents[0];    exp     = *expptr++;    reqhits = 0;    big_values = channel->big_values;    while (big_values-- && cachesz + bits_left > 0) {      union huffpair const *pair;      unsigned int clumpsz, value;      register mad_fixed_t requantized;      if (xrptr == sfbound) {	sfbound += *sfbwidth++;	/* change table if region boundary */	if (--rcount == 0) {	  if (region == 0)	    rcount = channel->region1_count + 1;	  else	    rcount = 0;  /* all remaining */