/*****************************************************************************
description: writes bits corresponding to the "synthetic-coding"-extension
returns: number of bits written
*****************************************************************************/
static int writeSyntheticCodingData (HANDLE_SBR_ENV_DATA sbrEnvData,
HANDLE_BIT_BUF hBitStream)
{
int i;
int payloadBits = 0;
/* counting previous operation */
payloadBits += WriteBits (hBitStream, sbrEnvData->addHarmonicFlag, 1);
if (sbrEnvData->addHarmonicFlag) {
/* sbrEnvData->addHarmonic[] */
for (i = 0; i < sbrEnvData->noHarmonics; i++) {
payloadBits += WriteBits (hBitStream, sbrEnvData->addHarmonic[i], 1);
}
}
return payloadBits;
}
/*****************************************************************************
description: writes bits that describes the direction of the envelopes of a frame
returns: number of bits written
*****************************************************************************/
static int
encodeSbrDtdf (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_BIT_BUF hBitStream)
{
int i, payloadBits = 0, noOfNoiseEnvelopes;
/* counting previous operations */
noOfNoiseEnvelopes = (sbrEnvData->noOfEnvelopes > 1) ? 2 : 1;
/* sbrEnvData->domain_vec[] */
for (i = 0; i < sbrEnvData->noOfEnvelopes; ++i) {
payloadBits += WriteBits (hBitStream, sbrEnvData->domain_vec[i], SBR_DIR_BITS);
}
/* sbrEnvData->domain_vec_noise[] */
for (i = 0; i < noOfNoiseEnvelopes; ++i) {
payloadBits += WriteBits (hBitStream, sbrEnvData->domain_vec_noise[i], SBR_DIR_BITS);
}
return payloadBits;
}
void CompressFile ( FILE *input, BFILE *output)
{
int i;
int c;
int look_ahead_bytes;
int current_pos;
int replace_count;
int match_len;
int match_pos;
current_pos = 1;
for ( i = 0; i < LOOK_AHEAD_SIZE; i++)
{
if ( (c = getc (input)) == EOF )
break;
window [current_pos + i] = (uchar) c;
}
look_ahead_bytes = i;
InitTree (current_pos);
match_len = 0;
match_pos = 0;
while (look_ahead_bytes > 0)
{
if (match_len > look_ahead_bytes)
match_len = look_ahead_bytes;
if (match_len <= BREAK_EVEN)
{
replace_count = 1;
WriteBit ( output, 1);
WriteBits ( output, (ulong) window [current_pos], 8);
}
else
{
WriteBit ( output, 0);
WriteBits ( output, (ulong) match_pos, INDEX_BITS);
WriteBits ( output, (ulong) ( match_len - (BREAK_EVEN + 1)),
LENGTH_BITS);
replace_count = match_len;
}
for ( i = 0; i < replace_count; i++)
{
DeleteString ( MODULO (current_pos + LOOK_AHEAD_SIZE));
if ( (c = getc (input)) == EOF )
look_ahead_bytes--;
else
window [MODULO (current_pos + LOOK_AHEAD_SIZE)] = (uchar) c;
current_pos = MODULO (current_pos + 1);
if (look_ahead_bytes)
match_len = AddString ( current_pos, &match_pos);
}
}
WriteBit ( output, 0);
WriteBits ( output, (ulong) END_OF_STREAM, INDEX_BITS);
}
/*****************************************************************************
description: encodes SBR Header information
returns: number of bits written
*****************************************************************************/
static int
encodeSbrHeader (HANDLE_SBR_HEADER_DATA sbrHeaderData,
HANDLE_SBR_BITSTREAM_DATA sbrBitstreamData,
HANDLE_COMMON_DATA cmonData,
SBR_ELEMENT_TYPE sbrElem)
{
int payloadBits = 0;
/* counting previous operation */
if (sbrBitstreamData->CRCActive) {
cmonData->sbrCrcLen = 1;
}
else {
cmonData->sbrCrcLen = 0;
}
if (sbrBitstreamData->HeaderActive) {
payloadBits += WriteBits (&cmonData->sbrBitbuf, 1, 1);
payloadBits += encodeSbrHeaderData (sbrHeaderData,
&cmonData->sbrBitbuf,
sbrElem);
}
else {
payloadBits += WriteBits (&cmonData->sbrBitbuf, 0, 1);
}
cmonData->sbrHdrBits = payloadBits;
return payloadBits;
}
/*****************************************************************************
description: encodes sbr SCE information
returns: number of bits written
*****************************************************************************/
static int
encodeSbrSingleChannelElement (HANDLE_SBR_ENV_DATA sbrEnvData,
HANDLE_BIT_BUF hBitStream,
int data_extra)
{
int payloadBits = 0;
/* counting previous operation */
payloadBits += WriteBits (hBitStream, 0, 1); /* no reserved bits */
payloadBits += encodeSbrGrid (sbrEnvData, hBitStream);
payloadBits += encodeSbrDtdf (sbrEnvData, hBitStream);
{
int i;
/* sbrEnvData->sbr_invf_mode_vec[] */
for (i = 0; i < sbrEnvData->noOfnoisebands; i++) {
payloadBits += WriteBits (hBitStream, sbrEnvData->sbr_invf_mode_vec[i], SI_SBR_INVF_MODE_BITS);
}
}
payloadBits += writeEnvelopeData (sbrEnvData, hBitStream, 0);
payloadBits += writeNoiseLevelData (sbrEnvData, hBitStream, 0);
payloadBits += writeSyntheticCodingData (sbrEnvData,hBitStream);
return payloadBits;
}
void CEncoder::WriteBytes(const Byte *data, UInt32 sizeInBits, Byte lastByte)
{
UInt32 bytesSize = (sizeInBits / 8);
for (UInt32 i = 0; i < bytesSize; i++)
m_OutStream.WriteBits(data[i], 8);
WriteBits(lastByte, (sizeInBits & 7));
}
void PanelDataWrite(StdAirDataBase *DataBase, uint16 index, uint16 Data)
{
uint08 tmptype = PanelDataStr[index][0];
uint08 tmpindex = PanelDataStr[index][1];
if (tmpindex == DEF_INDEX)
{
return;
}
tmpindex--;
if (tmptype == BITTYPE)
{
if (tmpindex < BIT_LEN_MAX)
{
WriteBits(DataBase->Solo.Bits.All, tmpindex, Data);
}
}
else if (tmptype == BYTETYPE)
{
if (tmpindex < BYTE_LEN_MAX)
{
DataBase->Solo.Bytes.All[tmpindex] = Data % 256;
}
}
else if (tmptype == WORDTYPE)
{
if (tmpindex < WORD_LEN_MAX)
{
DataBase->Solo.Words.All[tmpindex] = Data;
}
}
}
/* Guarda la tabla en formato comprimido de acuerdo a la tabla huffman */
void RecordOMTHC(unsigned char omt[NUM_BOARDS])
{
/* Archivo de salida */
FILE* comp_bin_fp;
/* i */
int i;
/* Abro el archivo */
comp_bin_fp = fopen("comp.bin", "wb");
/* Recorro la tabla */
for (i = 0; i < NUM_BOARDS; i++)
WriteBits((unsigned char)huffman_table[omt[i]][0],
huffman_table[omt[i]][1], comp_bin_fp);
/* Hago flush */
WriteBits(0, 0, comp_bin_fp);
/* Cierra el archivo */
fclose(comp_bin_fp);
}
int main(int argc, char* argv[]) {
printf("Example1: BitIO\n");
#ifdef OnOSX
signal(SIGINT, Quit); // Trap Control+C function Quit on Mac
#endif
if (!InitializeForBitIO()) {
printf("\nFT232R cable found\nLED is ");
while (1) {
WriteBits(LED_Off);
printf("Off\b\b\b");
Idle(10);
while (ReadBits() & Button) {
WriteBits(LED_On);
printf("On \b\b\b");
Idle(10);
}
}
}
Quit();
}
OSCL_EXPORT_REF void BitStreamParser::WriteUInt8(uint8 data)
{
if (bitpos != MOST_SIG_BIT)
{
WriteBits(BITS_PER_BYTE, &data);
}
else
{
if (bytepos >= (start + size))
{
OSCL_LEAVE(OsclErrOverflow);
}
*bytepos = data;
bytepos++;
}
}
/*
========================
idLZWCompressor::WriteByte
========================
*/
void idLZWCompressor::WriteByte( uint8 value ) {
int code = Lookup( lzwData->codeWord, value );
if ( code >= 0 ) {
lzwData->codeWord = code;
} else {
WriteBits( lzwData->codeWord, lzwData->codeBits );
if ( !BumpBits() ) {
AddToDict( lzwData->codeWord, value );
}
lzwData->codeWord = value;
}
if ( lzwData->bytesWritten >= maxSize - ( lzwData->codeBits + lzwData->tempBits + 7 ) / 8 ) {
overflowed = true; // At any point, if we can't perform an End call, then trigger an overflow
return;
}
}
// Write an array or casted stream
void BitStream::Write( const char* inputByteArray, const unsigned int numberOfBytes )
{
if (numberOfBytes==0)
return;
// Optimization:
if ((numberOfBitsUsed & 7) == 0)
{
AddBitsAndReallocate( BYTES_TO_BITS(numberOfBytes) );
memcpy(data+BITS_TO_BYTES(numberOfBitsUsed), inputByteArray, (size_t) numberOfBytes);
numberOfBitsUsed+=BYTES_TO_BITS(numberOfBytes);
}
else
{
WriteBits( ( unsigned char* ) inputByteArray, numberOfBytes * 8, true );
}
}
/*
========================
idLZWCompressor::End
========================
*/
int idLZWCompressor::End() {
assert( lzwData->tempBits < 8 );
assert( lzwData->bytesWritten < maxSize - ( lzwData->codeBits + lzwData->tempBits + 7 ) / 8 );
assert( ( Length() > 0 ) == ( lzwData->codeWord != -1 ) );
if ( lzwData->codeWord != -1 ) {
WriteBits( lzwData->codeWord, lzwData->codeBits );
}
if ( lzwData->tempBits > 0 ) {
if ( lzwData->bytesWritten >= maxSize ) {
overflowed = true;
return -1;
}
data[lzwData->bytesWritten++] = (uint8)lzwData->tempValue & ( ( 1 << lzwData->tempBits ) - 1 );
}
return Length() > 0 ? Length() : -1; // Total bytes written (or failure)
}
/** Set full-scale gyroscope range.
* @param range New full-scale gyroscope range value
* @see MPU6050_GetFullScaleGyroRange()
* @see MPU6050_GYRO_FS_250
* @see MPU6050_RA_GYRO_CONFIG
* @see MPU6050_GCONFIG_FS_SEL_BIT
* @see MPU6050_GCONFIG_FS_SEL_LENGTH
*/
void clMPU6050::SetFullScaleGyroRange(uint8_t range)
{
WriteBits(MPU6050_DEFAULT_ADDRESS, MPU6050_RA_GYRO_CONFIG, MPU6050_GCONFIG_FS_SEL_BIT, MPU6050_GCONFIG_FS_SEL_LENGTH, range);
// Memorize range:
float fullRangeLSB = 32768;
switch(range){
case MPU6050_GYRO_FS_250:
this->sensors.gyroScaleFactor = fullRangeLSB/250;
break;
case MPU6050_GYRO_FS_500:
this->sensors.gyroScaleFactor = fullRangeLSB/500;
break;
case MPU6050_GYRO_FS_1000:
this->sensors.gyroScaleFactor = fullRangeLSB/1000;
break;
case MPU6050_GYRO_FS_2000:
this->sensors.gyroScaleFactor = fullRangeLSB/2000;
break;
default:
// To avoid erroneous measurements, set to zero to make the error more obvious.
this->sensors.gyroScaleFactor = 0;
}
}
/** Set full-scale accelerometer range.
* @param range New full-scale accelerometer range setting
* @see MPU6050_GetFullScaleAccelRange()
*/
void clMPU6050::SetFullScaleAccelRange(uint8_t range)
{
WriteBits(MPU6050_DEFAULT_ADDRESS, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_AFS_SEL_BIT, MPU6050_ACONFIG_AFS_SEL_LENGTH, range);
// Memorize range:
float fullRangeLSB = 32768;
switch(range){
case MPU6050_ACCEL_FS_2:
this->sensors.accelerometerScaleFactor = fullRangeLSB/2.0;
break;
case MPU6050_ACCEL_FS_4:
this->sensors.accelerometerScaleFactor = fullRangeLSB/4.0;
break;
case MPU6050_ACCEL_FS_8:
this->sensors.accelerometerScaleFactor = fullRangeLSB/8.0;
break;
case MPU6050_ACCEL_FS_16:
this->sensors.accelerometerScaleFactor = fullRangeLSB/16.0;
break;
default:
// To avoid erroneous measurements:
this->sensors.accelerometerScaleFactor = 0;
}
}
static int
appendBitstream( HANDLE_BIT_BUF hBitBufWrite,
HANDLE_BIT_BUF hBitBufRead,
int nBits )
{
int i;
unsigned b;
COUNT_sub_start("appendBitstream");
LOOP(1);
for (i=0; i< nBits; i++)
{
FUNC(2);
b = ReadBits (hBitBufRead, 1);
FUNC(3);
WriteBits (hBitBufWrite, b, 1);
}
COUNT_sub_end();
return nBits;
}
WorldPacket const* WorldPackets::CombatLog::SpellNonMeleeDamageLog::Write()
{
*this << Me;
*this << CasterGUID;
*this << CastID;
*this << int32(SpellID);
*this << int32(Damage);
*this << int32(Overkill);
*this << uint8(SchoolMask);
*this << int32(ShieldBlock);
*this << int32(Resisted);
*this << int32(Absorbed);
WriteBit(Periodic);
WriteBits(Flags, 7);
WriteBit(false); // Debug info
WriteLogDataBit();
WriteBit(SandboxScaling.is_initialized());
FlushBits();
WriteLogData();
if (SandboxScaling)
*this << *SandboxScaling;
return &_worldPacket;
}
/*****************************************************************************
description: Encode SBR grid information
*****************************************************************************/
static int
encodeSbrGrid (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_BIT_BUF hBitStream)
{
int payloadBits = 0;
int i, temp;
/* counting previous operations */
payloadBits += WriteBits (hBitStream, sbrEnvData->hSbrBSGrid->frameClass,
SBR_CLA_BITS);
switch (sbrEnvData->hSbrBSGrid->frameClass) {
case FIXFIX:
temp = ceil_ln2(sbrEnvData->hSbrBSGrid->bs_num_env);
payloadBits += WriteBits (hBitStream, temp, SBR_ENV_BITS);
payloadBits += WriteBits (hBitStream, sbrEnvData->freq_res_fixfix, SBR_RES_BITS);
break;
case FIXVAR:
case VARFIX:
if (sbrEnvData->hSbrBSGrid->frameClass == FIXVAR)
{
temp = sbrEnvData->hSbrBSGrid->bs_abs_bord - 16;
}
else
{
temp = sbrEnvData->hSbrBSGrid->bs_abs_bord;
}
payloadBits += WriteBits (hBitStream, temp, SBR_ABS_BITS);
payloadBits += WriteBits (hBitStream, sbrEnvData->hSbrBSGrid->n, SBR_NUM_BITS);
/* sbrEnvData->hSbrBSGrid->bs_rel_bord[] */
for (i = 0; i < sbrEnvData->hSbrBSGrid->n; i++) {
temp = (sbrEnvData->hSbrBSGrid->bs_rel_bord[i] - 2) >> 1;
payloadBits += WriteBits (hBitStream, temp, SBR_REL_BITS);
}
temp = ceil_ln2(sbrEnvData->hSbrBSGrid->n + 2);
payloadBits += WriteBits (hBitStream, sbrEnvData->hSbrBSGrid->p, temp);
/* sbrEnvData->hSbrBSGrid->v_f[] */
for (i = 0; i < sbrEnvData->hSbrBSGrid->n + 1; i++) {
payloadBits += WriteBits (hBitStream, sbrEnvData->hSbrBSGrid->v_f[i],
SBR_RES_BITS);
}
break;
case VARVAR:
temp = sbrEnvData->hSbrBSGrid->bs_abs_bord_0;
payloadBits += WriteBits (hBitStream, temp, SBR_ABS_BITS);
temp = sbrEnvData->hSbrBSGrid->bs_abs_bord_1 - 16;
payloadBits += WriteBits (hBitStream, temp, SBR_ABS_BITS);
payloadBits += WriteBits (hBitStream, sbrEnvData->hSbrBSGrid->bs_num_rel_0, SBR_NUM_BITS);
payloadBits += WriteBits (hBitStream, sbrEnvData->hSbrBSGrid->bs_num_rel_1, SBR_NUM_BITS);
/* sbrEnvData->hSbrBSGrid->bs_rel_bord_0[] */
for (i = 0; i < sbrEnvData->hSbrBSGrid->bs_num_rel_0; i++) {
temp = (sbrEnvData->hSbrBSGrid->bs_rel_bord_0[i] - 2) >> 1;
payloadBits += WriteBits (hBitStream, temp, SBR_REL_BITS);
}
/* sbrEnvData->hSbrBSGrid->bs_rel_bord_1[] */
for (i = 0; i < sbrEnvData->hSbrBSGrid->bs_num_rel_1; i++) {
temp = (sbrEnvData->hSbrBSGrid->bs_rel_bord_1[i] - 2) >> 1;
payloadBits += WriteBits (hBitStream, temp, SBR_REL_BITS);
}
temp = ceil_ln2(sbrEnvData->hSbrBSGrid->bs_num_rel_0 +
sbrEnvData->hSbrBSGrid->bs_num_rel_1 + 2);
payloadBits += WriteBits (hBitStream, sbrEnvData->hSbrBSGrid->p, temp);
temp = sbrEnvData->hSbrBSGrid->bs_num_rel_0 +
sbrEnvData->hSbrBSGrid->bs_num_rel_1 + 1;
/* sbrEnvData->hSbrBSGrid->v_fLR[] */
for (i = 0; i < temp; i++) {
payloadBits += WriteBits (hBitStream, sbrEnvData->hSbrBSGrid->v_fLR[i],
SBR_RES_BITS);
}
break;
}
return payloadBits;
}
/*****************************************************************************
description: encodes sbr CPE information
*****************************************************************************/
static int
encodeSbrChannelPairElement (HANDLE_SBR_ENV_DATA sbrEnvDataLeft,
HANDLE_SBR_ENV_DATA sbrEnvDataRight,
HANDLE_BIT_BUF hBitStream,
int data_extra,
int coupling)
{
int payloadBits = 0;
int i = 0;
/* counting previous operation */
payloadBits += WriteBits (hBitStream, 0, 1); /* no reserved bits */
payloadBits += WriteBits (hBitStream, coupling, SI_SBR_COUPLING_BITS);
if (coupling) {
payloadBits += encodeSbrGrid (sbrEnvDataLeft, hBitStream);
payloadBits += encodeSbrDtdf (sbrEnvDataLeft, hBitStream);
payloadBits += encodeSbrDtdf (sbrEnvDataRight, hBitStream);
/* sbrEnvDataLeft->sbr_invf_mode_vec[] */
for (i = 0; i < sbrEnvDataLeft->noOfnoisebands; i++) {
payloadBits += WriteBits (hBitStream, sbrEnvDataLeft->sbr_invf_mode_vec[i], SI_SBR_INVF_MODE_BITS);
}
payloadBits += writeEnvelopeData (sbrEnvDataLeft, hBitStream,1);
payloadBits += writeNoiseLevelData (sbrEnvDataLeft, hBitStream,1);
payloadBits += writeEnvelopeData (sbrEnvDataRight, hBitStream,1);
payloadBits += writeNoiseLevelData (sbrEnvDataRight, hBitStream,1);
payloadBits += writeSyntheticCodingData (sbrEnvDataLeft,hBitStream);
payloadBits += writeSyntheticCodingData (sbrEnvDataRight,hBitStream);
} else { /* no coupling */
payloadBits += encodeSbrGrid (sbrEnvDataLeft, hBitStream);
payloadBits += encodeSbrGrid (sbrEnvDataRight, hBitStream);
payloadBits += encodeSbrDtdf (sbrEnvDataLeft, hBitStream);
payloadBits += encodeSbrDtdf (sbrEnvDataRight, hBitStream);
/* sbrEnvDataLeft->sbr_invf_mode_vec[] */
for (i = 0; i < sbrEnvDataLeft->noOfnoisebands; i++) {
payloadBits += WriteBits (hBitStream, sbrEnvDataLeft->sbr_invf_mode_vec[i],
SI_SBR_INVF_MODE_BITS);
}
/* sbrEnvDataRight->sbr_invf_mode_vec[] */
for (i = 0; i < sbrEnvDataRight->noOfnoisebands; i++) {
payloadBits += WriteBits (hBitStream, sbrEnvDataRight->sbr_invf_mode_vec[i],
SI_SBR_INVF_MODE_BITS);
}
payloadBits += writeEnvelopeData (sbrEnvDataLeft, hBitStream,0);
payloadBits += writeEnvelopeData (sbrEnvDataRight, hBitStream,0);
payloadBits += writeNoiseLevelData (sbrEnvDataLeft, hBitStream,0);
payloadBits += writeNoiseLevelData (sbrEnvDataRight, hBitStream,0);
payloadBits += writeSyntheticCodingData (sbrEnvDataLeft,hBitStream);
payloadBits += writeSyntheticCodingData (sbrEnvDataRight,hBitStream);
} /* coupling */
return payloadBits;
}
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;
}
/*****************************************************************************
functionname: encodeSbrHeaderData
description: writes sbr_header()
returns: number of bits written
*****************************************************************************/
static int
encodeSbrHeaderData (HANDLE_SBR_HEADER_DATA sbrHeaderData,
HANDLE_BIT_BUF hBitStream,
SBR_ELEMENT_TYPE sbrElem)
{
int payloadBits = 0;
/* counting previous operation */
if (sbrHeaderData != NULL) {
payloadBits += WriteBits (hBitStream, sbrHeaderData->sbr_amp_res,
SI_SBR_AMP_RES_BITS);
payloadBits += WriteBits (hBitStream, sbrHeaderData->sbr_start_frequency,
SI_SBR_START_FREQ_BITS);
payloadBits += WriteBits (hBitStream, sbrHeaderData->sbr_stop_frequency,
SI_SBR_STOP_FREQ_BITS);
payloadBits += WriteBits (hBitStream, sbrHeaderData->sbr_xover_band,
SI_SBR_XOVER_BAND_BITS);
payloadBits += WriteBits (hBitStream, 0,
SI_SBR_RESERVED_BITS);
payloadBits += WriteBits (hBitStream, sbrHeaderData->header_extra_1,
SI_SBR_HEADER_EXTRA_1_BITS);
payloadBits += WriteBits (hBitStream, sbrHeaderData->header_extra_2,
SI_SBR_HEADER_EXTRA_2_BITS);
if (sbrHeaderData->header_extra_1) {
payloadBits += WriteBits (hBitStream, sbrHeaderData->freqScale,
SI_SBR_FREQ_SCALE_BITS);
payloadBits += WriteBits (hBitStream, sbrHeaderData->alterScale,
SI_SBR_ALTER_SCALE_BITS);
payloadBits += WriteBits (hBitStream, sbrHeaderData->sbr_noise_bands,
SI_SBR_NOISE_BANDS_BITS);
} /* sbrHeaderData->header_extra_1 */
if (sbrHeaderData->header_extra_2) {
payloadBits += WriteBits (hBitStream, sbrHeaderData->sbr_limiter_bands,
SI_SBR_LIMITER_BANDS_BITS);
payloadBits += WriteBits (hBitStream, sbrHeaderData->sbr_limiter_gains,
SI_SBR_LIMITER_GAINS_BITS);
payloadBits += WriteBits (hBitStream, sbrHeaderData->sbr_interpol_freq,
SI_SBR_INTERPOL_FREQ_BITS);
payloadBits += WriteBits (hBitStream, sbrHeaderData->sbr_smoothing_length,
SI_SBR_SMOOTHING_LENGTH_BITS);
} /* sbrHeaderData->header_extra_2 */
} /* sbrHeaderData != NULL */
return payloadBits;
}
void CEncoder::WriteBit(bool v) { WriteBits((v ? 1 : 0), 1); }
/*****************************************************************************
description: writes bits corresponding to the extended data
returns: number of bits written
*****************************************************************************/
static void
encodeExtendedData (HANDLE_SBR_ENV_DATA sbrEnvDataLeft,
HANDLE_SBR_ENV_DATA sbrEnvDataRight,
struct PS_ENC* h_ps_e,
int bHeaderActive,
HANDLE_BIT_BUF hBitStreamPrev,
int *sbrHdrBits,
HANDLE_BIT_BUF hBitStream,
int* payloadBitsReturn)
{
int extDataSize;
int payloadBitsIn = *payloadBitsReturn;
int payloadBits = 0;
/* counting previous operations */
extDataSize = getSbrExtendedDataSize(sbrEnvDataLeft,
sbrEnvDataRight,
h_ps_e,
bHeaderActive
);
if (extDataSize != 0) {
#ifndef MONO_ONLY
if (h_ps_e && AppendPsBS (h_ps_e, NULL, NULL, 0)) {
*payloadBitsReturn = AppendPsBS (h_ps_e, hBitStream, hBitStreamPrev, sbrHdrBits);
}
else {
#endif /*#ifndef MONO_ONLY */
int maxExtSize = (1<<SI_SBR_EXTENSION_SIZE_BITS) - 1;
/* counting previous operation */
payloadBits += WriteBits (hBitStream, 1, SI_SBR_EXTENDED_DATA_BITS);
assert(extDataSize <= SBR_EXTENDED_DATA_MAX_CNT);
if (extDataSize < maxExtSize) {
payloadBits += WriteBits (hBitStream, extDataSize, SI_SBR_EXTENSION_SIZE_BITS);
} else {
payloadBits += WriteBits (hBitStream, maxExtSize, SI_SBR_EXTENSION_SIZE_BITS);
payloadBits += WriteBits (hBitStream, extDataSize - maxExtSize, SI_SBR_EXTENSION_ESC_COUNT_BITS);
}
*payloadBitsReturn = payloadBits + payloadBitsIn;
#ifndef MONO_ONLY
}
#endif /*#ifndef MONO_ONLY */
}
else {
payloadBits += WriteBits (hBitStream, 0, SI_SBR_EXTENDED_DATA_BITS);
*payloadBitsReturn = payloadBits + payloadBitsIn;
}
}
/*****************************************************************************
description: writes bits corresponding to the envelope data
returns: number of bits written
*****************************************************************************/
static int
writeEnvelopeData (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_BIT_BUF hBitStream, int coupling)
{
int payloadBits = 0, j, i, delta;
/* sbrEnvData->domain_vec[]
sbrEnvData->ienvelope[][]
sbrEnvData->noScfBands[]
*/
for (j = 0; j < sbrEnvData->noOfEnvelopes; j++) { /* loop over all envelopes */
if (sbrEnvData->domain_vec[j] == FREQ) {
if (coupling && sbrEnvData->balance) {
payloadBits += WriteBits (hBitStream, sbrEnvData->ienvelope[j][0], sbrEnvData->si_sbr_start_env_bits_balance);
} else {
payloadBits += WriteBits (hBitStream, sbrEnvData->ienvelope[j][0], sbrEnvData->si_sbr_start_env_bits);
}
}
for (i = 1 - sbrEnvData->domain_vec[j]; i < sbrEnvData->noScfBands[j]; i++) {
delta = sbrEnvData->ienvelope[j][i];
if (coupling && sbrEnvData->balance) {
assert (abs (delta) <= sbrEnvData->codeBookScfLavBalance);
} else {
assert (abs (delta) <= sbrEnvData->codeBookScfLav);
}
if (coupling) {
if (sbrEnvData->balance) {
if (sbrEnvData->domain_vec[j]) {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableBalanceTimeC[delta + sbrEnvData->codeBookScfLavBalance],
sbrEnvData->hufftableBalanceTimeL[delta + sbrEnvData->codeBookScfLavBalance]);
} else {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableBalanceFreqC[delta + sbrEnvData->codeBookScfLavBalance],
sbrEnvData->hufftableBalanceFreqL[delta + sbrEnvData->codeBookScfLavBalance]);
}
} else {
if (sbrEnvData->domain_vec[j]) {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableLevelTimeC[delta + sbrEnvData->codeBookScfLav],
sbrEnvData->hufftableLevelTimeL[delta + sbrEnvData->codeBookScfLav]);
} else {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableLevelFreqC[delta + sbrEnvData->codeBookScfLav],
sbrEnvData->hufftableLevelFreqL[delta + sbrEnvData->codeBookScfLav]);
}
}
} else {
if (sbrEnvData->domain_vec[j]) {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableTimeC[delta + sbrEnvData->codeBookScfLav],
sbrEnvData->hufftableTimeL[delta + sbrEnvData->codeBookScfLav]);
} else {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableFreqC[delta + sbrEnvData->codeBookScfLav],
sbrEnvData->hufftableFreqL[delta + sbrEnvData->codeBookScfLav]);
}
}
}
}
return payloadBits;
}
/** Set clock source setting.
* An internal 8MHz oscillator, gyroscope based clock, or external sources can
* be selected as the MPU-60X0 clock source. When the internal 8 MHz oscillator
* or an external source is chosen as the clock source, the MPU-60X0 can operate
* in low power modes with the gyroscopes disabled.
*
* Upon power up, the MPU-60X0 clock source defaults to the internal oscillator.
* However, it is highly recommended that the device be configured to use one of
* the gyroscopes (or an external clock source) as the clock reference for
* improved stability. The clock source can be selected according to the following table:
*
* <pre>
* CLK_SEL | Clock Source
* --------+--------------------------------------
* 0 | Internal oscillator
* 1 | PLL with X Gyro reference
* 2 | PLL with Y Gyro reference
* 3 | PLL with Z Gyro reference
* 4 | PLL with external 32.768kHz reference
* 5 | PLL with external 19.2MHz reference
* 6 | Reserved
* 7 | Stops the clock and keeps the timing generator in reset
* </pre>
*
* @param source New clock source setting
* @see MPU6050_GetClockSource()
* @see MPU6050_RA_PWR_MGMT_1
* @see MPU6050_PWR1_CLKSEL_BIT
* @see MPU6050_PWR1_CLKSEL_LENGTH
*/
void clMPU6050::SetClockSource(uint8_t source)
{
WriteBits(MPU6050_DEFAULT_ADDRESS, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_CLKSEL_BIT, MPU6050_PWR1_CLKSEL_LENGTH, source);
}
// writes SV7-header
void
WriteHeader_SV7 ( const unsigned int MaxBand,
const unsigned int Profile,
const unsigned int MS_on,
const Uint32_t TotalFrames,
const unsigned int SamplesRest,
const unsigned int StreamVersion,
const unsigned int SampleFreq )
{
WriteBits ( StreamVersion, 8 ); // StreamVersion
WriteBits ( 0x2B504D , 24 ); // Magic Number "MP+"
WriteBits ( TotalFrames , 32 ); // # of frames
WriteBits ( 0 , 1 ); // former IS-Flag (not supported anymore)
WriteBits ( MS_on , 1 ); // MS-Coding Flag
WriteBits ( MaxBand , 6 ); // Bandwidth
#if 0
if ( MPPENC_VERSION [3] & 1 )
WriteBits ( 1 , 4 ); // 1: Experimental profile
else
#endif
WriteBits ( Profile , 4 ); // 5...15: below Telephone...above BrainDead
WriteBits ( 0 , 2 ); // for future use
switch ( SampleFreq ) {
case 44100: WriteBits ( 0, 2 ); break;
case 48000: WriteBits ( 1, 2 ); break;
case 37800: WriteBits ( 2, 2 ); break;
case 32000: WriteBits ( 3, 2 ); break;
default : stderr_printf ( "Internal error\n");
exit (1);
}
WriteBits ( 0 , 16 ); // maximum input sample value, currently filled by replaygain
WriteBits ( 0 , 32 ); // title based gain controls, currently filled by replaygain
WriteBits ( 0 , 32 ); // album based gain controls, currently filled by replaygain
WriteBits ( 1 , 1 ); // true gapless: used?
WriteBits ( SamplesRest , 11 ); // true gapless: valid samples in last frame
WriteBits ( 1 , 1 ); // we now support fast seeking
WriteBits ( 0 , 19 );
WriteBits ( (MPPENC_VERSION[0]&15)*100 + (MPPENC_VERSION[2]&15)*10 + (MPPENC_VERSION[3]&15),
8 ); // for future use
}
/*!
\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();
}
/*****************************************************************************
description: writes bits corresponding to the noise-floor-level
returns: number of bits written
*****************************************************************************/
static int
writeNoiseLevelData (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_BIT_BUF hBitStream, int coupling)
{
int j, i, payloadBits = 0;
int nNoiseEnvelopes = ((sbrEnvData->noOfEnvelopes > 1) ? 2 : 1);
/* .. > .. ? */
/* sbrEnvData->domain_vec_noise[]
sbrEnvData->sbr_noise_levels[i * sbrEnvData->noOfnoisebands]
*/
for (i = 0; i < nNoiseEnvelopes; i++) {
switch (sbrEnvData->domain_vec_noise[i]) {
case FREQ:
if (coupling && sbrEnvData->balance) {
payloadBits += WriteBits (hBitStream,
sbrEnvData->sbr_noise_levels[i * sbrEnvData->noOfnoisebands],
sbrEnvData->si_sbr_start_noise_bits_balance);
} else {
payloadBits += WriteBits (hBitStream,
sbrEnvData->sbr_noise_levels[i * sbrEnvData->noOfnoisebands],
sbrEnvData->si_sbr_start_noise_bits);
}
/* sbrEnvData->sbr_noise_levels[] */
for (j = 1 + i * sbrEnvData->noOfnoisebands; j < (sbrEnvData->noOfnoisebands * (1 + i)); j++) {
if (coupling) {
if (sbrEnvData->balance) {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableNoiseBalanceFreqC[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV_BALANCE11],
sbrEnvData->hufftableNoiseBalanceFreqL[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV_BALANCE11]);
} else {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableNoiseLevelFreqC[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV11],
sbrEnvData->hufftableNoiseLevelFreqL[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV11]);
}
} else {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableNoiseFreqC[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV11],
sbrEnvData->hufftableNoiseFreqL[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV11]);
}
}
break;
case TIME:
/* sbrEnvData->sbr_noise_levels[] */
for (j = i * sbrEnvData->noOfnoisebands; j < (sbrEnvData->noOfnoisebands * (1 + i)); j++) {
if (coupling) {
if (sbrEnvData->balance) {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableNoiseBalanceTimeC[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV_BALANCE11],
sbrEnvData->hufftableNoiseBalanceTimeL[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV_BALANCE11]);
} else {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableNoiseLevelTimeC[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV11],
sbrEnvData->hufftableNoiseLevelTimeL[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV11]);
}
} else {
payloadBits += WriteBits (hBitStream,
sbrEnvData->hufftableNoiseLevelTimeC[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV11],
sbrEnvData->hufftableNoiseLevelTimeL[sbrEnvData->sbr_noise_levels[j] +
CODE_BOOK_SCF_LAV11]);
}
}
break;
}
}
return payloadBits;
}
int
WritePsData (HANDLE_PS_ENC h_ps_e,
int bHeaderActive)
{
int temp, gr;
const int *aaHuffBookIidC;
const short *aaHuffBookIccC;
const char *aaHuffBookIidL;
const char *aaHuffBookIccL;
int *aaDeltaIid;
int *aaDeltaIcc;
int index, lastIndex;
int noBitsF = 0;
int noBitsT = 0;
int aaDeltaIidT[NO_IID_BINS];
int aaDeltaIccT[NO_ICC_BINS];
int aaDeltaIidF[NO_IID_BINS];
int aaDeltaIccF[NO_ICC_BINS];
int abDtFlagIid;
int abDtFlagIcc;
int bSendHeader;
unsigned int bZeroIid = 1;
unsigned int bZeroIcc = 1;
unsigned int bKeepParams = 1;
HANDLE_BIT_BUF bb = &h_ps_e->psBitBuf;
COUNT_sub_start("WritePsData");
INDIRECT(1); MOVE(6); PTR_INIT(1); /* counting previous operations */
FUNC(1);
temp = GetBitsAvail(bb);
/* bit buffer shall be empty */
BRANCH(1);
if (temp != 0)
{
COUNT_sub_end();
return -1;
}
BRANCH(1);
if (bHeaderActive) {
MOVE(1);
bKeepParams = 0;
}
MOVE(1);
lastIndex = 0;
PTR_INIT(3); /* h_ps_e->aaaIIDDataBuffer[][]
h_ps_e->aaaICCDataBuffer[][]
h_ps_e->aLastIidIndex[]
*/
INDIRECT(1); LOOP(1);
for (gr = 0; gr < h_ps_e->iidIccBins; gr++) {
float panValue = h_ps_e->aaaIIDDataBuffer[gr][SYSTEMLOOKAHEAD];
MOVE(1); /* counting previous operation */
ADD(2); BRANCH(1);
if (panValue >= -panClass[0] &&
panValue <= panClass[0]) {
MOVE(1);
index = 0;
}
else {
BRANCH(1);
if (panValue < 0) {
PTR_INIT(1); /* panClass[] */
LOOP(1);
for (index = NO_IID_STEPS-1; panValue > -panClass[index]; index--) {
ADD(1); /* for() condition */
}
ADD(1);
index = -index - 1;
}
else {
PTR_INIT(1); /* panClass[] */
LOOP(1);
for (index = NO_IID_STEPS-1; panValue < panClass[index]; index--) {
ADD(1); /* for() condition */
}
ADD(1);
index++;
}
MOVE(1);
bZeroIid = 0;
}
BRANCH(1);
if (gr == 0) {
MOVE(2);
aaDeltaIidF[gr] = index;
noBitsT = 0;
INDIRECT(1); MOVE(1);
noBitsF = aBookPsIidFreqLength[index + CODE_BOOK_LAV_IID];
}
else {
ADD(1); STORE(1);
aaDeltaIidF[gr] = index - lastIndex;
INDIRECT(1); ADD(1);
noBitsF += aBookPsIidFreqLength[aaDeltaIidF[gr] + CODE_BOOK_LAV_IID];
}
MOVE(1);
lastIndex = index;
ADD(1); STORE(1);
aaDeltaIidT[gr] = index - h_ps_e->aLastIidIndex[gr];
MOVE(1);
h_ps_e->aLastIidIndex[gr] = index;
INDIRECT(1); ADD(1);
noBitsT += aBookPsIidTimeLength[aaDeltaIidT[gr] + CODE_BOOK_LAV_IID];
BRANCH(1);
if (aaDeltaIidT[gr] != 0) {
MOVE(1);
bKeepParams = 0;
}
} /* gr */
ADD(1); LOGIC(1); BRANCH(1);
if (noBitsT < noBitsF && !bHeaderActive) {
MOVE(4);
abDtFlagIid = 1;
aaDeltaIid = aaDeltaIidT;
aaHuffBookIidC = aBookPsIidTimeCode;
aaHuffBookIidL = aBookPsIidTimeLength;
}
else {
MOVE(4);
abDtFlagIid = 0;
aaDeltaIid = aaDeltaIidF;
aaHuffBookIidC = aBookPsIidFreqCode;
aaHuffBookIidL = aBookPsIidFreqLength;
}
MOVE(1);
lastIndex = 0;
PTR_INIT(4); /* h_ps_e->aaaICCDataBuffer[][]
h_ps_e->aLastIccIndex[]
aaDeltaIccF[]
aaDeltaIccT[]
*/
INDIRECT(1); LOOP(1);
for (gr = 0; gr < h_ps_e->iidIccBins; gr++) {
float saValue = h_ps_e->aaaICCDataBuffer[gr][SYSTEMLOOKAHEAD];
MOVE(1); /* counting previous operation */
ADD(1); BRANCH(1);
if (saValue <= saClass[0]) {
MOVE(1);
index = 0;
}
else {
PTR_INIT(1); /* saClass[] */
LOOP(1);
for (index = NO_ICC_STEPS-2; saValue < saClass[index]; index--) {
ADD(1); /* for() condition */
}
ADD(1);
index++;
MOVE(1);
bZeroIcc = 0;
}
BRANCH(1);
if (gr == 0) {
MOVE(1);
aaDeltaIccF[gr] = index;
INDIRECT(1); MOVE(1);
noBitsF = aBookPsIccFreqLength[index + CODE_BOOK_LAV_ICC];
MOVE(1);
noBitsT = 0;
}
else {
ADD(1); STORE(1);
aaDeltaIccF[gr] = index - lastIndex;
INDIRECT(1); ADD(1);
noBitsF += aBookPsIccFreqLength[aaDeltaIccF[gr] + CODE_BOOK_LAV_ICC];
}
MOVE(1);
lastIndex = index;
ADD(1); STORE(1);
aaDeltaIccT[gr] = index - h_ps_e->aLastIccIndex[gr];
MOVE(1);
h_ps_e->aLastIccIndex[gr] = index;
INDIRECT(1); ADD(1);
noBitsT += aBookPsIccTimeLength[aaDeltaIccT[gr] + CODE_BOOK_LAV_ICC];
BRANCH(1);
if (aaDeltaIccT[gr] != 0) {
MOVE(1);
bKeepParams = 0;
}
} /* gr */
ADD(1); LOGIC(1); BRANCH(1);
if (noBitsT < noBitsF && !bHeaderActive) {
MOVE(4);
abDtFlagIcc = 1;
aaDeltaIcc = aaDeltaIccT;
aaHuffBookIccC = aBookPsIccTimeCode;
aaHuffBookIccL = aBookPsIccTimeLength;
}
else {
MOVE(4);
abDtFlagIcc = 0;
aaDeltaIcc = aaDeltaIccF;
aaHuffBookIccC = aBookPsIccFreqCode;
aaHuffBookIccL = aBookPsIccFreqLength;
}
{
static __thread int initheader = 0;
MOVE(1); /* counting previous operation */
LOGIC(1); BRANCH(1);
if (!initheader || bHeaderActive) {
INDIRECT(1); MOVE(2);
initheader = 1;
h_ps_e->bEnableHeader = 1;
}
else {
INDIRECT(1); MOVE(1);
h_ps_e->bEnableHeader = 0;
}
}
INDIRECT(3); ADD(2); LOGIC(2);
bSendHeader = h_ps_e->bEnableHeader ||
h_ps_e->bPrevZeroIid != bZeroIid ||
h_ps_e->bPrevZeroIcc != bZeroIcc;
FUNC(3);
WriteBits (bb, bSendHeader, 1);
BRANCH(1);
if (bSendHeader) {
LOGIC(1); FUNC(3);
WriteBits (bb, !bZeroIid, 1);
BRANCH(1);
if (!bZeroIid)
{
BRANCH(1); FUNC(3);
WriteBits (bb, (h_ps_e->bHiFreqResIidIcc)?1:0, 3);
}
LOGIC(1); FUNC(3);
WriteBits (bb, !bZeroIcc, 1);
BRANCH(1);
if (!bZeroIcc)
{
BRANCH(1); FUNC(3);
WriteBits (bb, (h_ps_e->bHiFreqResIidIcc)?1:0, 3);
}
FUNC(3);
WriteBits (bb, 0, 1);
}
FUNC(3);
WriteBits (bb, 0, 1);
ADD(1); FUNC(3);
WriteBits (bb, 1-bKeepParams, 2);
PTR_INIT(1); /* h_ps_e->iidIccBins
*/
BRANCH(1);
if (!bKeepParams) {
LOGIC(1); BRANCH(1);
if (!bZeroIid) {
FUNC(3);
WriteBits (bb, abDtFlagIid, 1);
LOOP(1);
for (gr = 0; gr < h_ps_e->iidIccBins; gr++) {
INDIRECT(2); FUNC(3);
WriteBits (bb,
aaHuffBookIidC[aaDeltaIid[gr] + CODE_BOOK_LAV_IID],
aaHuffBookIidL[aaDeltaIid[gr] + CODE_BOOK_LAV_IID]);
} /* gr */
} /* if (!bZeroIid) */
}
PTR_INIT(1); /* h_ps_e->iidIccBins
*/
BRANCH(1);
if (!bKeepParams) {
LOGIC(1); BRANCH(1);
if (!bZeroIcc) {
FUNC(3);
WriteBits (bb, abDtFlagIcc, 1);
LOOP(1);
for (gr = 0; gr < h_ps_e->iidIccBins; gr++) {
INDIRECT(2); FUNC(3);
WriteBits (bb,
aaHuffBookIccC[aaDeltaIcc[gr] + CODE_BOOK_LAV_ICC],
aaHuffBookIccL[aaDeltaIcc[gr] + CODE_BOOK_LAV_ICC]);
} /* gr */
} /* if (!bZeroIcc) */
}
INDIRECT(2); MOVE(2);
h_ps_e->bPrevZeroIid = bZeroIid;
h_ps_e->bPrevZeroIcc = bZeroIcc;
FUNC(1); /* counting post-operation */
COUNT_sub_end();
return GetBitsAvail(bb);
} /* writePsData */
void CEncoder::WriteByte(Byte b) { WriteBits(b , 8); }
