/*****************************************************************************
description: initializes parameters and allocates memory
returns: error status
*****************************************************************************/
int
EnvOpen (HANDLE_SBR_ENCODER * hEnvEncoder,
float *pCoreBuffer,
sbrConfigurationPtr params,
int *coreBandWith)
{
HANDLE_SBR_ENCODER hEnvEnc ;
int ch;
COUNT_sub_start("EnvOpen");
MOVE(1);
*hEnvEncoder=0;
PTR_INIT(1);
hEnvEnc = &sbrEncoder;
PTR_INIT(2); /* hEnvEnc->hEnvChannel[]
EnvChannel[]
*/
LOOP(1);
for (ch=0; ch<MAX_CHANNELS; ch++)
{
PTR_INIT(1);
hEnvEnc->hEnvChannel[ch] = &EnvChannel[ch];
}
INDIRECT(2); ADD(2); LOGIC(1); BRANCH(1);
if ((params->codecSettings.nChannels < 1) || (params->codecSettings.nChannels > MAX_CHANNELS)){
FUNC(1);
EnvClose (hEnvEnc);
COUNT_sub_end();
return(1);
}
INDIRECT(1); PTR_INIT(1);
hEnvEnc->sbrConfigData.freqBandTable[LO] = sbr_freqBandTableLO;
FUNC(2); LOOP(1); PTR_INIT(1); MOVE(1); STORE(MAX_FREQ_COEFFS/2+1);
memset(hEnvEnc->sbrConfigData.freqBandTable[LO],0,sizeof(unsigned char)*MAX_FREQ_COEFFS/2+1);
INDIRECT(1); PTR_INIT(1);
hEnvEnc->sbrConfigData.freqBandTable[HI] = sbr_freqBandTableHI;
FUNC(2); LOOP(1); PTR_INIT(1); MOVE(1); STORE(MAX_FREQ_COEFFS+1);
memset(hEnvEnc->sbrConfigData.freqBandTable[HI],0,sizeof(unsigned char)*MAX_FREQ_COEFFS+1);
INDIRECT(1); PTR_INIT(1);
hEnvEnc->sbrConfigData.v_k_master = sbr_v_k_master;
FUNC(2); LOOP(1); PTR_INIT(1); MOVE(1); STORE(MAX_FREQ_COEFFS+1);
memset(hEnvEnc->sbrConfigData.v_k_master,0,sizeof(unsigned char)*MAX_FREQ_COEFFS+1);
INDIRECT(1); BRANCH(1);
if (hEnvEnc->CmonData.sbrBitbuf.isValid == 0) {
INDIRECT(2); PTR_INIT(1); FUNC(3);
CreateBitBuffer(&hEnvEnc->CmonData.sbrBitbuf,
(unsigned char*) hEnvEnc->sbrPayload,
sizeof(hEnvEnc->sbrPayload));
}
INDIRECT(1); BRANCH(1);
if (hEnvEnc->CmonData.sbrBitbufPrev.isValid == 0) {
INDIRECT(2); PTR_INIT(1); FUNC(3);
CreateBitBuffer(&hEnvEnc->CmonData.sbrBitbufPrev,
(unsigned char*) hEnvEnc->sbrPayloadPrevious,
sizeof(hEnvEnc->sbrPayload));
}
INDIRECT(2); MOVE(1);
hEnvEnc->sbrConfigData.nChannels = params->codecSettings.nChannels;
INDIRECT(1); ADD(1); BRANCH(1);
if(params->codecSettings.nChannels == 2)
{
INDIRECT(2); MOVE(1);
hEnvEnc->sbrConfigData.stereoMode = params->stereoMode;
}
else
{
INDIRECT(1); MOVE(1);
hEnvEnc->sbrConfigData.stereoMode = SBR_MONO;
}
INDIRECT(1); ADD(1); BRANCH(1);
if (params->codecSettings.sampleFreq <= 24000) {
INDIRECT(1); MOVE(1);
hEnvEnc->sbrHeaderData.sampleRateMode = DUAL_RATE;
INDIRECT(1); MULT(1); STORE(1);
hEnvEnc->sbrConfigData.sampleFreq = 2 * params->codecSettings.sampleFreq;
}
else {
INDIRECT(2); MOVE(2);
hEnvEnc->sbrHeaderData.sampleRateMode = SINGLE_RATE;
hEnvEnc->sbrConfigData.sampleFreq = params->codecSettings.sampleFreq;
}
INDIRECT(1); MOVE(1);
hEnvEnc->sbrBitstreamData.CountSendHeaderData = 0;
INDIRECT(1); BRANCH(1);
if (params->SendHeaderDataTime > 0 ) {
INDIRECT(2); MULT(2); DIV(1); STORE(1);
hEnvEnc->sbrBitstreamData.NrSendHeaderData = (int)(params->SendHeaderDataTime * 0.001*
hEnvEnc->sbrConfigData.sampleFreq / 2048
);
ADD(1); BRANCH(1); MOVE(1);
hEnvEnc->sbrBitstreamData.NrSendHeaderData = max(hEnvEnc->sbrBitstreamData.NrSendHeaderData,1);
}
else {
INDIRECT(1); MOVE(1);
hEnvEnc->sbrBitstreamData.NrSendHeaderData = 0;
}
INDIRECT(10); MOVE(6);
hEnvEnc->sbrHeaderData.sbr_data_extra = params->sbr_data_extra;
hEnvEnc->sbrBitstreamData.CRCActive = params->crcSbr;
hEnvEnc->sbrBitstreamData.HeaderActive = 0;
hEnvEnc->sbrHeaderData.sbr_start_frequency = params->startFreq;
hEnvEnc->sbrHeaderData.sbr_stop_frequency = params->stopFreq;
hEnvEnc->sbrHeaderData.sbr_xover_band = 0;
INDIRECT(1); ADD(1); BRANCH(1);
if (params->sbr_xpos_ctrl!= SBR_XPOS_CTRL_DEFAULT)
{
INDIRECT(1); MOVE(1);
hEnvEnc->sbrHeaderData.sbr_data_extra = 1;
}
INDIRECT(1); MOVE(1);
hEnvEnc->sbrHeaderData.protocol_version = SI_SBR_PROTOCOL_VERSION_ID;
INDIRECT(2); MOVE(2);
hEnvEnc->sbrHeaderData.sbr_amp_res = (AMP_RES)params->amp_res;
INDIRECT(7); MOVE(4);
hEnvEnc->sbrHeaderData.freqScale = params->freqScale;
hEnvEnc->sbrHeaderData.alterScale = params->alterScale;
hEnvEnc->sbrHeaderData.sbr_noise_bands = params->sbr_noise_bands;
hEnvEnc->sbrHeaderData.header_extra_1 = 0;
ADD(3); LOGIC(2); BRANCH(1);
if ((params->freqScale != SBR_FREQ_SCALE_DEFAULT) ||
(params->alterScale != SBR_ALTER_SCALE_DEFAULT) ||
(params->sbr_noise_bands != SBR_NOISE_BANDS_DEFAULT)) {
MOVE(1);
hEnvEnc->sbrHeaderData.header_extra_1 = 1;
}
INDIRECT(9); MOVE(5);
hEnvEnc->sbrHeaderData.sbr_limiter_bands = params->sbr_limiter_bands;
hEnvEnc->sbrHeaderData.sbr_limiter_gains = params->sbr_limiter_gains;
hEnvEnc->sbrHeaderData.sbr_interpol_freq = params->sbr_interpol_freq;
hEnvEnc->sbrHeaderData.sbr_smoothing_length = params->sbr_smoothing_length;
hEnvEnc->sbrHeaderData.header_extra_2 = 0;
ADD(4); LOGIC(3); BRANCH(1);
if ((params->sbr_limiter_bands != SBR_LIMITER_BANDS_DEFAULT) ||
(params->sbr_limiter_gains != SBR_LIMITER_GAINS_DEFAULT) ||
(params->sbr_interpol_freq != SBR_INTERPOL_FREQ_DEFAULT) ||
(params->sbr_smoothing_length != SBR_SMOOTHING_LENGTH_DEFAULT)) {
MOVE(1);
hEnvEnc->sbrHeaderData.header_extra_2 = 1;
}
INDIRECT(4); MOVE(2);
hEnvEnc->sbrConfigData.detectMissingHarmonics = params->detectMissingHarmonics;
hEnvEnc->sbrConfigData.useParametricCoding = params->parametricCoding;
INDIRECT(2); PTR_INIT(2); FUNC(3); BRANCH(1);
if(updateFreqBandTable(&hEnvEnc->sbrConfigData,
&hEnvEnc->sbrHeaderData,
QMF_CHANNELS)){
FUNC(1);
EnvClose (hEnvEnc);
COUNT_sub_end();
return(1);
}
PTR_INIT(1); /* hEnvEnc->hEnvChannel[] */
INDIRECT(3); PTR_INIT(2); LOOP(1);
for ( ch = 0; ch < hEnvEnc->sbrConfigData.nChannels; ch++ ) {
FUNC(5); BRANCH(1);
if(createEnvChannel(ch,
&hEnvEnc->sbrConfigData,
&hEnvEnc->sbrHeaderData,
hEnvEnc->hEnvChannel[ch],
params)){
FUNC(1);
EnvClose (hEnvEnc);
COUNT_sub_end();
return(1);
}
}
INDIRECT(1); PTR_INIT(1);
hEnvEnc->hPsEnc = NULL;
#ifndef MONO_ONLY
INDIRECT(1); BRANCH(1);
if (params->usePs)
{
INDIRECT(2); PTR_INIT(1); FUNC(2); BRANCH(1);
if(createQmfBank (1, &hEnvEnc->hEnvChannel[1]->sbrQmf)){
COUNT_sub_end();
return (1);
}
INDIRECT(1); PTR_INIT(1); FUNC(3); BRANCH(1);
if(CreateExtractSbrEnvelope (1,
&hEnvEnc->hEnvChannel[1]->sbrExtractEnvelope,
576
)) {
COUNT_sub_end();
return(1);
}
INDIRECT(1); MOVE(1);
hEnvEnc->hSynthesisQmfBank = &SynthesisQmfBank;
INDIRECT(1); PTR_INIT(1); FUNC(1); BRANCH(1);
if(CreateSynthesisQmfBank (hEnvEnc->hSynthesisQmfBank)){
FUNC(1);
DeleteSynthesisQmfBank ((HANDLE_SBR_QMF_FILTER_BANK*)&hEnvEnc->hSynthesisQmfBank);
COUNT_sub_end();
return 1;
}
INDIRECT(1); MOVE(1);
hEnvEnc->hPsEnc = &psEncoder;
INDIRECT(2); PTR_INIT(1); FUNC(2); BRANCH(1);
if(CreatePsEnc (hEnvEnc->hPsEnc,
params->psMode)){
FUNC(1);
DeletePsEnc(&hEnvEnc->hPsEnc);
COUNT_sub_end();
return 1;
}
}
#endif /* #ifndef MONO_ONLY */
INDIRECT(2); MOVE(1);
hEnvEnc->CmonData.sbrNumChannels = hEnvEnc->sbrConfigData.nChannels;
INDIRECT(1); MOVE(1);
hEnvEnc->sbrPayloadSize = 0;
INDIRECT(1); MOVE(2);
*hEnvEncoder = hEnvEnc;
*coreBandWith = hEnvEnc->sbrConfigData.xOverFreq;
COUNT_sub_end();
return 0;
}
int main(/*int argc, char *argv[]*/)
{
AACENC_CONFIG config;
FILE* inputFile = NULL;
SBRDECODER sbrDecoderInfo = 0;
FILE *fOut=NULL;
HANDLE_MP4_FILE hMp4File;
int error;
int bitrate;
int nChannelsAAC, nChannelsSBR;
unsigned int sampleRateAAC;
int frmCnt;
int bandwidth = 0;
unsigned int numAncDataBytes=0;
unsigned char ancDataBytes[MAX_PAYLOAD_SIZE];
/*!< required only for interfacing with audio output library, thus not counted into RAM requirements */
short TimeDataPcm[AACENC_BLOCKSIZE*2*MAX_CHANNELS];
int numSamplesRead;
int bDoIIR2Downsample = 0;
int bDingleRate = 0;
int useParametricStereo = 0;
int coreWriteOffset = 0;
int coreReadOffset = 0;
int envWriteOffset = 0;
int envReadOffset = 0;
int writeOffset=INPUT_DELAY*MAX_CHANNELS;
struct AAC_ENCODER *aacEnc = 0;
int bDoUpsample = 0;
int upsampleReadOffset = 0;
int inSamples_enc;
int bDoIIR32Resample = 0;
const int nRuns = 4;
float *resamplerScratch = sbr_envRBuffer;
HANDLE_SBR_ENCODER hEnvEnc=NULL;
bitrate = 24000;
/*open audio input file*/
int sampleRate = 48000 ; /* only relevant if valid == 1 */
int nChannels = 2 ; /* only relevant if valid == 1 */
inputFile = fopen("f:\\xxxx.wav", "rb");
if(inputFile == NULL)
{
assert(0);
return 0;
}
/* set up basic parameters for aacPlus codec*/
AacInitDefaultConfig(&config);
nChannelsAAC = nChannelsSBR = nChannels;
if ( (nChannels == 2) && (bitrate > 16000) && (bitrate < 36000) )
{
useParametricStereo = 1;
}
if (useParametricStereo)
{
nChannelsAAC = 1;
nChannelsSBR = 2;
}
if ( (sampleRate == 48000) && (nChannelsAAC == 2) && (bitrate < 24000) ) {
bDoIIR32Resample = 1;
}
if (sampleRate == 16000) {
bDoUpsample = 1;
sampleRate = 32000;
bDingleRate = 1;
}
sampleRateAAC = sampleRate;
if (bDoIIR32Resample)
sampleRateAAC = 32000;
config.bitRate = bitrate;
config.nChannelsIn=nChannels;
config.nChannelsOut=nChannelsAAC;
config.bandWidth=bandwidth;
/*set up SBR configuration*/
if(!IsSbrSettingAvail (bitrate, nChannelsAAC, sampleRateAAC, &sampleRateAAC)) {
fprintf(stderr,"No valid SBR configuration found\n");
exit(10);
}
{
sbrConfiguration sbrConfig;
envReadOffset = 0;
coreWriteOffset = 0;
if(useParametricStereo)
{
envReadOffset = (MAX_DS_FILTER_DELAY + INPUT_DELAY)*MAX_CHANNELS;
coreWriteOffset = CORE_INPUT_OFFSET_PS;
writeOffset = envReadOffset;
}
InitializeSbrDefaults (&sbrConfig);
sbrConfig.usePs = useParametricStereo;
AdjustSbrSettings(&sbrConfig,
bitrate,
nChannelsAAC,
sampleRateAAC,
AACENC_TRANS_FAC,
24000);
EnvOpen(&hEnvEnc,
inputBuffer + coreWriteOffset,
&sbrConfig,
&config.bandWidth);
/* set IIR 2:1 downsampling */
bDoIIR2Downsample = (bDoUpsample) ? 0 : 1;
if (useParametricStereo)
{
bDoIIR2Downsample = 0;
}else{
assert(0);
}
}
if (bDoUpsample) {
assert(0);
}
else {
if (bDoIIR2Downsample){
assert(0);
}
}
/*
set up AAC encoder, now that samling rate is known
*/
config.sampleRate = sampleRateAAC;
error = AacEncOpen( &aacEnc,config);
if (error){
assert(0);
AacEncClose(aacEnc);
fclose(inputFile);
if (fOut)
fclose(fOut);
return 1;
}
/*set up MPEG-4/3GPP file format library (not instrumented nor accounted for RAM requirements)*/
{
unsigned char ASConfigBuffer[80];
unsigned int nConfigBits;
unsigned int nConfigBytes;
memset (ASConfigBuffer, 0, 80);
if ( GetMPEG4ASConfig( sampleRateAAC,
nChannelsAAC,
ASConfigBuffer,
&nConfigBits,
1,
bDingleRate) ) {
fprintf(stderr, "\nCould not initialize Audio Specific Config\n");
exit(10);
}
nConfigBytes = (nConfigBits+7)>>3;
if (OpenMP4File(&hMp4File,
ASConfigBuffer,
nConfigBytes,
"f:/out2.3gp",
(!bDingleRate) ? sampleRateAAC*2 : sampleRateAAC, /* output sampleRate */
config.bitRate,
nChannelsAAC,
1,
1) ) {
fprintf(stderr, "\nFailed to create 3GPP file\n") ;
exit(10);
}
}
frmCnt = 0;
memset(TimeDataPcm,0,sizeof(TimeDataPcm));
/*set up input samples block size feed*/
inSamples_enc = AACENC_BLOCKSIZE * nChannels * 2;
////decodec////////////////////////////////////////////////////////////////////////////////////////
#define INPUT_BUF_SIZE (6144*2/8) /*!< Size of Input buffer in bytes*/
unsigned int inBuffer[INPUT_BUF_SIZE/(sizeof(int))]; /*!< Input buffer */
struct BIT_BUF bitBuf, *hBitBuf;
AACDECODER aacDecoderInfo = 0;
SBRBITSTREAM streamSBR;
hBitBuf = CreateBitBuffer(&bitBuf,(unsigned char*) inBuffer,INPUT_BUF_SIZE);
aacDecoderInfo = CAacDecoderOpen(hBitBuf,
&streamSBR,
TimeDataFloat);
if(0 == aacDecoderInfo)
{
assert(0);
return 0;
}
if(0 != CAacDecoderInit (aacDecoderInfo,sampleRate/2,bitrate))
{
assert(0);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
FILE* fw = fopen("f:\\uuu.pcm", "wb");
/* The frame loop */
while (1)
{
int i, numOutBytes;
numSamplesRead = fread(TimeDataPcm, 2, inSamples_enc, inputFile);
if(numSamplesRead <= 0)
{
break;
}
/* copy from short to float input buffer */
if ( nChannels == nChannelsSBR ) {
for (i=0; i<numSamplesRead; i++) {
inputBuffer[i+writeOffset] = (float) TimeDataPcm[i];
}
}
#if (MAX_CHANNELS==2)
/* copy from short to float input buffer, reordering necessary since the encoder takes interleaved data */
if(nChannels == 1) {
int i;
for (i=0; i<numSamplesRead; i++) {
inputBuffer[writeOffset+2*i] = (float) TimeDataPcm[i];
}
}
#endif
/*encode one SBR frame*/
EnvEncodeFrame (hEnvEnc,
inputBuffer + envReadOffset,
inputBuffer + coreWriteOffset,
MAX_CHANNELS,
&numAncDataBytes,
ancDataBytes);
/*encode one AAC frame*/
if (hEnvEnc && useParametricStereo) {
AacEncEncode(aacEnc,
inputBuffer,
1, /* stride */
ancDataBytes,
&numAncDataBytes,
outputBuffer,
&numOutBytes);
if(hEnvEnc)
{
memcpy( inputBuffer,inputBuffer+AACENC_BLOCKSIZE,CORE_INPUT_OFFSET_PS*sizeof(float));
}
}
else
{
assert(0);
}
////////////////////////////////////////dec
unsigned char* pData = (unsigned char*)outputBuffer;
for(int i = 0; i < numOutBytes; i++)
WriteBits(hBitBuf,pData[i],8);
streamSBR.NrElements = 0;
int frameSize_dec= 0, sampleRate_dec = 0, numChannels_dec = 2;
char frameOk_dec = 1, channelMode_dec = 0;
int ErrorStatus = CAacDecoder_DecodeFrame(aacDecoderInfo,&frameSize_dec,&sampleRate_dec,
&numChannels_dec, &channelMode_dec, frameOk_dec);
assert(ErrorStatus == 0);
if ((!sbrDecoderInfo) && streamSBR.NrElements)
sbrDecoderInfo = openSBR (sampleRate_dec,frameSize_dec, 0,0);
if (sbrDecoderInfo) {
/* apply SBR processing */
if (applySBR(sbrDecoderInfo, &streamSBR, TimeDataFloat, &numChannels_dec,
frameOk_dec, 0, 0) != SBRDEC_OK){
sbrDecoderInfo = 0;
}
else {
frameSize_dec = frameSize_dec * 2;
sampleRate_dec *= 2;
}
}
short* pwData = new short[frameSize_dec * 2];
/* clip time samples */
for (i = 0; i < frameSize_dec * numChannels_dec; i++) {
if (TimeDataFloat[i] < -32768.0) {
TimeDataFloat[i] = -32768.0;
}
else {
if (TimeDataFloat[i] > 32767.0) {
TimeDataFloat[i] = 32767.0;
}
}
//pwData[i] = TimeDataFloat[i];
}
interleaveSamples(&TimeDataFloat[0],&TimeDataFloat[frameSize_dec],pwData,frameSize_dec,&numChannels_dec);
fwrite(pwData, 2, frameSize_dec * numChannels_dec, fw);
delete [] pwData;
////////////////////////////////////////////////////////////////////////
if (numOutBytes) {
MP4FileAddFrame( hMp4File,
outputBuffer,
numOutBytes );
}
frmCnt++;
/* 3GPP instrumenting tool: measure worst case work load at end of each decoding loop */
fprintf(stderr,"[%d]\r",frmCnt); fflush(stderr);
}
fprintf(stderr,"\n"); fflush(stderr);
AacEncClose(aacEnc);
fclose(inputFile);
if (WriteMP4File( hMp4File)) {
fprintf(stderr, "Writing of 3GPP file failed.");
exit(10);
}
CloseMP4File( hMp4File);
if(hEnvEnc)
{
EnvClose(hEnvEnc);
}
printf("\nencoding finished\n");
return 0;
}
/*!
\brief appends the parametric stereo bitstream portion to the output
bitstream
\return Number of bits needed for parametric stereo coding
of 0 if no EXTENSION_ID_PS_CODING element should be transmitted
****************************************************************************/
int
AppendPsBS (HANDLE_PS_ENC h_ps_e,
HANDLE_BIT_BUF hBitStream,
HANDLE_BIT_BUF hBitStreamPrev,
int* sbrHdrBits)
{
struct BIT_BUF bitbufTmp;
unsigned char tmp[MAX_PAYLOAD_SIZE];
COUNT_sub_start("AppendPsBS");
BRANCH(1);
if (!h_ps_e)
{
COUNT_sub_end();
return 0;
}
BRANCH(1);
if (!hBitStream) {
INDIRECT(1); PTR_INIT(1); FUNC(1); /* counting post-operation */
COUNT_sub_end();
return GetBitsAvail (&h_ps_e->psBitBuf);
}
else {
int writtenNoBits = 0;
int maxExtSize = (1<<SI_SBR_EXTENSION_SIZE_BITS) - 1;
int numBits = GetBitsAvail (&h_ps_e->psBitBuf);
int extDataSize = (numBits+SI_SBR_EXTENSION_ID_BITS+7)>>3;
MOVE(2); INDIRECT(1); PTR_INIT(1); FUNC(1); ADD(1); SHIFT(1); /* counting previous operations */
FUNC(1); BRANCH(1);
if ( GetBitsAvail(hBitStreamPrev) == 0) {
INDIRECT(1); MOVE(1);
h_ps_e->hdrBitsPrevFrame = *sbrHdrBits;
FUNC(2);
CopyBitBuf(hBitStream, hBitStreamPrev);
}
else {
int tmpBits;
PTR_INIT(1); FUNC(3);
CreateBitBuffer (&bitbufTmp, tmp, sizeof(tmp));
MOVE(1);
tmpBits = *sbrHdrBits;
INDIRECT(1); MOVE(2);
*sbrHdrBits = h_ps_e->hdrBitsPrevFrame;
h_ps_e->hdrBitsPrevFrame = tmpBits;
FUNC(2);
CopyBitBuf (hBitStreamPrev, &bitbufTmp);
FUNC(2);
CopyBitBuf (hBitStream, hBitStreamPrev);
FUNC(2);
CopyBitBuf (&bitbufTmp, hBitStream);
}
FUNC(3);
WriteBits (hBitStream, 1, SI_SBR_EXTENDED_DATA_BITS);
ADD(1); BRANCH(1);
if (extDataSize < maxExtSize) {
FUNC(3);
WriteBits (hBitStream, extDataSize, SI_SBR_EXTENSION_SIZE_BITS);
} else {
FUNC(3);
WriteBits (hBitStream, maxExtSize, SI_SBR_EXTENSION_SIZE_BITS);
ADD(1); FUNC(3);
WriteBits (hBitStream, extDataSize - maxExtSize, SI_SBR_EXTENSION_ESC_COUNT_BITS);
}
FUNC(3); ADD(1);
writtenNoBits += WriteBits (hBitStream, EXTENSION_ID_PS_CODING, SI_SBR_EXTENSION_ID_BITS);
INDIRECT(1); PTR_INIT(1); FUNC(3); ADD(1);
writtenNoBits += appendBitstream( hBitStream, &h_ps_e->psBitBuf, numBits );
LOGIC(1);
writtenNoBits = writtenNoBits%8;
BRANCH(1);
if(writtenNoBits)
{
ADD(1); FUNC(3);
WriteBits(hBitStream, 0, (8 - writtenNoBits));
}
FUNC(1); ADD(2); /* counting post-operation */
COUNT_sub_end();
return GetBitsAvail(hBitStream)-(*sbrHdrBits)-SI_FILL_EXTENTION_BITS;
}
COUNT_sub_end();
}
int AacEncEncode(struct AAC_ENCODER *aacEnc, /*!< an encoder handle */
float *timeSignal, /*!< BLOCKSIZE*nChannels audio samples */
unsigned int timeInStride,
const unsigned char *ancBytes, /*!< pointer to ancillary data bytes */
unsigned int *numAncBytes, /*!< number of ancillary Data Bytes */
unsigned int *outBytes, /*!< pointer to output buffer */
int *numOutBytes /*!< number of bytes in output buffer */
)
{
ELEMENT_INFO* elInfo = &aacEnc->elInfo;
int globUsedBits;
int ancDataBytes, ancDataBytesLeft;
COUNT_sub_start("AacEncEncode");
INDIRECT(2); PTR_INIT(1); FUNC(3);
aacEnc->hBitStream = CreateBitBuffer(&aacEnc->bitStream,
(unsigned char*) outBytes,
(MAX_CHANNEL_BITS/8)*MAX_CHANNELS);
INDIRECT(1); PTR_INIT(1); /* counting previous operation */
MOVE(2);
ancDataBytes = ancDataBytesLeft = *numAncBytes;
/* advance psychoacoustic */
LOGIC(1); BRANCH(1);
if (elInfo->elType == ID_CPE) {
PTR_INIT(1); FUNC(5);
ApplyStereoPreProcess(&aacEnc->stereoPrePro,
timeInStride,
elInfo,
timeSignal,
FRAME_LEN_LONG);
}
INDIRECT(5); PTR_INIT(4); FUNC(9);
psyMain(timeInStride,
elInfo,
timeSignal,
&aacEnc->psyKernel.psyData[elInfo->ChannelIndex[0]],
&aacEnc->psyKernel.tnsData[elInfo->ChannelIndex[0]],
&aacEnc->psyKernel.psyConfLong,
&aacEnc->psyKernel.psyConfShort,
&aacEnc->psyOut.psyOutChannel[elInfo->ChannelIndex[0]],
&aacEnc->psyOut.psyOutElement,
aacEnc->psyKernel.pScratchTns);
INDIRECT(3); PTR_INIT(1); FUNC(3);
AdjustBitrate(&aacEnc->qcKernel,
aacEnc->config.bitRate,
aacEnc->config.sampleRate);
PTR_INIT(4); /*
aacEnc->qcKernel.elementBits
aacEnc->qcKernel.adjThr.adjThrStateElem,
aacEnc->psyOut.psyOutElement,
aacEnc->qcOut.qcElement
*/
ADD(1); BRANCH(1); MOVE(1); /* min() */ INDIRECT(2); PTR_INIT(3); FUNC(9);
QCMain( &aacEnc->qcKernel,
elInfo->nChannelsInEl,
&aacEnc->qcKernel.elementBits,
&aacEnc->qcKernel.adjThr.adjThrStateElem,
&aacEnc->psyOut.psyOutChannel[elInfo->ChannelIndex[0]],
&aacEnc->psyOut.psyOutElement,
&aacEnc->qcOut.qcChannel[elInfo->ChannelIndex[0]],
&aacEnc->qcOut.qcElement,
min(ancDataBytesLeft,ancDataBytes));
LOGIC(1); BRANCH(1);
if ( elInfo->elType == ID_CPE ) {
INDIRECT(1); PTR_INIT(2); FUNC(4);
UpdateStereoPreProcess(&aacEnc->psyOut.psyOutChannel[elInfo->ChannelIndex[0]],
&aacEnc->qcOut.qcElement,
&aacEnc->stereoPrePro,
aacEnc->psyOut.psyOutElement.weightMsLrPeRatio);
}
ADD(1);
ancDataBytesLeft-=ancDataBytes;
INDIRECT(2); PTR_INIT(2); FUNC(2);
FinalizeBitConsumption( &aacEnc->qcKernel,
&aacEnc->qcOut);
INDIRECT(3); PTR_INIT(3); FUNC(7);
WriteBitstream( aacEnc->hBitStream,
*elInfo,
&aacEnc->qcOut,
&aacEnc->psyOut,
&globUsedBits,
ancBytes);
INDIRECT(2); PTR_INIT(2); FUNC(2);
UpdateBitres(&aacEnc->qcKernel,
&aacEnc->qcOut);
/* write out the bitstream */
INDIRECT(1); FUNC(1); DIV(1); STORE(1);
*numOutBytes = GetBitsAvail(aacEnc->hBitStream)/8;
/* assert this frame is not too large */
assert(*numOutBytes*8 <= MAX_CHANNEL_BITS * elInfo->nChannelsInEl);
COUNT_sub_end();
return 0;
}
