sublay2.cpp

MP3解压程序源代码

bool SubbandLayer2::read_sampledata(Ibitstream *stream)
{
  if (allocation)
	 if (groupingtable)
	 {
		uint32 samplecode = stream->get_bits(codelength);
		// create requantized samples:
		samplecode += samplecode << 1;
		register real *target = samples;
		register const real *source = groupingtable + samplecode;
		*target++ = *source++;
		*target++ = *source++;
		*target = *source;
		// memcpy (samples, groupingtable + samplecode, 3 * sizeof (real));
	 }
	 else
	 {
		samples[0] = real (stream->get_bits(codelength)) * factor - 1.0;
		samples[1] = real (stream->get_bits(codelength)) * factor - 1.0;
		samples[2] = real (stream->get_bits(codelength)) * factor - 1.0;
	 }

  samplenumber = 0;
  if (++groupnumber == 12)
	 return true;
  else
	 return false;
}


bool SubbandLayer2::put_next_sample (e_channels channels,
												 SynthesisFilter *filter1,
                                     SynthesisFilter *)
{
  if (allocation && channels != right)
  {
	 register real sample = samples[samplenumber];

	 if (!groupingtable)
		sample = (sample + d) * c;
	 if (groupnumber <= 4)
		sample *= scalefactor1;
	 else if (groupnumber <= 8)
		sample *= scalefactor2;
	 else
		sample *= scalefactor3;
	 filter1->input_sample(sample, subbandnumber);
  }

  if (++samplenumber == 3)
	 return true;
  else
	 return false;
}



/******************************/
/*** Intensity Stereo Class ***/
/******************************/

SubbandLayer2IntensityStereo::SubbandLayer2IntensityStereo(uint32 subbandnumber)
: SubbandLayer2(subbandnumber)
{
}


void SubbandLayer2IntensityStereo::read_scalefactor_selection(Ibitstream *stream,
																				  Crc16 *crc)
{
  if (allocation)
  {
	 scfsi = stream->get_bits(2);
	 channel2_scfsi = stream->get_bits(2);
	 if (crc)
	 {
		crc->add_bits(scfsi, 2);
		crc->add_bits(channel2_scfsi, 2);
	 }
  }
}


void SubbandLayer2IntensityStereo::read_scalefactor(Ibitstream *stream, Header *header)
{
  if (allocation)
  {
	 SubbandLayer2::read_scalefactor(stream, header);
	 switch (channel2_scfsi)
	 {
		case 0:
		channel2_scalefactor1 = scalefactors[stream->get_bits(6)];
		channel2_scalefactor2 = scalefactors[stream->get_bits(6)];
		channel2_scalefactor3 = scalefactors[stream->get_bits(6)];
		break;

		case 1:
		channel2_scalefactor1 = channel2_scalefactor2 = scalefactors[stream->get_bits (6)];
		channel2_scalefactor3 = scalefactors[stream->get_bits(6)];
		break;

		case 2:
		channel2_scalefactor1 = channel2_scalefactor2 =
		channel2_scalefactor3 = scalefactors[stream->get_bits(6)];
		break;

		case 3:
		channel2_scalefactor1 = scalefactors[stream->get_bits(6)];
		channel2_scalefactor2 = channel2_scalefactor3 = scalefactors[stream->get_bits (6)];
		break;
	 }
  }
}


bool SubbandLayer2IntensityStereo::put_next_sample (e_channels channels,
	SynthesisFilter *filter1, SynthesisFilter *filter2)
{
  if (allocation)
  {
	 register real sample = samples[samplenumber];

	 if (!groupingtable)
		sample = (sample + d) * c;
    if (channels == both)
    {
		register float sample2 = sample;
      if (groupnumber <= 4)
      {
	sample *= scalefactor1;
	sample2 *= channel2_scalefactor1;
		}
		else if (groupnumber <= 8)
		{
	sample *= scalefactor2;
	sample2 *= channel2_scalefactor2;
		}
		else
		{
	sample *= scalefactor3;
	sample2 *= channel2_scalefactor3;
		}
		filter1->input_sample(sample, subbandnumber);
      filter2->input_sample(sample2, subbandnumber);
    }
    else if (channels == left)
	 {
		if (groupnumber <= 4)
			sample *= scalefactor1;
      else if (groupnumber <= 8)
			sample *= scalefactor2;
		else
			sample *= scalefactor3;
		filter1->input_sample(sample, subbandnumber);
	 }
	 else
	 {
		if (groupnumber <= 4)
			sample *= channel2_scalefactor1;
		else if (groupnumber <= 8)
			sample *= channel2_scalefactor2;
		else
			sample *= channel2_scalefactor3;
		filter1->input_sample(sample, subbandnumber);
	 }
  }

  if (++samplenumber == 3)
	 return true;
  else
	 return false;
}



/********************/
/*** Stereo Class ***/
/********************/

SubbandLayer2Stereo::SubbandLayer2Stereo(uint32 subbandnumber)
: SubbandLayer2(subbandnumber)
{
}


void SubbandLayer2Stereo::read_allocation(Ibitstream *stream, Header *header, Crc16 *crc)
{
  uint32 length = get_allocationlength(header);
  allocation = stream->get_bits(length);
  channel2_allocation = stream->get_bits(length);
  if (crc)
  {
	 crc->add_bits(allocation, length);
	 crc->add_bits(channel2_allocation, length);
  }
}


void SubbandLayer2Stereo::read_scalefactor_selection(Ibitstream *stream, Crc16 *crc)
{
  if (allocation)
  {
	 scfsi = stream->get_bits(2);
	 if (crc)
		crc->add_bits(scfsi, 2);
  }
  if (channel2_allocation)
  {
	 channel2_scfsi = stream->get_bits(2);
	 if (crc)
		crc->add_bits(channel2_scfsi, 2);
  }
}


void SubbandLayer2Stereo::read_scalefactor(Ibitstream *stream, Header *header)
{
  SubbandLayer2::read_scalefactor(stream, header);
  if (channel2_allocation)
  {
	 switch (channel2_scfsi)
	 {
		case 0:
  	   channel2_scalefactor1 = scalefactors[stream->get_bits(6)];
	   channel2_scalefactor2 = scalefactors[stream->get_bits(6)];
	   channel2_scalefactor3 = scalefactors[stream->get_bits(6)];
	   break;

		case 1:
	   channel2_scalefactor1 = channel2_scalefactor2 =
      						      scalefactors[stream->get_bits(6)];
	   channel2_scalefactor3 = scalefactors[stream->get_bits(6)];
	   break;

		case 2:
	   channel2_scalefactor1 = channel2_scalefactor2 =
	   channel2_scalefactor3 = scalefactors[stream->get_bits(6)];
	   break;

		case 3:
	   channel2_scalefactor1 = scalefactors[stream->get_bits(6)];
	   channel2_scalefactor2 = channel2_scalefactor3 =
      							   scalefactors[stream->get_bits(6)];
  	   break;
	 }
	 prepare_sample_reading(header, channel2_allocation, &channel2_groupingtable,
                           &channel2_factor, &channel2_codelength, &channel2_c,
                           &channel2_d);
  }
}


bool SubbandLayer2Stereo::read_sampledata(Ibitstream *stream)
{
  bool returnvalue = SubbandLayer2::read_sampledata(stream);

  if (channel2_allocation)
	 if (channel2_groupingtable) {
		uint32 samplecode = stream->get_bits(channel2_codelength);
		// create requantized samples:
		samplecode += samplecode << 1;
		register real *target = channel2_samples;
		register const real *source = channel2_groupingtable + samplecode;
		*target++ = *source++;
		*target++ = *source++;
		*target = *source;
		// memcpy (channel2_samples, channel2_groupingtable + samplecode, 3 * sizeof (real));
    } else {
		channel2_samples[0] = real (stream->get_bits(channel2_codelength)) *
      							 channel2_factor - 1.0;
		channel2_samples[1] = real (stream->get_bits(channel2_codelength)) *
      							 channel2_factor - 1.0;
		channel2_samples[2] = real (stream->get_bits(channel2_codelength)) *
                            channel2_factor - 1.0;
	 }

  return returnvalue;
}


bool SubbandLayer2Stereo::put_next_sample(e_channels channels,
														SynthesisFilter *filter1,
                                          SynthesisFilter *filter2)
{
  bool returnvalue = SubbandLayer2::put_next_sample(channels, filter1, filter2);
  if (channel2_allocation && channels != left)
  {
	 register real sample = channel2_samples[samplenumber - 1];

	 if (!channel2_groupingtable)
		sample = (sample + channel2_d) * channel2_c;

	 if (groupnumber <= 4)
		sample *= channel2_scalefactor1;
	 else if (groupnumber <= 8)
		sample *= channel2_scalefactor2;
	 else
		sample *= channel2_scalefactor3;
	 if (channels == both)
		filter2->input_sample(sample, subbandnumber);
	 else
		filter1->input_sample(sample, subbandnumber);
  }
  return returnvalue;
}