1 /******************************************************************************
2 *
3 * Copyright 1999-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * contains code for encoder flow and initalization of encoder
22 *
23 ******************************************************************************/
24
25 #include "sbc_encoder.h"
26 #include <string.h>
27 #include "bt_target.h"
28 #include "sbc_enc_func_declare.h"
29
30 int16_t EncMaxShiftCounter;
31
32 #if (SBC_JOINT_STE_INCLUDED == TRUE)
33 int32_t s32LRDiff[SBC_MAX_NUM_OF_BLOCKS] = {0};
34 int32_t s32LRSum[SBC_MAX_NUM_OF_BLOCKS] = {0};
35 #endif
36
SBC_Encode(SBC_ENC_PARAMS * pstrEncParams,int16_t * input,uint8_t * output)37 uint32_t SBC_Encode(SBC_ENC_PARAMS* pstrEncParams, int16_t* input,
38 uint8_t* output) {
39 int32_t s32Ch; /* counter for ch*/
40 int32_t s32Sb; /* counter for sub-band*/
41 uint32_t u32Count, maxBit = 0; /* loop count*/
42 int32_t s32MaxValue; /* temp variable to store max value */
43
44 int16_t* ps16ScfL;
45 int32_t* SbBuffer;
46 int32_t s32Blk; /* counter for block*/
47 int32_t s32NumOfBlocks = pstrEncParams->s16NumOfBlocks;
48 #if (SBC_JOINT_STE_INCLUDED == TRUE)
49 int32_t s32MaxValue2;
50 uint32_t u32CountSum, u32CountDiff;
51 int32_t *pSum, *pDiff;
52 #endif
53 register int32_t s32NumOfSubBands = pstrEncParams->s16NumOfSubBands;
54
55 /* SBC ananlysis filter*/
56 if (s32NumOfSubBands == 4)
57 SbcAnalysisFilter4(pstrEncParams, input);
58 else
59 SbcAnalysisFilter8(pstrEncParams, input);
60
61 /* compute the scale factor, and save the max */
62 ps16ScfL = pstrEncParams->as16ScaleFactor;
63 s32Ch = pstrEncParams->s16NumOfChannels * s32NumOfSubBands;
64
65 for (s32Sb = 0; s32Sb < s32Ch; s32Sb++) {
66 SbBuffer = pstrEncParams->s32SbBuffer + s32Sb;
67 s32MaxValue = 0;
68 for (s32Blk = s32NumOfBlocks; s32Blk > 0; s32Blk--) {
69 if (s32MaxValue < abs32(*SbBuffer)) s32MaxValue = abs32(*SbBuffer);
70 SbBuffer += s32Ch;
71 }
72
73 u32Count = (s32MaxValue > 0x800000) ? 9 : 0;
74
75 for (; u32Count < 15; u32Count++) {
76 if (s32MaxValue <= (int32_t)(0x8000 << u32Count)) break;
77 }
78 *ps16ScfL++ = (int16_t)u32Count;
79
80 if (u32Count > maxBit) maxBit = u32Count;
81 }
82 /* In case of JS processing,check whether to use JS */
83 #if (SBC_JOINT_STE_INCLUDED == TRUE)
84 if (pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO) {
85 /* Calculate sum and differance scale factors for making JS decision */
86 ps16ScfL = pstrEncParams->as16ScaleFactor;
87 /* calculate the scale factor of Joint stereo max sum and diff */
88 for (s32Sb = 0; s32Sb < s32NumOfSubBands - 1; s32Sb++) {
89 SbBuffer = pstrEncParams->s32SbBuffer + s32Sb;
90 s32MaxValue2 = 0;
91 s32MaxValue = 0;
92 pSum = s32LRSum;
93 pDiff = s32LRDiff;
94 for (s32Blk = 0; s32Blk < s32NumOfBlocks; s32Blk++) {
95 *pSum = (*SbBuffer + *(SbBuffer + s32NumOfSubBands)) >> 1;
96 if (abs32(*pSum) > s32MaxValue) s32MaxValue = abs32(*pSum);
97 pSum++;
98 *pDiff = (*SbBuffer - *(SbBuffer + s32NumOfSubBands)) >> 1;
99 if (abs32(*pDiff) > s32MaxValue2) s32MaxValue2 = abs32(*pDiff);
100 pDiff++;
101 SbBuffer += s32Ch;
102 }
103 u32Count = (s32MaxValue > 0x800000) ? 9 : 0;
104 for (; u32Count < 15; u32Count++) {
105 if (s32MaxValue <= (int32_t)(0x8000 << u32Count)) break;
106 }
107 u32CountSum = u32Count;
108 u32Count = (s32MaxValue2 > 0x800000) ? 9 : 0;
109 for (; u32Count < 15; u32Count++) {
110 if (s32MaxValue2 <= (int32_t)(0x8000 << u32Count)) break;
111 }
112 u32CountDiff = u32Count;
113 if ((*ps16ScfL + *(ps16ScfL + s32NumOfSubBands)) >
114 (int16_t)(u32CountSum + u32CountDiff)) {
115 if (u32CountSum > maxBit) maxBit = u32CountSum;
116
117 if (u32CountDiff > maxBit) maxBit = u32CountDiff;
118
119 *ps16ScfL = (int16_t)u32CountSum;
120 *(ps16ScfL + s32NumOfSubBands) = (int16_t)u32CountDiff;
121
122 SbBuffer = pstrEncParams->s32SbBuffer + s32Sb;
123 pSum = s32LRSum;
124 pDiff = s32LRDiff;
125
126 for (s32Blk = 0; s32Blk < s32NumOfBlocks; s32Blk++) {
127 *SbBuffer = *pSum;
128 *(SbBuffer + s32NumOfSubBands) = *pDiff;
129
130 SbBuffer += s32NumOfSubBands << 1;
131 pSum++;
132 pDiff++;
133 }
134
135 pstrEncParams->as16Join[s32Sb] = 1;
136 } else {
137 pstrEncParams->as16Join[s32Sb] = 0;
138 }
139 ps16ScfL++;
140 }
141 pstrEncParams->as16Join[s32Sb] = 0;
142 }
143 #endif
144
145 pstrEncParams->s16MaxBitNeed = (int16_t)maxBit;
146
147 /* bit allocation */
148 if ((pstrEncParams->s16ChannelMode == SBC_STEREO) ||
149 (pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO))
150 sbc_enc_bit_alloc_ste(pstrEncParams);
151 else
152 sbc_enc_bit_alloc_mono(pstrEncParams);
153
154 /* Quantize the encoded audio */
155 return EncPacking(pstrEncParams, output);
156 }
157
158 /****************************************************************************
159 * InitSbcAnalysisFilt - Initalizes the input data to 0
160 *
161 * RETURNS : N/A
162 */
SBC_Encoder_Init(SBC_ENC_PARAMS * pstrEncParams)163 void SBC_Encoder_Init(SBC_ENC_PARAMS* pstrEncParams) {
164 uint16_t s16SamplingFreq; /*temp variable to store smpling freq*/
165 int16_t s16Bitpool; /*to store bit pool value*/
166 int16_t s16BitRate; /*to store bitrate*/
167 int16_t s16FrameLen; /*to store frame length*/
168 uint16_t HeaderParams;
169
170 /* Required number of channels */
171 if (pstrEncParams->s16ChannelMode == SBC_MONO)
172 pstrEncParams->s16NumOfChannels = 1;
173 else
174 pstrEncParams->s16NumOfChannels = 2;
175
176 /* Bit pool calculation */
177 if (pstrEncParams->s16SamplingFreq == SBC_sf16000)
178 s16SamplingFreq = 16000;
179 else if (pstrEncParams->s16SamplingFreq == SBC_sf32000)
180 s16SamplingFreq = 32000;
181 else if (pstrEncParams->s16SamplingFreq == SBC_sf44100)
182 s16SamplingFreq = 44100;
183 else
184 s16SamplingFreq = 48000;
185
186 if ((pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO) ||
187 (pstrEncParams->s16ChannelMode == SBC_STEREO)) {
188 s16Bitpool =
189 (int16_t)((pstrEncParams->u16BitRate * pstrEncParams->s16NumOfSubBands *
190 1000 / s16SamplingFreq) -
191 ((32 + (4 * pstrEncParams->s16NumOfSubBands *
192 pstrEncParams->s16NumOfChannels) +
193 ((pstrEncParams->s16ChannelMode - 2) *
194 pstrEncParams->s16NumOfSubBands)) /
195 pstrEncParams->s16NumOfBlocks));
196
197 s16FrameLen = 4 +
198 (4 * pstrEncParams->s16NumOfSubBands *
199 pstrEncParams->s16NumOfChannels) /
200 8 +
201 (((pstrEncParams->s16ChannelMode - 2) *
202 pstrEncParams->s16NumOfSubBands) +
203 (pstrEncParams->s16NumOfBlocks * s16Bitpool)) /
204 8;
205
206 s16BitRate = (8 * s16FrameLen * s16SamplingFreq) /
207 (pstrEncParams->s16NumOfSubBands *
208 pstrEncParams->s16NumOfBlocks * 1000);
209
210 if (s16BitRate > pstrEncParams->u16BitRate) s16Bitpool--;
211
212 if (pstrEncParams->s16NumOfSubBands == 8)
213 pstrEncParams->s16BitPool = (s16Bitpool > 255) ? 255 : s16Bitpool;
214 else
215 pstrEncParams->s16BitPool = (s16Bitpool > 128) ? 128 : s16Bitpool;
216 } else {
217 s16Bitpool = (int16_t)(
218 ((pstrEncParams->s16NumOfSubBands * pstrEncParams->u16BitRate * 1000) /
219 (s16SamplingFreq * pstrEncParams->s16NumOfChannels)) -
220 (((32 / pstrEncParams->s16NumOfChannels) +
221 (4 * pstrEncParams->s16NumOfSubBands)) /
222 pstrEncParams->s16NumOfBlocks));
223
224 pstrEncParams->s16BitPool =
225 (s16Bitpool > (16 * pstrEncParams->s16NumOfSubBands))
226 ? (16 * pstrEncParams->s16NumOfSubBands)
227 : s16Bitpool;
228 }
229
230 if (pstrEncParams->s16BitPool < 0) pstrEncParams->s16BitPool = 0;
231 /* sampling freq */
232 HeaderParams = ((pstrEncParams->s16SamplingFreq & 3) << 6);
233
234 /* number of blocks*/
235 HeaderParams |= (((pstrEncParams->s16NumOfBlocks - 4) & 12) << 2);
236
237 /* channel mode: mono, dual...*/
238 HeaderParams |= ((pstrEncParams->s16ChannelMode & 3) << 2);
239
240 /* Loudness or SNR */
241 HeaderParams |= ((pstrEncParams->s16AllocationMethod & 1) << 1);
242 HeaderParams |= ((pstrEncParams->s16NumOfSubBands >> 3) & 1); /*4 or 8*/
243 pstrEncParams->FrameHeader = HeaderParams;
244
245 if (pstrEncParams->s16NumOfSubBands == 4) {
246 if (pstrEncParams->s16NumOfChannels == 1)
247 EncMaxShiftCounter = ((ENC_VX_BUFFER_SIZE - 4 * 10) >> 2) << 2;
248 else
249 EncMaxShiftCounter = ((ENC_VX_BUFFER_SIZE - 4 * 10 * 2) >> 3) << 2;
250 } else {
251 if (pstrEncParams->s16NumOfChannels == 1)
252 EncMaxShiftCounter = ((ENC_VX_BUFFER_SIZE - 8 * 10) >> 3) << 3;
253 else
254 EncMaxShiftCounter = ((ENC_VX_BUFFER_SIZE - 8 * 10 * 2) >> 4) << 3;
255 }
256
257 SbcAnalysisInit();
258 }
259