1 /******************************************************************************
2 *
3 * Copyright (C) 2014 The Android Open Source Project
4 * Copyright 2003 - 2004 Open Interface North America, Inc. All rights reserved.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 ******************************************************************************/
19
20 /**********************************************************************************
21 $Revision: #1 $
22 ***********************************************************************************/
23
24 /**
25 @file
26
27 The functions in this file relate to the allocation of available bits to
28 subbands within the SBC/eSBC frame, along with support functions for computing
29 frame length and bitrate.
30
31 @ingroup codec_internal
32 */
33
34 /**
35 @addtogroup codec_internal
36 @{
37 */
38
39 #include "oi_utils.h"
40 #include <oi_codec_sbc_private.h>
41
OI_SBC_MaxBitpool(OI_CODEC_SBC_FRAME_INFO * frame)42 OI_UINT32 OI_SBC_MaxBitpool(OI_CODEC_SBC_FRAME_INFO *frame)
43 {
44 switch (frame->mode) {
45 case SBC_MONO:
46 case SBC_DUAL_CHANNEL:
47 return 16 * frame->nrof_subbands;
48 case SBC_STEREO:
49 case SBC_JOINT_STEREO:
50 return 32 * frame->nrof_subbands;
51 }
52
53 ERROR(("Invalid frame mode %d", frame->mode));
54 OI_ASSERT(FALSE);
55 return 0; /* Should never be reached */
56 }
57
58
internal_CalculateFramelen(OI_CODEC_SBC_FRAME_INFO * frame)59 PRIVATE OI_UINT16 internal_CalculateFramelen(OI_CODEC_SBC_FRAME_INFO *frame)
60 {
61 OI_UINT16 nbits = frame->nrof_blocks * frame->bitpool;
62 OI_UINT16 nrof_subbands = frame->nrof_subbands;
63 OI_UINT16 result = nbits;
64
65 if (frame->mode == SBC_JOINT_STEREO) {
66 result += nrof_subbands + (8 * nrof_subbands);
67 } else {
68 if (frame->mode == SBC_DUAL_CHANNEL) { result += nbits; }
69 if (frame->mode == SBC_MONO) { result += 4*nrof_subbands; } else { result += 8*nrof_subbands; }
70 }
71 return SBC_HEADER_LEN + (result + 7) / 8;
72 }
73
74
internal_CalculateBitrate(OI_CODEC_SBC_FRAME_INFO * frame)75 PRIVATE OI_UINT32 internal_CalculateBitrate(OI_CODEC_SBC_FRAME_INFO *frame)
76 {
77 OI_UINT blocksbands;
78 blocksbands = frame->nrof_subbands * frame->nrof_blocks;
79
80 return DIVIDE(8 * internal_CalculateFramelen(frame) * frame->frequency, blocksbands);
81 }
82
83
OI_SBC_CalculateFrameAndHeaderlen(OI_CODEC_SBC_FRAME_INFO * frame,OI_UINT * headerLen_)84 INLINE OI_UINT16 OI_SBC_CalculateFrameAndHeaderlen(OI_CODEC_SBC_FRAME_INFO *frame, OI_UINT *headerLen_)
85 {
86 OI_UINT headerLen = SBC_HEADER_LEN + frame->nrof_subbands * frame->nrof_channels/2;
87
88 if (frame->mode == SBC_JOINT_STEREO) { headerLen++; }
89
90 *headerLen_ = headerLen;
91 return internal_CalculateFramelen(frame);
92 }
93
94
95 #define MIN(x, y) ((x) < (y) ? (x) : (y))
96
97
98 /*
99 * Computes the bit need for each sample and as also returns a counts of bit needs that are greater
100 * than one. This count is used in the first phase of bit allocation.
101 *
102 * We also compute a preferred bitpool value that this is the minimum bitpool needed to guarantee
103 * lossless representation of the audio data. The preferred bitpool may be larger than the bits
104 * actually required but the only input we have are the scale factors. For example, it takes 2 bits
105 * to represent values in the range -1 .. +1 but the scale factor is 0. To guarantee lossless
106 * representation we add 2 to each scale factor and sum them to come up with the preferred bitpool.
107 * This is not ideal because 0 requires 0 bits but we currently have no way of knowing this.
108 *
109 * @param bitneed Array to return bitneeds for each subband
110 *
111 * @param ch Channel 0 or 1
112 *
113 * @param preferredBitpool Returns the number of reserved bits
114 *
115 * @return The SBC bit need
116 *
117 */
computeBitneed(OI_CODEC_SBC_COMMON_CONTEXT * common,OI_UINT8 * bitneeds,OI_UINT ch,OI_UINT * preferredBitpool)118 OI_UINT computeBitneed(OI_CODEC_SBC_COMMON_CONTEXT *common,
119 OI_UINT8 *bitneeds,
120 OI_UINT ch,
121 OI_UINT *preferredBitpool)
122 {
123 static const OI_INT8 offset4[4][4] = {
124 { -1, 0, 0, 0 },
125 { -2, 0, 0, 1 },
126 { -2, 0, 0, 1 },
127 { -2, 0, 0, 1 }
128 };
129
130 static const OI_INT8 offset8[4][8] = {
131 { -2, 0, 0, 0, 0, 0, 0, 1 },
132 { -3, 0, 0, 0, 0, 0, 1, 2 },
133 { -4, 0, 0, 0, 0, 0, 1, 2 },
134 { -4, 0, 0, 0, 0, 0, 1, 2 }
135 };
136
137 const OI_UINT nrof_subbands = common->frameInfo.nrof_subbands;
138 OI_UINT sb;
139 OI_INT8 *scale_factor = &common->scale_factor[ch ? nrof_subbands : 0];
140 OI_UINT bitcount = 0;
141 OI_UINT8 maxBits = 0;
142 OI_UINT8 prefBits = 0;
143
144 if (common->frameInfo.alloc == SBC_SNR) {
145 for (sb = 0; sb < nrof_subbands; sb++) {
146 OI_INT bits = scale_factor[sb];
147 if (bits > maxBits) {
148 maxBits = bits;
149 }
150 if ((bitneeds[sb] = bits) > 1) {
151 bitcount += bits;
152 }
153 prefBits += 2 + bits;
154 }
155 } else {
156 const OI_INT8 *offset;
157 if (nrof_subbands == 4) {
158 offset = offset4[common->frameInfo.freqIndex];
159 } else {
160 offset = offset8[common->frameInfo.freqIndex];
161 }
162 for (sb = 0; sb < nrof_subbands; sb++) {
163 OI_INT bits = scale_factor[sb];
164 if (bits > maxBits) {
165 maxBits = bits;
166 }
167 prefBits += 2 + bits;
168 if (bits) {
169 bits -= offset[sb];
170 if (bits > 0) {
171 bits /= 2;
172 }
173 bits += 5;
174 }
175 if ((bitneeds[sb] = bits) > 1) {
176 bitcount += bits;
177 }
178 }
179 }
180 common->maxBitneed = OI_MAX(maxBits, common->maxBitneed);
181 *preferredBitpool += prefBits;
182 return bitcount;
183 }
184
185
186 /*
187 * Explanation of the adjustToFitBitpool inner loop.
188 *
189 * The inner loop computes the effect of adjusting the bit allocation up or
190 * down. Allocations must be 0 or in the range 2..16. This is accomplished by
191 * the following code:
192 *
193 * for (s = bands - 1; s >= 0; --s) {
194 * OI_INT bits = bitadjust + bitneeds[s];
195 * bits = bits < 2 ? 0 : bits;
196 * bits = bits > 16 ? 16 : bits;
197 * count += bits;
198 * }
199 *
200 * This loop can be optimized to perform 4 operations at a time as follows:
201 *
202 * Adjustment is computed as a 7 bit signed value and added to the bitneed.
203 *
204 * Negative allocations are zeroed by masking. (n & 0x40) >> 6 puts the
205 * sign bit into bit 0, adding this to 0x7F give us a mask of 0x80
206 * for -ve values and 0x7F for +ve values.
207 *
208 * n &= 0x7F + (n & 0x40) >> 6)
209 *
210 * Allocations greater than 16 are truncated to 16. Adjusted allocations are in
211 * the range 0..31 so we know that bit 4 indicates values >= 16. We use this bit
212 * to create a mask that zeroes bits 0 .. 3 if bit 4 is set.
213 *
214 * n &= (15 + (n >> 4))
215 *
216 * Allocations of 1 are disallowed. Add and shift creates a mask that
217 * eliminates the illegal value
218 *
219 * n &= ((n + 14) >> 4) | 0x1E
220 *
221 * These operations can be performed in 8 bits without overflowing so we can
222 * operate on 4 values at once.
223 */
224
225
226 /*
227 * Encoder/Decoder
228 *
229 * Computes adjustment +/- of bitneeds to fill bitpool and returns overall
230 * adjustment and excess bits.
231 *
232 * @param bitpool The bitpool we have to work within
233 *
234 * @param bitneeds An array of bit needs (more acturately allocation prioritities) for each
235 * subband across all blocks in the SBC frame
236 *
237 * @param subbands The number of subbands over which the adkustment is calculated. For mono and
238 * dual mode this is 4 or 8, for stereo or joint stereo this is 8 or 16.
239 *
240 * @param bitcount A starting point for the adjustment
241 *
242 * @param excess Returns the excess bits after the adjustment
243 *
244 * @return The adjustment.
245 */
adjustToFitBitpool(const OI_UINT bitpool,OI_UINT32 * bitneeds,const OI_UINT subbands,OI_UINT bitcount,OI_UINT * excess)246 OI_INT adjustToFitBitpool(const OI_UINT bitpool,
247 OI_UINT32 *bitneeds,
248 const OI_UINT subbands,
249 OI_UINT bitcount,
250 OI_UINT *excess)
251 {
252 OI_INT maxBitadjust = 0;
253 OI_INT bitadjust = (bitcount > bitpool) ? -8 : 8;
254 OI_INT chop = 8;
255
256 /*
257 * This is essentially a binary search for the optimal adjustment value.
258 */
259 while ((bitcount != bitpool) && chop) {
260 OI_UINT32 total = 0;
261 OI_UINT count;
262 OI_UINT32 adjust4;
263 OI_INT i;
264
265 adjust4 = bitadjust & 0x7F;
266 adjust4 |= (adjust4 << 8);
267 adjust4 |= (adjust4 << 16);
268
269 for (i = (subbands / 4 - 1); i >= 0; --i) {
270 OI_UINT32 mask;
271 OI_UINT32 n = bitneeds[i] + adjust4;
272 mask = 0x7F7F7F7F + ((n & 0x40404040) >> 6);
273 n &= mask;
274 mask = 0x0F0F0F0F + ((n & 0x10101010) >> 4);
275 n &= mask;
276 mask = (((n + 0x0E0E0E0E) >> 4) | 0x1E1E1E1E);
277 n &= mask;
278 total += n;
279 }
280
281 count = (total & 0xFFFF) + (total >> 16);
282 count = (count & 0xFF) + (count >> 8);
283
284 chop >>= 1;
285 if (count > bitpool) {
286 bitadjust -= chop;
287 } else {
288 maxBitadjust = bitadjust;
289 bitcount = count;
290 bitadjust += chop;
291 }
292 }
293
294 *excess = bitpool - bitcount;
295
296 return maxBitadjust;
297 }
298
299
300 /*
301 * The bit allocator trys to avoid single bit allocations except as a last resort. So in the case
302 * where a bitneed of 1 was passed over during the adsjustment phase 2 bits are now allocated.
303 */
allocAdjustedBits(OI_UINT8 * dest,OI_INT bits,OI_INT excess)304 INLINE OI_INT allocAdjustedBits(OI_UINT8 *dest,
305 OI_INT bits,
306 OI_INT excess)
307 {
308 if (bits < 16) {
309 if (bits > 1) {
310 if (excess) {
311 ++bits;
312 --excess;
313 }
314 } else if ((bits == 1) && (excess > 1)) {
315 bits = 2;
316 excess -= 2;
317 } else {
318 bits = 0;
319 }
320 } else {
321 bits = 16;
322 }
323 *dest = (OI_UINT8)bits;
324 return excess;
325 }
326
327
328 /*
329 * Excess bits not allocated by allocaAdjustedBits are allocated round-robin.
330 */
allocExcessBits(OI_UINT8 * dest,OI_INT excess)331 INLINE OI_INT allocExcessBits(OI_UINT8 *dest,
332 OI_INT excess)
333 {
334 if (*dest < 16) {
335 *dest += 1;
336 return excess - 1;
337 } else {
338 return excess;
339 }
340 }
341
oneChannelBitAllocation(OI_CODEC_SBC_COMMON_CONTEXT * common,BITNEED_UNION1 * bitneeds,OI_UINT ch,OI_UINT bitcount)342 void oneChannelBitAllocation(OI_CODEC_SBC_COMMON_CONTEXT *common,
343 BITNEED_UNION1 *bitneeds,
344 OI_UINT ch,
345 OI_UINT bitcount)
346 {
347 const OI_UINT8 nrof_subbands = common->frameInfo.nrof_subbands;
348 OI_UINT excess;
349 OI_UINT sb;
350 OI_INT bitadjust;
351 OI_UINT8 RESTRICT *allocBits;
352
353
354 {
355 OI_UINT ex;
356 bitadjust = adjustToFitBitpool(common->frameInfo.bitpool, bitneeds->uint32, nrof_subbands, bitcount, &ex);
357 /* We want the compiler to put excess into a register */
358 excess = ex;
359 }
360
361 /*
362 * Allocate adjusted bits
363 */
364 allocBits = &common->bits.uint8[ch ? nrof_subbands : 0];
365
366 sb = 0;
367 while (sb < nrof_subbands) {
368 excess = allocAdjustedBits(&allocBits[sb], bitneeds->uint8[sb] + bitadjust, excess);
369 ++sb;
370 }
371 sb = 0;
372 while (excess) {
373 excess = allocExcessBits(&allocBits[sb], excess);
374 ++sb;
375 }
376 }
377
378
monoBitAllocation(OI_CODEC_SBC_COMMON_CONTEXT * common)379 void monoBitAllocation(OI_CODEC_SBC_COMMON_CONTEXT *common)
380 {
381 BITNEED_UNION1 bitneeds;
382 OI_UINT bitcount;
383 OI_UINT bitpoolPreference = 0;
384
385 bitcount = computeBitneed(common, bitneeds.uint8, 0, &bitpoolPreference);
386
387 oneChannelBitAllocation(common, &bitneeds, 0, bitcount);
388 }
389
390 /**
391 @}
392 */
393