--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videoeditorengine/mp3aacManipLib/AACGain/src/sbr_demux.cpp Fri Jan 29 14:08:33 2010 +0200
@@ -0,0 +1,594 @@
+/*
+* Copyright (c) 2010 Ixonos Plc.
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - Initial contribution
+*
+* Contributors:
+* Ixonos Plc
+*
+* Description:
+*
+*/
+
+
+/*
+ \file
+ \brief SBR codec implementation $Revision: 1.1.1.1.4.1 $
+*/
+
+/**************************************************************************
+ sbr_demux.cpp - SBR bitstream demultiplexer implementations.
+
+ Author(s): Juha Ojanpera
+ Copyright (c) 2004 by Nokia Research Center, Multimedia Technologies.
+ *************************************************************************/
+
+/*-- Project Headers. --*/
+#include "sbr_rom.h"
+#include "env_extr.h"
+
+typedef const int8 (*Huffman)[2];
+
+/*
+ \brief Decodes Huffman codeword from TBitStream
+
+ \return Decoded Huffman value.
+*/
+int16
+DecodeHuffmanCW(Huffman h, TBitStream *bs)
+{
+ int16 value, bit, index = 0;
+
+ while(index >= 0)
+ {
+ bit = (int16) BsGetBits(bs, 1);
+ index = h[index][bit];
+ }
+
+ value = index + 64;
+
+ return (value);
+}
+
+/*
+ \brief Reads direction control data from TBitStream
+*/
+void
+sbrGetDTDFData(SbrFrameData *frameData, TBitStream *bs)
+{
+ frameData->domain_vec = (uint8) BsGetBits(bs, frameData->frameInfo.nEnvelopes);
+ frameData->domain_vec_noise = (uint8) BsGetBits(bs, frameData->frameInfo.nNoiseEnvelopes);
+}
+
+/*
+ \brief Reads noise-floor-level data from TBitStream
+*/
+void
+sbrGetNoiseFloorData(SbrHeaderData *headerData, SbrFrameData *frameData, TBitStream *bs)
+{
+ int16 i, j, k, noNoiseBands;
+ Huffman hcb_noiseF, hcb_noise;
+
+ noNoiseBands = headerData->hFreqBandData->nNfb;
+
+ if(frameData->coupling == COUPLING_BAL)
+ {
+ hcb_noise = (Huffman) &sbr_huffBook_NoiseBalance11T;
+ hcb_noiseF = (Huffman) &sbr_huffBook_EnvBalance11F;
+ }
+ else
+ {
+ hcb_noise = (Huffman) &sbr_huffBook_NoiseLevel11T;
+ hcb_noiseF = (Huffman) &sbr_huffBook_EnvLevel11F;
+ }
+
+ k = SBR_BIT_ARRAY_SIZE - frameData->frameInfo.nNoiseEnvelopes;
+ for(i = 0; i < frameData->frameInfo.nNoiseEnvelopes; i++, k++)
+ {
+ uint8 codValue;
+ int16 index = i * noNoiseBands;
+
+ codValue = frameData->domain_vec_noise & bitArray[k];
+
+ if(!codValue)
+ {
+ frameData->sbrNoiseFloorLevel[index++] = (int16) BsGetBits(bs, 5);
+
+ for(j = 1; j < noNoiseBands; j++, index++)
+ frameData->sbrNoiseFloorLevel[index] = DecodeHuffmanCW(hcb_noiseF, bs);
+ }
+ else
+ {
+ for(j = 0; j < noNoiseBands; j++, index++)
+ frameData->sbrNoiseFloorLevel[index] = DecodeHuffmanCW(hcb_noise, bs);
+ }
+ }
+}
+
+/*
+ \brief Reads envelope data from TBitStream
+
+ \return One on success.
+*/
+int16
+sbrGetEnvelope(SbrHeaderData *headerData, SbrFrameData *frameData, TBitStream *bs, int16 decVal)
+{
+ Huffman hcb_t, hcb_f;
+ uint8 no_band[MAX_ENVELOPES];
+ int16 i, j, k, delta, offset, ampRes;
+ int16 start_bits, start_bits_balance;
+
+ ampRes = headerData->ampResolution;
+ if(frameData->frameInfo.frameClass == FIXFIX && frameData->frameInfo.nEnvelopes == 1)
+ ampRes = SBR_AMP_RES_1_5;
+
+ if(ampRes == SBR_AMP_RES_3_0)
+ {
+ start_bits = 6;
+ start_bits_balance = 5;
+ }
+ else
+ {
+ start_bits = 7;
+ start_bits_balance = 6;
+ }
+
+ k = SBR_BIT_ARRAY_SIZE - frameData->frameInfo.nEnvelopes;
+ for(i = 0; i < frameData->frameInfo.nEnvelopes; i++, k++)
+ {
+ uint8 resValue = (frameData->frameInfo.freqRes & bitArray[k]) ? 1 : 0;
+
+ no_band[i] = headerData->hFreqBandData->nSfb[resValue];
+ }
+
+ if(frameData->coupling == COUPLING_BAL)
+ {
+ if(ampRes == SBR_AMP_RES_1_5)
+ {
+ hcb_t = (Huffman) &sbr_huffBook_EnvBalance10T;
+ hcb_f = (Huffman) &sbr_huffBook_EnvBalance10F;
+ }
+ else
+ {
+ hcb_t = (Huffman) &sbr_huffBook_EnvBalance11T;
+ hcb_f = (Huffman) &sbr_huffBook_EnvBalance11F;
+ }
+ }
+ else
+ {
+ if(ampRes == SBR_AMP_RES_1_5)
+ {
+ hcb_t = (Huffman) &sbr_huffBook_EnvLevel10T;
+ hcb_f = (Huffman) &sbr_huffBook_EnvLevel10F;
+ }
+ else
+ {
+ hcb_t = (Huffman) &sbr_huffBook_EnvLevel11T;
+ hcb_f = (Huffman) &sbr_huffBook_EnvLevel11F;
+ }
+ }
+
+ decVal = (ampRes) ? decVal : decVal << 1;
+
+ k = SBR_BIT_ARRAY_SIZE - frameData->frameInfo.nEnvelopes;
+ for(j = 0, offset = 0; j < frameData->frameInfo.nEnvelopes; j++, k++)
+ {
+ uint8 codValue = frameData->domain_vec & bitArray[k];
+
+ if(!codValue)
+ {
+ if(frameData->coupling == COUPLING_BAL)
+ frameData->iEnvelope[offset] = (int16) BsGetBits(bs, start_bits_balance);
+ else
+ {
+ frameData->iEnvelope[offset] = (int16) BsGetBits(bs, start_bits);
+
+ frameData->iEnvelope[offset] -= decVal;
+ if(frameData->iEnvelope[offset] < 0)
+ frameData->iEnvelope[offset] = 0;
+ }
+ }
+
+ for(i = (1 - ((codValue) ? 1 : 0)); i < no_band[j]; i++)
+ {
+ if(!codValue)
+ delta = DecodeHuffmanCW(hcb_f, bs);
+ else
+ {
+ delta = DecodeHuffmanCW(hcb_t, bs);
+
+ if(i == 0)
+ delta -= decVal;
+ }
+
+ frameData->iEnvelope[offset + i] = delta;
+ }
+
+ offset += no_band[j];
+ }
+
+ return (1);
+}
+
+/*
+ \brief Extracts the frame information from the TBitStream
+
+ \return One on success
+*/
+int16
+sbrReadGridInfo(TBitStream *bs, SbrHeaderData *headerData, SbrFrameData *frameData)
+{
+ uint8 tmp;
+ FRAME_INFO *frameInfo;
+ SbrGridInfo *sbrGridInfo;
+ int16 pointer_bits, nEnv, k, staticFreqRes;
+
+ nEnv = 0;
+ frameInfo = &frameData->frameInfo;
+ sbrGridInfo = &frameData->sbrGridInfo;
+
+ frameInfo->frameClass = (uint8) BsGetBits(bs, 2);
+
+ switch(frameInfo->frameClass)
+ {
+ case FIXFIX:
+ sbrGridInfo->bs_num_env = (uint8) BsGetBits(bs, 2);
+ staticFreqRes = (int16) BsGetBits(bs, 1);
+ nEnv = (int16) (1 << sbrGridInfo->bs_num_env);
+
+ if(sbrGridInfo->bs_num_env < 3 && headerData->numberTimeSlots == 16)
+ COPY_MEMORY(frameInfo, &(sbr_staticFrameInfo[sbrGridInfo->bs_num_env]), sizeof(FRAME_INFO));
+
+ if(!staticFreqRes)
+ frameInfo->freqRes = 0;
+ break;
+
+ case FIXVAR:
+ case VARFIX:
+ sbrGridInfo->bs_var_board[0] = (uint8) BsGetBits(bs, 2);
+ sbrGridInfo->bs_num_env = (uint8) BsGetBits(bs, 2);
+ nEnv = sbrGridInfo->bs_num_env + 1;
+
+ for(k = 0; k < sbrGridInfo->bs_num_env; k++)
+ sbrGridInfo->bs_rel_board_0[k] = (uint8) BsGetBits(bs, 2);
+
+ pointer_bits = (int16) (FloatFR_logDualis(sbrGridInfo->bs_num_env + 2) + 0.992188f);
+ sbrGridInfo->bs_pointer = (uint8) BsGetBits(bs, pointer_bits);
+ break;
+ }
+
+ switch(frameInfo->frameClass)
+ {
+ case FIXVAR:
+ frameInfo->freqRes = 0;
+ tmp = (uint8) BsGetBits(bs, sbrGridInfo->bs_num_env + 1);
+ for(k = sbrGridInfo->bs_num_env; k >= 0; k--)
+ {
+ frameInfo->freqRes <<= 1;
+ frameInfo->freqRes |= tmp & 0x1;
+ tmp >>= 1;
+ }
+ break;
+
+ case VARFIX:
+ frameInfo->freqRes = (uint8) BsGetBits(bs, sbrGridInfo->bs_num_env + 1);
+ break;
+
+ case VARVAR:
+ sbrGridInfo->bs_var_board[0] = (uint8) BsGetBits(bs, 2);
+ sbrGridInfo->bs_var_board[1] = (uint8) BsGetBits(bs, 2);
+ sbrGridInfo->bs_num_rel[0] = (uint8) BsGetBits(bs, 2);
+ sbrGridInfo->bs_num_rel[1] = (uint8) BsGetBits(bs, 2);
+
+ nEnv = sbrGridInfo->bs_num_rel[0] + sbrGridInfo->bs_num_rel[1] + 1;
+
+ for(k = 0; k < sbrGridInfo->bs_num_rel[0]; k++)
+ sbrGridInfo->bs_rel_board_0[k] = (uint8) BsGetBits(bs, 2);
+
+ for(k = 0; k < sbrGridInfo->bs_num_rel[1]; k++)
+ sbrGridInfo->bs_rel_board_1[k] = (uint8) BsGetBits(bs, 2);
+
+ pointer_bits = (int16) (FloatFR_logDualis(nEnv + 1) + 0.992188f);
+ sbrGridInfo->bs_pointer = (int16) BsGetBits(bs, pointer_bits);
+
+ frameInfo->freqRes = (uint8) BsGetBits(bs, nEnv);
+ break;
+ }
+
+ frameInfo->nEnvelopes = (uint8) nEnv;
+ frameInfo->nNoiseEnvelopes = (nEnv == 1) ? 1 : 2;
+
+ return (1);
+}
+
+/*
+ \brief Initializes SBR header data
+*/
+void
+initHeaderData(SbrHeaderData *headerData, FreqBandData *freqBandData,
+ int32 sampleRate, int16 samplesPerFrame)
+{
+ FreqBandData *hFreq = freqBandData;
+
+ COPY_MEMORY(headerData, &sbr_defaultHeader, sizeof(SbrHeaderData));
+
+ headerData->hFreqBandData = hFreq;
+ headerData->codecFrameSize = samplesPerFrame;
+ headerData->outSampleRate = SBR_UPSAMPLE_FAC * sampleRate;
+ headerData->numberTimeSlots = samplesPerFrame >> (4 + headerData->timeStep);
+}
+
+/*
+ \brief Reads header data from TBitStream
+
+ \return Processing status - HEADER_RESET or HEADER_OK
+*/
+SBR_HEADER_STATUS
+sbrGetHeaderData(SbrHeaderData *h_sbr_header, TBitStream *bs)
+{
+ SbrHeaderData lastHeader;
+ uint8 headerExtra1, headerExtra2;
+
+ COPY_MEMORY(&lastHeader, h_sbr_header, sizeof(SbrHeaderData));
+
+ h_sbr_header->ampResolution = (uint8) BsGetBits(bs, 1);
+ h_sbr_header->startFreq = (uint8) BsGetBits(bs, 4);
+ h_sbr_header->stopFreq = (uint8) BsGetBits(bs, 4);
+ h_sbr_header->xover_band = (uint8) BsGetBits(bs, 3);
+
+ BsGetBits(bs, 2);
+
+ headerExtra1 = (uint8) BsGetBits(bs, 1);
+ headerExtra2 = (uint8) BsGetBits(bs, 1);
+
+ if(headerExtra1)
+ {
+ h_sbr_header->freqScale = (uint8) BsGetBits(bs, 2);
+ h_sbr_header->alterScale = (uint8) BsGetBits(bs, 1);
+ h_sbr_header->noise_bands = (uint8) BsGetBits(bs, 2);
+ }
+ else
+ {
+ h_sbr_header->freqScale = SBR_FREQ_SCALE_DEF;
+ h_sbr_header->alterScale = SBR_ALTER_SCALE_DEF;
+ h_sbr_header->noise_bands = SBR_NOISE_BANDS_DEF;
+ }
+
+ if(headerExtra2)
+ {
+ h_sbr_header->limiterBands = (uint8) BsGetBits(bs, 2);
+ h_sbr_header->limiterGains = (uint8) BsGetBits(bs, 2);
+ h_sbr_header->interpolFreq = (uint8) BsGetBits(bs, 1);
+ h_sbr_header->smoothingLength = (uint8) BsGetBits(bs, 1);
+ }
+ else
+ {
+ h_sbr_header->limiterBands = SBR_LIMITER_BANDS_DEF;
+ h_sbr_header->limiterGains = SBR_LIMITER_GAINS_DEF;
+ h_sbr_header->interpolFreq = SBR_INTERPOL_FREQ_DEF;
+ h_sbr_header->smoothingLength = SBR_SMOOTHING_LENGTH_DEF;
+ }
+
+ if(h_sbr_header->syncState != SBR_ACTIVE ||
+ lastHeader.startFreq != h_sbr_header->startFreq ||
+ lastHeader.stopFreq != h_sbr_header->stopFreq ||
+ lastHeader.xover_band != h_sbr_header->xover_band ||
+ lastHeader.freqScale != h_sbr_header->freqScale ||
+ lastHeader.alterScale != h_sbr_header->alterScale ||
+ lastHeader.noise_bands != h_sbr_header->noise_bands)
+ return (HEADER_RESET); /*-- New settings --*/
+
+ return (HEADER_OK);
+}
+
+/*
+ \brief Reads additional harmonics parameters
+
+ \return Number of bits read
+*/
+static int16
+sbrGetSineData(SbrHeaderData *headerData, SbrFrameData *frameData, TBitStream *bs)
+{
+ int16 bitsRead;
+
+ bitsRead = 1;
+ frameData->isSinesPresent = (uint8) BsGetBits(bs, 1);
+
+ if(frameData->isSinesPresent)
+ {
+ int16 rSfb;
+
+ bitsRead += headerData->hFreqBandData->nSfb[1];
+
+ rSfb = (headerData->hFreqBandData->nSfb[1] > 32) ? 32 : headerData->hFreqBandData->nSfb[1];
+
+ frameData->addHarmonics[0] = (uint8) BsGetBits(bs, rSfb);
+
+ if(headerData->hFreqBandData->nSfb[1] > 32)
+ {
+ rSfb = headerData->hFreqBandData->nSfb[1] - 32;
+ frameData->addHarmonics[1] = (uint8) BsGetBits(bs, rSfb);
+ }
+ }
+
+ return (bitsRead);
+}
+
+/*
+ \brief Reads extension data from the TBitStream
+*/
+static void
+sbrReadExtensionData(TBitStream *bs, SbrExtensionData *sbrExtData, uint8 isMono)
+{
+ sbrExtData->writePsData = 0;
+ sbrExtData->extensionDataPresent = (uint8) BsGetBits(bs, 1);
+
+ if(sbrExtData->extensionDataPresent)
+ {
+ int16 i, nBitsLeft, cnt;
+
+ cnt = (int16) BsGetBits(bs, 4);
+ if(cnt == 15)
+ cnt += (int16) BsGetBits(bs, 8);
+
+ sbrExtData->byteCount = MIN(cnt, sbrExtData->extDataBufLen);
+
+ nBitsLeft = cnt << 3;
+
+ while(nBitsLeft > 7)
+ {
+ sbrExtData->extension_id = (uint8) BsGetBits(bs, 2);
+
+ if(!(sbrExtData->extension_id == SBR_PARAMETRIC_STEREO_ID && isMono))
+ sbrExtData->extension_id = 0;
+ else
+ sbrExtData->writePsData = 1;
+
+ nBitsLeft -= 2;
+
+ cnt = (int16) ((uint16) nBitsLeft >> 3);
+
+ if(sbrExtData->extDataBufLen)
+ {
+ for(i = 0; i < MIN(cnt, sbrExtData->extDataBufLen); i++)
+ sbrExtData->extensioData[i] = (uint8) BsGetBits(bs, 8);
+
+ for( ; i < cnt; i++)
+ BsGetBits(bs, 8);
+ }
+ else
+ for(i = 0; i < cnt; i++)
+ BsGetBits(bs, 8);
+
+ nBitsLeft -= cnt << 3;
+ }
+
+ BsGetBits(bs, nBitsLeft);
+ }
+}
+
+/*
+ \brief Reads TBitStream elements of one channel
+
+ \return One on success
+*/
+int16
+sbrGetSCE(SbrHeaderData *headerData, SbrFrameData *frameData,
+ SbrExtensionData *sbrExtData, TBitStream *bs,
+ int16 decVal, uint8 isMono)
+{
+ frameData->coupling = COUPLING_OFF;
+
+ /*-- Data present. --*/
+ frameData->dataPresent = (int16) BsGetBits(bs, 1);
+ if(frameData->dataPresent) BsGetBits(bs, 4);
+
+ /*-- Read grid info. --*/
+ sbrReadGridInfo(bs, headerData, frameData);
+
+ /*-- Read direction info for envelope decoding. --*/
+ sbrGetDTDFData(frameData, bs);
+
+ /*-- Read inverse filtering modes. --*/
+ frameData->sbr_invf_mode = (uint8) BsGetBits(bs, headerData->hFreqBandData->nInvfBands << 1);
+
+ /*-- Read Huffman coded envelope values. --*/
+ sbrGetEnvelope(headerData, frameData, bs, decVal);
+
+ /*-- Read noise data. --*/
+ sbrGetNoiseFloorData(headerData, frameData, bs);
+
+ /*-- Read sine data, if any. --*/
+ sbrGetSineData(headerData, frameData, bs);
+
+ /*-- Read extension data, if any. --*/
+ sbrReadExtensionData(bs, sbrExtData, isMono);
+
+ return (1);
+}
+
+/*
+ \brief Reads TBitStream elements of a channel pair
+
+ \return One on success
+*/
+int16
+sbrGetCPE(SbrHeaderData *headerData, SbrFrameData *frameDataLeft,
+ SbrFrameData *frameDataRight, SbrExtensionData *sbrExtData,
+ TBitStream *bs, int16 decVal)
+{
+ /*-- Data present. -*/
+ frameDataLeft->dataPresent = (uint8) BsGetBits(bs, 1);
+ if(frameDataLeft->dataPresent)
+ BsGetBits(bs, 8);
+
+ /*-- Coupling mode. --*/
+ if(BsGetBits(bs, 1))
+ {
+ frameDataLeft->coupling = COUPLING_LEVEL;
+ frameDataRight->coupling = COUPLING_BAL;
+ }
+ else
+ {
+ frameDataLeft->coupling = COUPLING_OFF;
+ frameDataRight->coupling = COUPLING_OFF;
+ }
+
+ /*-- Read grid info (left channel). --*/
+ sbrReadGridInfo(bs, headerData, frameDataLeft);
+
+ /*-- Read grid info (right channel). --*/
+ if(frameDataLeft->coupling)
+ COPY_MEMORY(&frameDataRight->frameInfo, &frameDataLeft->frameInfo, sizeof(FRAME_INFO));
+ else
+ sbrReadGridInfo(bs, headerData, frameDataRight);
+
+ /*-- Read direction info for envelope decoding. --*/
+ sbrGetDTDFData(frameDataLeft, bs);
+ sbrGetDTDFData(frameDataRight, bs);
+
+ /*-- Read inverse filtering modes for left channel. --*/
+ frameDataLeft->sbr_invf_mode = (uint8) BsGetBits(bs, headerData->hFreqBandData->nInvfBands << 1);
+
+ if(frameDataLeft->coupling)
+ {
+ frameDataRight->sbr_invf_mode = frameDataLeft->sbr_invf_mode;
+
+ /*-- Read Huffman coded envelope + noise values for left channel. --*/
+ sbrGetEnvelope(headerData, frameDataLeft, bs, decVal);
+ sbrGetNoiseFloorData(headerData, frameDataLeft, bs);
+
+ /*-- Read Huffman coded envelope for right channel. --*/
+ sbrGetEnvelope(headerData, frameDataRight, bs, decVal);
+ }
+ else
+ {
+ /*-- Read inverse filtering modes for right channel. --*/
+ frameDataRight->sbr_invf_mode = (uint8) BsGetBits(bs, headerData->hFreqBandData->nInvfBands << 1);
+
+ /*-- Read Huffman coded envelope values. --*/
+ sbrGetEnvelope(headerData, frameDataLeft, bs, decVal);
+ sbrGetEnvelope(headerData, frameDataRight, bs, decVal);
+
+ /*-- Read noise data for left channel. --*/
+ sbrGetNoiseFloorData(headerData, frameDataLeft, bs);
+ }
+
+ /*-- Read noise data for right channel. --*/
+ sbrGetNoiseFloorData(headerData, frameDataRight, bs);
+
+ /*-- Read additional sines, if any. --*/
+ sbrGetSineData(headerData, frameDataLeft, bs);
+ sbrGetSineData(headerData, frameDataRight, bs);
+
+ /*-- Read extension data, if any. --*/
+ sbrReadExtensionData(bs, sbrExtData, 0);
+
+ return (1);
+}