l3bitstream.c

功能非常完善的MP3编译码器,输入文件WAV或AIFF,能够方便的嵌入到你自己的系统当中.

/*
			(c) Copyright 1998, 1999 - Tord Jansson
			=======================================

		This file is part of the BladeEnc MP3 Encoder, based on
		ISO's reference code for MPEG Layer 3 compression, and might
		contain smaller or larger sections that are directly taken
		from ISO's reference code.

		All changes to the ISO reference code herein are either
		copyrighted by Tord Jansson ([e-mail])
		or sublicensed to Tord Jansson by a third party.

	BladeEnc is free software; you can redistribute this file
	and/or modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

*/

#include <stdlib.h>
#include "system.h"

#include "l3bitstream.h" /* the public interface */
#include "l3psy.h"
#include "mdct.h"
#include "loop.h"
#include "formatbitstream2.h"
#include "huffman.h"
#include <assert.h>
#include "l3bitstream-pvt.h"

static int stereo = 1;
static frame_params *fr_ps  = NULL;


int PartHoldersInitialized = 0;

BitHolder *headerPH;
BitHolder *frameSIPH;
BitHolder *channelSIPH[ MAX_CHANNELS ];
BitHolder *spectrumSIPH[ MAX_GRANULES ][ MAX_CHANNELS ];
BitHolder *scaleFactorsPH[ MAX_GRANULES ][ MAX_CHANNELS ];
BitHolder *codedDataPH[ MAX_GRANULES ][ MAX_CHANNELS ];
BitHolder *userSpectrumPH[ MAX_GRANULES ][ MAX_CHANNELS ];
BitHolder *userFrameDataPH;


BF_FrameData			sFrameData;
BF_FrameResults		sFrameResults;



/*
  III_format_bitstream()
  
  This is called after a frame of audio has been quantized and coded.
  It will write the encoded audio to the bitstream. Note that
  from a layer3 encoder's perspective the bit stream is primarily
  a series of main_data() blocks, with header and side information
  inserted at the proper locations to maintain framing. (See Figure A.7
  in the IS).
  */

void III_format_bitstream(	int              bitsPerFrame,
														frame_params     *in_fr_ps,
														int              l3_enc[2][2][576],
														III_side_info_t  *l3_side,
														III_scalefac_t   *scalefac,
														double           (*xr)[2][576],
														char             *ancillary,
														int              ancillary_bits )
{
  int gr, ch, i, mode_gr;
  fr_ps = in_fr_ps;
  stereo = fr_ps->stereo;
  mode_gr = 2;
  
  if ( !PartHoldersInitialized )
  {
		headerPH = initBitHolder( &sFrameData.header, 16*2 );
		frameSIPH = initBitHolder( &sFrameData.frameSI, 4*2 );

		for ( ch = 0; ch < MAX_CHANNELS; ch++ )
	    channelSIPH[ch] = initBitHolder( &sFrameData.channelSI[ch], 8*2 );

		for ( gr = 0; gr < MAX_GRANULES; gr++ )	
	    for ( ch = 0; ch < MAX_CHANNELS; ch++ )
	    {
				spectrumSIPH[gr][ch]   = initBitHolder( &sFrameData.spectrumSI[gr][ch], 32*2 );
				scaleFactorsPH[gr][ch] = initBitHolder( &sFrameData.scaleFactors[gr][ch], 64*2 );
				codedDataPH[gr][ch]    = initBitHolder( &sFrameData.codedData[gr][ch], 576*2 );
				userSpectrumPH[gr][ch] = initBitHolder( &sFrameData.userSpectrum[gr][ch], 4*2 );
	    }
		userFrameDataPH = initBitHolder( &sFrameData.userFrameData, 8*2 );
		
		
		PartHoldersInitialized = 1;
  }

#if 1
  for ( gr = 0; gr < mode_gr; gr++ )
		for ( ch =  0; ch < stereo; ch++ )
		{
	    int *pi = &l3_enc[gr][ch][0];
	    double *pr = &xr[gr][ch][0];
	    for ( i = 0; i < 576; i++, pr++, pi++ )
		  {
				if ( (*pr < 0) && (*pi > 0) )
				  *pi *= -1;
	    }
		}
#endif

  encodeSideInfo( l3_side );
  encodeMainData( l3_enc, l3_side, scalefac );
  write_ancillary_data( ancillary, ancillary_bits );

  if ( l3_side->resvDrain )
		drain_into_ancillary_data( l3_side->resvDrain );

  sFrameData.frameLength = bitsPerFrame;
  sFrameData.nGranules   = mode_gr;
  sFrameData.nChannels   = stereo;

  writeFrame( &sFrameData, &sFrameResults );

  /* we set this here -- it will be tested in the next loops iteration */
  l3_side->main_data_begin = sFrameResults.nextBackPtr;
}

void III_FlushBitstream()
{
	int	ch, gr;

  if ( PartHoldersInitialized )
  {
				
		exitBitHolder( &sFrameData.header );
		exitBitHolder( &sFrameData.frameSI );

		for ( ch = 0; ch < MAX_CHANNELS; ch++ )
	    exitBitHolder( &sFrameData.channelSI[ch] );


		for ( gr = 0; gr < MAX_GRANULES; gr++ )	
	    for ( ch = 0; ch < MAX_CHANNELS; ch++ )
	    {
				exitBitHolder( &sFrameData.spectrumSI[gr][ch] );
				exitBitHolder( &sFrameData.scaleFactors[gr][ch] );
				exitBitHolder( &sFrameData.codedData[gr][ch] );
				exitBitHolder( &sFrameData.userSpectrum[gr][ch] );
	    }
		exitBitHolder( &sFrameData.userFrameData );
				
		PartHoldersInitialized = 0;
  }
	

 /*	BF_FlushBitstream( frameData, frameResults ); */
}

static unsigned slen1_tab[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
static unsigned slen2_tab[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };

static void encodeMainData( int l3_enc[2][2][576],
														III_side_info_t  *si,
														III_scalefac_t   *scalefac )
{
  int gr, ch, sfb, window, mode_gr;

	mode_gr = 2;

  for ( gr = 0; gr < mode_gr; gr++ )
		for ( ch = 0; ch < stereo; ch++ )
	    scaleFactorsPH[gr][ch]->nrEntries = 0;

  for ( gr = 0; gr < mode_gr; gr++ )
		for ( ch = 0; ch < stereo; ch++ )
	    codedDataPH[gr][ch]->nrEntries = 0;

	for ( gr = 0; gr < 2; gr++ )
	{
	  for ( ch = 0; ch < stereo; ch++ )
	  {
			BitHolder **pph = &scaleFactorsPH[gr][ch];		
			gr_info *gi = &(si->gr[gr].ch[ch].tt);
			unsigned slen1 = slen1_tab[ gi->scalefac_compress ];
			unsigned slen2 = slen2_tab[ gi->scalefac_compress ];
			int *ix = &l3_enc[gr][ch][0];

			if ( (gi->window_switching_flag == 1) && (gi->block_type == 2) )
			{
				if ( gi->mixed_block_flag )
				{
					for ( sfb = 0; sfb < 8; sfb++ )
						addBits( *pph,  scalefac->l[gr][ch][sfb], slen1 );

					for ( sfb = 3; sfb < 6; sfb++ )
						for ( window = 0; window < 3; window++ )
							addBits( *pph,  scalefac->s[gr][ch][sfb][window], slen1 );

					for ( sfb = 6; sfb < 12; sfb++ )
						for ( window = 0; window < 3; window++ )
							addBits( *pph,  scalefac->s[gr][ch][sfb][window], slen2 );

				}
				else
				{
					for ( sfb = 0; sfb < 6; sfb++ )
						for ( window = 0; window < 3; window++ )
							addBits( *pph,  scalefac->s[gr][ch][sfb][window], slen1 );

					for ( sfb = 6; sfb < 12; sfb++ )
						for ( window = 0; window < 3; window++ )
							addBits( *pph,  scalefac->s[gr][ch][sfb][window], slen2 );
				}
			}
			else
			{
				if ( (gr == 0) || (si->scfsi[ch][0] == 0) )
					for ( sfb = 0; sfb < 6; sfb++ )
						addBits( *pph,  scalefac->l[gr][ch][sfb], slen1 );

				if ( (gr == 0) || (si->scfsi[ch][1] == 0) )
					for ( sfb = 6; sfb < 11; sfb++ )
						addBits( *pph,  scalefac->l[gr][ch][sfb], slen1 );

				if ( (gr == 0) || (si->scfsi[ch][2] == 0) )
					for ( sfb = 11; sfb < 16; sfb++ )
						addBits( *pph,  scalefac->l[gr][ch][sfb], slen2 );

				if ( (gr == 0) || (si->scfsi[ch][3] == 0) )
					for ( sfb = 16; sfb < 21; sfb++ )
						addBits( *pph,  scalefac->l[gr][ch][sfb], slen2 );
			}
			Huffmancodebits( &codedDataPH[gr][ch], ix, gi );
	  } /* for ch */
	} /* for gr */
} /* main_data */

/*____ encodeSideInfo() _____________________________________________________*/

static int encodeSideInfo( III_side_info_t  *si )
{
  int gr, ch, scfsi_band, region, window, bits_sent, mode_gr;
  layer *info = fr_ps->header;

  mode_gr =  2;

  headerPH->nrEntries = 0;
  addBits( headerPH, 0xfff,                   12 );
  addBits( headerPH, 1,												 1 );
  addBits( headerPH, 4 - info->lay,            2 );
  addBits( headerPH, !info->error_protection,  1 );
  addBits( headerPH, info->bitrate_index,      4 );
  addBits( headerPH, info->sampling_frequency, 2 );
  addBits( headerPH, info->padding,            1 );
  addBits( headerPH, info->extension,          1 );
  addBits( headerPH, info->mode,               2 );
  addBits( headerPH, info->mode_ext,           2 );
  addBits( headerPH, info->copyright,          1 );
  addBits( headerPH, info->original,           1 );
  addBits( headerPH, info->emphasis,           2 );
    
  bits_sent = 32;

  if ( info->error_protection )
  {
		addBits( headerPH, 0, 16 );					/* Just a dummy add. Real CRC calculated & inserted in writeSideInfo() */
		bits_sent += 16;
  }
	

  frameSIPH->nrEntries = 0;

  for (ch = 0; ch < stereo; ch++ )
		channelSIPH[ch]->nrEntries = 0;

  for ( gr = 0; gr < 2; gr++ )
		for ( ch = 0; ch < stereo; ch++ )
	    spectrumSIPH[gr][ch]->nrEntries = 0;

	addBits( frameSIPH, si->main_data_begin, 9 );

	if ( stereo == 2 )
	  addBits( frameSIPH, si->private_bits, 3 );
	else
	  addBits( frameSIPH, si->private_bits, 5 );

	for ( ch = 0; ch < stereo; ch++ )
	  for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
	  {
			BitHolder **pph = &channelSIPH[ch];
			addBits( *pph, si->scfsi[ch][scfsi_band], 1 );
	  }

	for ( gr = 0; gr < 2; gr++ )
	  for ( ch = 0; ch < stereo; ch++ )
	  {
			BitHolder **pph = &spectrumSIPH[gr][ch];
			gr_info *gi = &(si->gr[gr].ch[ch].tt);
			addBits( *pph, gi->part2_3_length,        12 );
			addBits( *pph, gi->big_values,            9 );
			addBits( *pph, gi->global_gain,           8 );
			addBits( *pph, gi->scalefac_compress,     4 );
			addBits( *pph, gi->window_switching_flag, 1 );

			if ( gi->window_switching_flag )
			{   
				addBits( *pph, gi->block_type,       2 );
				addBits( *pph, gi->mixed_block_flag, 1 );

				for ( region = 0; region < 2; region++ )
					addBits( *pph, gi->table_select[region],  5 );
				for ( window = 0; window < 3; window++ )
					addBits( *pph, gi->subblock_gain[window], 3 );
			}
			else
			{
/*				assert( gi->block_type == 0 ); */
				for ( region = 0; region < 3; region++ )
					addBits( *pph, gi->table_select[region], 5 );

				addBits( *pph, gi->region0_count, 4 );
				addBits( *pph, gi->region1_count, 3 );
			}

			addBits( *pph, gi->preflag,            1 );
			addBits( *pph, gi->scalefac_scale,     1 );
			addBits( *pph, gi->count1table_select, 1 );
		}


	if ( stereo == 2 )
		bits_sent += 256;
	else
		bits_sent += 136;
  return bits_sent;
}



/*____ write_ancillary_data() _______________________________________________*/

static void write_ancillary_data( char *theData, int lengthInBits )
{
    /*
     */
  int bytesToSend = lengthInBits / 8;
  int remainingBits = lengthInBits % 8;
  unsigned wrd;
  int i;

  userFrameDataPH->nrEntries = 0;

  for ( i = 0; i < bytesToSend; i++ )
  {
		wrd = theData[i];
		addBits( userFrameDataPH, wrd, 8 );
  }
  if ( remainingBits )
  {
		/* right-justify remaining bits */
		wrd = theData[bytesToSend] >> (8 - remainingBits);
		addBits( userFrameDataPH, wrd, remainingBits );
  }
    
}

/*