mirror of
https://github.com/espressif/esp-idf.git
synced 2025-11-02 16:11:41 +01:00
component/bt: minor issue fixes for pre-merge
1. arrange the order of profile ID enums 2. add directory "external" and move SBC codec source into it
This commit is contained in:
wangmengyang
399
components/bt/bluedroid/external/sbc/encoder/srce/sbc_encoder.c
vendored
Normal file
399
components/bt/bluedroid/external/sbc/encoder/srce/sbc_encoder.c
vendored
Normal file
@@ -0,0 +1,399 @@
|
||||
/******************************************************************************
|
||||
*
|
||||
* 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 <string.h>
|
||||
#include "bt_target.h"
|
||||
#include "sbc_encoder.h"
|
||||
#include "sbc_enc_func_declare.h"
|
||||
|
||||
SINT16 EncMaxShiftCounter;
|
||||
|
||||
/*************************************************************************************************
|
||||
* SBC encoder scramble code
|
||||
* Purpose: to tie the SBC code with BTE/mobile stack code,
|
||||
* especially for the case when the SBC is ported into a third-party Multimedia chip
|
||||
*
|
||||
* Algorithm:
|
||||
* init process: all counters reset to 0,
|
||||
* calculate base_index: (6 + s16NumOfChannels*s16NumOfSubBands/2)
|
||||
* scramble side: the init process happens every time SBC_Encoder_Init() is called.
|
||||
* descramble side: it would be nice to know if he "init" process has happened.
|
||||
* alter the SBC SYNC word 0x9C (1001 1100) to 0x8C (1000 1100).
|
||||
*
|
||||
* scramble process:
|
||||
* The CRC byte:
|
||||
* Every SBC frame has a frame header.
|
||||
* The 1st byte is the sync word and the following 2 bytes are about the stream format.
|
||||
* They are supposed to be "constant" within a "song"
|
||||
* The 4th byte is the CRC byte. The CRC byte is bound to be random.
|
||||
* Derive 2 items from the CRC byte; one is the "use" bit, the other is the "index".
|
||||
*
|
||||
* SBC keeps 2 sets of "use" & "index"; derived the current and the previous frame.
|
||||
*
|
||||
* The "use" bit is any bit in SBC_PRTC_USE_MASK is set.
|
||||
* If set, SBC uses the "index" from the current frame.
|
||||
* If not set, SBC uses the "index" from the previous frame or 0.
|
||||
*
|
||||
* index = (CRC & 0x3) + ((CRC & 0x30) >> 2) // 8 is the max index
|
||||
*
|
||||
* if(index > 0)
|
||||
* {
|
||||
* p = &u8frame[base_index];
|
||||
* if((index&1)&&(u16PacketLength > (base_index+index*2)))
|
||||
* {
|
||||
* // odd index: swap 2 bytes
|
||||
* tmp = p[index];
|
||||
* p[index] = p[index*2];
|
||||
* p[index*2] = tmp;
|
||||
* }
|
||||
* else
|
||||
* {
|
||||
* // even index: shift by 3
|
||||
* tmp = (p[index] >> 5) + (p[index] << 3);
|
||||
* p[index] = tmp;
|
||||
* }
|
||||
* }
|
||||
* //else index is 0. The frame stays unaltered
|
||||
*
|
||||
*/
|
||||
|
||||
#define SBC_PRTC_CRC_IDX 3
|
||||
#define SBC_PRTC_USE_MASK 0x64
|
||||
#define SBC_PRTC_SYNC_MASK 0x10
|
||||
#define SBC_PRTC_CIDX 0
|
||||
#define SBC_PRTC_LIDX 1
|
||||
typedef struct {
|
||||
UINT8 use;
|
||||
UINT8 idx;
|
||||
} tSBC_FR_CB;
|
||||
|
||||
typedef struct {
|
||||
tSBC_FR_CB fr[2];
|
||||
UINT8 init;
|
||||
UINT8 index;
|
||||
UINT8 base;
|
||||
} tSBC_PRTC_CB;
|
||||
tSBC_PRTC_CB sbc_prtc_cb;
|
||||
|
||||
#define SBC_PRTC_IDX(sc) (((sc) & 0x3) + (((sc) & 0x30) >> 2))
|
||||
#define SBC_PRTC_CHK_INIT(ar) {if(sbc_prtc_cb.init == 0){sbc_prtc_cb.init=1; ar[0] &= ~SBC_PRTC_SYNC_MASK;}}
|
||||
#define SBC_PRTC_C2L() {p_last=&sbc_prtc_cb.fr[SBC_PRTC_LIDX]; p_cur=&sbc_prtc_cb.fr[SBC_PRTC_CIDX]; \
|
||||
p_last->idx = p_cur->idx; p_last->use = p_cur->use;}
|
||||
#define SBC_PRTC_GETC(ar) {p_cur->use = ar[SBC_PRTC_CRC_IDX] & SBC_PRTC_USE_MASK; \
|
||||
p_cur->idx = SBC_PRTC_IDX(ar[SBC_PRTC_CRC_IDX]);}
|
||||
#define SBC_PRTC_CHK_CRC(ar) {SBC_PRTC_C2L();SBC_PRTC_GETC(ar);sbc_prtc_cb.index = (p_cur->use)?SBC_PRTC_CIDX:SBC_PRTC_LIDX;}
|
||||
#define SBC_PRTC_SCRMB(ar) {idx = sbc_prtc_cb.fr[sbc_prtc_cb.index].idx; \
|
||||
if(idx > 0){if((idx&1)&&(pstrEncParams->u16PacketLength > (sbc_prtc_cb.base+(idx<<1)))) {tmp2=idx<<1; tmp=ar[idx];ar[idx]=ar[tmp2];ar[tmp2]=tmp;} \
|
||||
else{tmp2=ar[idx]; tmp=(tmp2>>5)+(tmp2<<3);ar[idx]=(UINT8)tmp;}}}
|
||||
|
||||
#if (SBC_JOINT_STE_INCLUDED == TRUE)
|
||||
SINT32 s32LRDiff[SBC_MAX_NUM_OF_BLOCKS] = {0};
|
||||
SINT32 s32LRSum[SBC_MAX_NUM_OF_BLOCKS] = {0};
|
||||
#endif
|
||||
|
||||
void SBC_Encoder(SBC_ENC_PARAMS *pstrEncParams)
|
||||
{
|
||||
SINT32 s32Ch; /* counter for ch*/
|
||||
SINT32 s32Sb; /* counter for sub-band*/
|
||||
UINT32 u32Count, maxBit = 0; /* loop count*/
|
||||
SINT32 s32MaxValue; /* temp variable to store max value */
|
||||
|
||||
SINT16 *ps16ScfL;
|
||||
SINT32 *SbBuffer;
|
||||
SINT32 s32Blk; /* counter for block*/
|
||||
SINT32 s32NumOfBlocks = pstrEncParams->s16NumOfBlocks;
|
||||
#if (SBC_JOINT_STE_INCLUDED == TRUE)
|
||||
SINT32 s32MaxValue2;
|
||||
UINT32 u32CountSum, u32CountDiff;
|
||||
SINT32 *pSum, *pDiff;
|
||||
#endif
|
||||
UINT8 *pu8;
|
||||
tSBC_FR_CB *p_cur, *p_last;
|
||||
UINT32 idx, tmp, tmp2;
|
||||
register SINT32 s32NumOfSubBands = pstrEncParams->s16NumOfSubBands;
|
||||
|
||||
pstrEncParams->pu8NextPacket = pstrEncParams->pu8Packet;
|
||||
|
||||
#if (SBC_NO_PCM_CPY_OPTION == TRUE)
|
||||
pstrEncParams->ps16NextPcmBuffer = pstrEncParams->ps16PcmBuffer;
|
||||
#else
|
||||
pstrEncParams->ps16NextPcmBuffer = pstrEncParams->as16PcmBuffer;
|
||||
#endif
|
||||
do {
|
||||
/* SBC ananlysis filter*/
|
||||
if (s32NumOfSubBands == 4) {
|
||||
SbcAnalysisFilter4(pstrEncParams);
|
||||
} else {
|
||||
SbcAnalysisFilter8(pstrEncParams);
|
||||
}
|
||||
|
||||
/* compute the scale factor, and save the max */
|
||||
ps16ScfL = pstrEncParams->as16ScaleFactor;
|
||||
s32Ch = pstrEncParams->s16NumOfChannels * s32NumOfSubBands;
|
||||
|
||||
pstrEncParams->ps16NextPcmBuffer += s32Ch * s32NumOfBlocks; /* in case of multible sbc frame to encode update the pcm pointer */
|
||||
|
||||
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 <= (SINT32)(0x8000 << u32Count)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
*ps16ScfL++ = (SINT16)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 <= (SINT32)(0x8000 << u32Count)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
u32CountSum = u32Count;
|
||||
u32Count = (s32MaxValue2 > 0x800000) ? 9 : 0;
|
||||
for ( ; u32Count < 15; u32Count++) {
|
||||
if (s32MaxValue2 <= (SINT32)(0x8000 << u32Count)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
u32CountDiff = u32Count;
|
||||
if ( (*ps16ScfL + * (ps16ScfL + s32NumOfSubBands)) > (SINT16)(u32CountSum + u32CountDiff) ) {
|
||||
|
||||
if (u32CountSum > maxBit) {
|
||||
maxBit = u32CountSum;
|
||||
}
|
||||
|
||||
if (u32CountDiff > maxBit) {
|
||||
maxBit = u32CountDiff;
|
||||
}
|
||||
|
||||
*ps16ScfL = (SINT16)u32CountSum;
|
||||
*(ps16ScfL + s32NumOfSubBands) = (SINT16)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 = (SINT16)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);
|
||||
}
|
||||
|
||||
/* save the beginning of the frame. pu8NextPacket is modified in EncPacking() */
|
||||
pu8 = pstrEncParams->pu8NextPacket;
|
||||
/* Quantize the encoded audio */
|
||||
EncPacking(pstrEncParams);
|
||||
|
||||
/* scramble the code */
|
||||
SBC_PRTC_CHK_INIT(pu8);
|
||||
SBC_PRTC_CHK_CRC(pu8);
|
||||
#if 0
|
||||
if (pstrEncParams->u16PacketLength > ((sbc_prtc_cb.fr[sbc_prtc_cb.index].idx * 2) + sbc_prtc_cb.base)) {
|
||||
printf("len: %d, idx: %d\n", pstrEncParams->u16PacketLength, sbc_prtc_cb.fr[sbc_prtc_cb.index].idx);
|
||||
} else {
|
||||
printf("len: %d, idx: %d!!!!\n", pstrEncParams->u16PacketLength, sbc_prtc_cb.fr[sbc_prtc_cb.index].idx);
|
||||
}
|
||||
#endif
|
||||
SBC_PRTC_SCRMB((&pu8[sbc_prtc_cb.base]));
|
||||
} while (--(pstrEncParams->u8NumPacketToEncode));
|
||||
|
||||
pstrEncParams->u8NumPacketToEncode = 1; /* default is one for retrocompatibility purpose */
|
||||
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* InitSbcAnalysisFilt - Initalizes the input data to 0
|
||||
*
|
||||
* RETURNS : N/A
|
||||
*/
|
||||
void SBC_Encoder_Init(SBC_ENC_PARAMS *pstrEncParams)
|
||||
{
|
||||
UINT16 s16SamplingFreq; /*temp variable to store smpling freq*/
|
||||
SINT16 s16Bitpool; /*to store bit pool value*/
|
||||
SINT16 s16BitRate; /*to store bitrate*/
|
||||
SINT16 s16FrameLen; /*to store frame length*/
|
||||
UINT16 HeaderParams;
|
||||
|
||||
pstrEncParams->u8NumPacketToEncode = 1; /* default is one for retrocompatibility purpose */
|
||||
|
||||
/* 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 = (SINT16)( (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 = (SINT16)( ((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;
|
||||
}
|
||||
}
|
||||
|
||||
APPL_TRACE_EVENT("SBC_Encoder_Init : bitrate %d, bitpool %d",
|
||||
pstrEncParams->u16BitRate, pstrEncParams->s16BitPool);
|
||||
|
||||
SbcAnalysisInit();
|
||||
|
||||
memset(&sbc_prtc_cb, 0, sizeof(tSBC_PRTC_CB));
|
||||
sbc_prtc_cb.base = 6 + pstrEncParams->s16NumOfChannels * pstrEncParams->s16NumOfSubBands / 2;
|
||||
}
|
||||
Reference in New Issue
Block a user