You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
258 lines
9.0 KiB
258 lines
9.0 KiB
/****************************************************************************** |
|
* |
|
* Copyright (C) 1999-2012 Broadcom Corporation |
|
* |
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
|
* you may not use this file except in compliance with the License. |
|
* You may obtain a copy of the License at: |
|
* |
|
* http://www.apache.org/licenses/LICENSE-2.0 |
|
* |
|
* Unless required by applicable law or agreed to in writing, software |
|
* distributed under the License is distributed on an "AS IS" BASIS, |
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
* See the License for the specific language governing permissions and |
|
* limitations under the License. |
|
* |
|
******************************************************************************/ |
|
|
|
/****************************************************************************** |
|
* |
|
* contains code for encoder flow and initalization of encoder |
|
* |
|
******************************************************************************/ |
|
|
|
#include "sbc_encoder.h" |
|
#include <string.h> |
|
#include "bt_target.h" |
|
#include "sbc_enc_func_declare.h" |
|
|
|
int16_t EncMaxShiftCounter; |
|
|
|
#if (SBC_JOINT_STE_INCLUDED == TRUE) |
|
int32_t s32LRDiff[SBC_MAX_NUM_OF_BLOCKS] = {0}; |
|
int32_t s32LRSum[SBC_MAX_NUM_OF_BLOCKS] = {0}; |
|
#endif |
|
|
|
uint32_t SBC_Encode(SBC_ENC_PARAMS* pstrEncParams, int16_t* input, |
|
uint8_t* output) { |
|
int32_t s32Ch; /* counter for ch*/ |
|
int32_t s32Sb; /* counter for sub-band*/ |
|
uint32_t u32Count, maxBit = 0; /* loop count*/ |
|
int32_t s32MaxValue; /* temp variable to store max value */ |
|
|
|
int16_t* ps16ScfL; |
|
int32_t* SbBuffer; |
|
int32_t s32Blk; /* counter for block*/ |
|
int32_t s32NumOfBlocks = pstrEncParams->s16NumOfBlocks; |
|
#if (SBC_JOINT_STE_INCLUDED == TRUE) |
|
int32_t s32MaxValue2; |
|
uint32_t u32CountSum, u32CountDiff; |
|
int32_t *pSum, *pDiff; |
|
#endif |
|
register int32_t s32NumOfSubBands = pstrEncParams->s16NumOfSubBands; |
|
|
|
/* SBC ananlysis filter*/ |
|
if (s32NumOfSubBands == 4) |
|
SbcAnalysisFilter4(pstrEncParams, input); |
|
else |
|
SbcAnalysisFilter8(pstrEncParams, input); |
|
|
|
/* compute the scale factor, and save the max */ |
|
ps16ScfL = pstrEncParams->as16ScaleFactor; |
|
s32Ch = pstrEncParams->s16NumOfChannels * s32NumOfSubBands; |
|
|
|
for (s32Sb = 0; s32Sb < s32Ch; s32Sb++) { |
|
SbBuffer = pstrEncParams->s32SbBuffer + s32Sb; |
|
s32MaxValue = 0; |
|
for (s32Blk = s32NumOfBlocks; s32Blk > 0; s32Blk--) { |
|
if (s32MaxValue < abs32(*SbBuffer)) s32MaxValue = abs32(*SbBuffer); |
|
SbBuffer += s32Ch; |
|
} |
|
|
|
u32Count = (s32MaxValue > 0x800000) ? 9 : 0; |
|
|
|
for (; u32Count < 15; u32Count++) { |
|
if (s32MaxValue <= (int32_t)(0x8000 << u32Count)) break; |
|
} |
|
*ps16ScfL++ = (int16_t)u32Count; |
|
|
|
if (u32Count > maxBit) maxBit = u32Count; |
|
} |
|
/* In case of JS processing,check whether to use JS */ |
|
#if (SBC_JOINT_STE_INCLUDED == TRUE) |
|
if (pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO) { |
|
/* Calculate sum and differance scale factors for making JS decision */ |
|
ps16ScfL = pstrEncParams->as16ScaleFactor; |
|
/* calculate the scale factor of Joint stereo max sum and diff */ |
|
for (s32Sb = 0; s32Sb < s32NumOfSubBands - 1; s32Sb++) { |
|
SbBuffer = pstrEncParams->s32SbBuffer + s32Sb; |
|
s32MaxValue2 = 0; |
|
s32MaxValue = 0; |
|
pSum = s32LRSum; |
|
pDiff = s32LRDiff; |
|
for (s32Blk = 0; s32Blk < s32NumOfBlocks; s32Blk++) { |
|
*pSum = (*SbBuffer + *(SbBuffer + s32NumOfSubBands)) >> 1; |
|
if (abs32(*pSum) > s32MaxValue) s32MaxValue = abs32(*pSum); |
|
pSum++; |
|
*pDiff = (*SbBuffer - *(SbBuffer + s32NumOfSubBands)) >> 1; |
|
if (abs32(*pDiff) > s32MaxValue2) s32MaxValue2 = abs32(*pDiff); |
|
pDiff++; |
|
SbBuffer += s32Ch; |
|
} |
|
u32Count = (s32MaxValue > 0x800000) ? 9 : 0; |
|
for (; u32Count < 15; u32Count++) { |
|
if (s32MaxValue <= (int32_t)(0x8000 << u32Count)) break; |
|
} |
|
u32CountSum = u32Count; |
|
u32Count = (s32MaxValue2 > 0x800000) ? 9 : 0; |
|
for (; u32Count < 15; u32Count++) { |
|
if (s32MaxValue2 <= (int32_t)(0x8000 << u32Count)) break; |
|
} |
|
u32CountDiff = u32Count; |
|
if ((*ps16ScfL + *(ps16ScfL + s32NumOfSubBands)) > |
|
(int16_t)(u32CountSum + u32CountDiff)) { |
|
if (u32CountSum > maxBit) maxBit = u32CountSum; |
|
|
|
if (u32CountDiff > maxBit) maxBit = u32CountDiff; |
|
|
|
*ps16ScfL = (int16_t)u32CountSum; |
|
*(ps16ScfL + s32NumOfSubBands) = (int16_t)u32CountDiff; |
|
|
|
SbBuffer = pstrEncParams->s32SbBuffer + s32Sb; |
|
pSum = s32LRSum; |
|
pDiff = s32LRDiff; |
|
|
|
for (s32Blk = 0; s32Blk < s32NumOfBlocks; s32Blk++) { |
|
*SbBuffer = *pSum; |
|
*(SbBuffer + s32NumOfSubBands) = *pDiff; |
|
|
|
SbBuffer += s32NumOfSubBands << 1; |
|
pSum++; |
|
pDiff++; |
|
} |
|
|
|
pstrEncParams->as16Join[s32Sb] = 1; |
|
} else { |
|
pstrEncParams->as16Join[s32Sb] = 0; |
|
} |
|
ps16ScfL++; |
|
} |
|
pstrEncParams->as16Join[s32Sb] = 0; |
|
} |
|
#endif |
|
|
|
pstrEncParams->s16MaxBitNeed = (int16_t)maxBit; |
|
|
|
/* bit allocation */ |
|
if ((pstrEncParams->s16ChannelMode == SBC_STEREO) || |
|
(pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO)) |
|
sbc_enc_bit_alloc_ste(pstrEncParams); |
|
else |
|
sbc_enc_bit_alloc_mono(pstrEncParams); |
|
|
|
/* Quantize the encoded audio */ |
|
return EncPacking(pstrEncParams, output); |
|
} |
|
|
|
/**************************************************************************** |
|
* InitSbcAnalysisFilt - Initalizes the input data to 0 |
|
* |
|
* RETURNS : N/A |
|
*/ |
|
void SBC_Encoder_Init(SBC_ENC_PARAMS* pstrEncParams) { |
|
uint16_t s16SamplingFreq; /*temp variable to store smpling freq*/ |
|
int16_t s16Bitpool; /*to store bit pool value*/ |
|
int16_t s16BitRate; /*to store bitrate*/ |
|
int16_t s16FrameLen; /*to store frame length*/ |
|
uint16_t HeaderParams; |
|
|
|
/* Required number of channels */ |
|
if (pstrEncParams->s16ChannelMode == SBC_MONO) |
|
pstrEncParams->s16NumOfChannels = 1; |
|
else |
|
pstrEncParams->s16NumOfChannels = 2; |
|
|
|
/* Bit pool calculation */ |
|
if (pstrEncParams->s16SamplingFreq == SBC_sf16000) |
|
s16SamplingFreq = 16000; |
|
else if (pstrEncParams->s16SamplingFreq == SBC_sf32000) |
|
s16SamplingFreq = 32000; |
|
else if (pstrEncParams->s16SamplingFreq == SBC_sf44100) |
|
s16SamplingFreq = 44100; |
|
else |
|
s16SamplingFreq = 48000; |
|
|
|
if ((pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO) || |
|
(pstrEncParams->s16ChannelMode == SBC_STEREO)) { |
|
s16Bitpool = |
|
(int16_t)((pstrEncParams->u16BitRate * pstrEncParams->s16NumOfSubBands * |
|
1000 / s16SamplingFreq) - |
|
((32 + (4 * pstrEncParams->s16NumOfSubBands * |
|
pstrEncParams->s16NumOfChannels) + |
|
((pstrEncParams->s16ChannelMode - 2) * |
|
pstrEncParams->s16NumOfSubBands)) / |
|
pstrEncParams->s16NumOfBlocks)); |
|
|
|
s16FrameLen = 4 + |
|
(4 * pstrEncParams->s16NumOfSubBands * |
|
pstrEncParams->s16NumOfChannels) / |
|
8 + |
|
(((pstrEncParams->s16ChannelMode - 2) * |
|
pstrEncParams->s16NumOfSubBands) + |
|
(pstrEncParams->s16NumOfBlocks * s16Bitpool)) / |
|
8; |
|
|
|
s16BitRate = (8 * s16FrameLen * s16SamplingFreq) / |
|
(pstrEncParams->s16NumOfSubBands * |
|
pstrEncParams->s16NumOfBlocks * 1000); |
|
|
|
if (s16BitRate > pstrEncParams->u16BitRate) s16Bitpool--; |
|
|
|
if (pstrEncParams->s16NumOfSubBands == 8) |
|
pstrEncParams->s16BitPool = (s16Bitpool > 255) ? 255 : s16Bitpool; |
|
else |
|
pstrEncParams->s16BitPool = (s16Bitpool > 128) ? 128 : s16Bitpool; |
|
} else { |
|
s16Bitpool = (int16_t)( |
|
((pstrEncParams->s16NumOfSubBands * pstrEncParams->u16BitRate * 1000) / |
|
(s16SamplingFreq * pstrEncParams->s16NumOfChannels)) - |
|
(((32 / pstrEncParams->s16NumOfChannels) + |
|
(4 * pstrEncParams->s16NumOfSubBands)) / |
|
pstrEncParams->s16NumOfBlocks)); |
|
|
|
pstrEncParams->s16BitPool = |
|
(s16Bitpool > (16 * pstrEncParams->s16NumOfSubBands)) |
|
? (16 * pstrEncParams->s16NumOfSubBands) |
|
: s16Bitpool; |
|
} |
|
|
|
if (pstrEncParams->s16BitPool < 0) pstrEncParams->s16BitPool = 0; |
|
/* sampling freq */ |
|
HeaderParams = ((pstrEncParams->s16SamplingFreq & 3) << 6); |
|
|
|
/* number of blocks*/ |
|
HeaderParams |= (((pstrEncParams->s16NumOfBlocks - 4) & 12) << 2); |
|
|
|
/* channel mode: mono, dual...*/ |
|
HeaderParams |= ((pstrEncParams->s16ChannelMode & 3) << 2); |
|
|
|
/* Loudness or SNR */ |
|
HeaderParams |= ((pstrEncParams->s16AllocationMethod & 1) << 1); |
|
HeaderParams |= ((pstrEncParams->s16NumOfSubBands >> 3) & 1); /*4 or 8*/ |
|
pstrEncParams->FrameHeader = HeaderParams; |
|
|
|
if (pstrEncParams->s16NumOfSubBands == 4) { |
|
if (pstrEncParams->s16NumOfChannels == 1) |
|
EncMaxShiftCounter = ((ENC_VX_BUFFER_SIZE - 4 * 10) >> 2) << 2; |
|
else |
|
EncMaxShiftCounter = ((ENC_VX_BUFFER_SIZE - 4 * 10 * 2) >> 3) << 2; |
|
} else { |
|
if (pstrEncParams->s16NumOfChannels == 1) |
|
EncMaxShiftCounter = ((ENC_VX_BUFFER_SIZE - 8 * 10) >> 3) << 3; |
|
else |
|
EncMaxShiftCounter = ((ENC_VX_BUFFER_SIZE - 8 * 10 * 2) >> 4) << 3; |
|
} |
|
|
|
SbcAnalysisInit(); |
|
}
|
|
|