1 /*
2 * Bluetooth low-complexity, subband codec (SBC)
3 *
4 * Copyright (C) 2017 Aurelien Jacobs <aurel@gnuage.org>
5 * Copyright (C) 2012-2013 Intel Corporation
6 * Copyright (C) 2008-2010 Nokia Corporation
7 * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
8 * Copyright (C) 2004-2005 Henryk Ploetz <henryk@ploetzli.ch>
9 * Copyright (C) 2005-2008 Brad Midgley <bmidgley@xmission.com>
10 *
11 * This file is part of FFmpeg.
12 *
13 * FFmpeg is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
17 *
18 * FFmpeg is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
22 *
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with FFmpeg; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 */
27
28 /**
29 * @file
30 * SBC common functions for the encoder and decoder
31 */
32
33 #include "sbc.h"
34
35 /* A2DP specification: Appendix B, page 69 */
36 static const int sbc_offset4[4][4] = {
37 { -1, 0, 0, 0 },
38 { -2, 0, 0, 1 },
39 { -2, 0, 0, 1 },
40 { -2, 0, 0, 1 }
41 };
42
43 /* A2DP specification: Appendix B, page 69 */
44 static const int sbc_offset8[4][8] = {
45 { -2, 0, 0, 0, 0, 0, 0, 1 },
46 { -3, 0, 0, 0, 0, 0, 1, 2 },
47 { -4, 0, 0, 0, 0, 0, 1, 2 },
48 { -4, 0, 0, 0, 0, 0, 1, 2 }
49 };
50
51 /*
52 * Calculates the CRC-8 of the first len bits in data
53 */
ff_sbc_crc8(const AVCRC * ctx,const uint8_t * data,size_t len)54 uint8_t ff_sbc_crc8(const AVCRC *ctx, const uint8_t *data, size_t len)
55 {
56 size_t byte_length = len >> 3;
57 int bit_length = len & 7;
58 uint8_t crc;
59
60 crc = av_crc(ctx, 0x0F, data, byte_length);
61
62 if (bit_length) {
63 uint8_t bits = data[byte_length];
64 while (bit_length--) {
65 int8_t mask = bits ^ crc;
66 crc = (crc << 1) ^ ((mask >> 7) & 0x1D);
67 bits <<= 1;
68 }
69 }
70
71 return crc;
72 }
73
74 /*
75 * Code straight from the spec to calculate the bits array
76 * Takes a pointer to the frame in question and a pointer to the bits array
77 */
ff_sbc_calculate_bits(const struct sbc_frame * frame,int (* bits)[8])78 void ff_sbc_calculate_bits(const struct sbc_frame *frame, int (*bits)[8])
79 {
80 int subbands = frame->subbands;
81 uint8_t sf = frame->frequency;
82
83 if (frame->mode == MONO || frame->mode == DUAL_CHANNEL) {
84 int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice;
85 int ch, sb;
86
87 for (ch = 0; ch < frame->channels; ch++) {
88 max_bitneed = 0;
89 if (frame->allocation == SNR) {
90 for (sb = 0; sb < subbands; sb++) {
91 bitneed[ch][sb] = frame->scale_factor[ch][sb];
92 if (bitneed[ch][sb] > max_bitneed)
93 max_bitneed = bitneed[ch][sb];
94 }
95 } else {
96 for (sb = 0; sb < subbands; sb++) {
97 if (frame->scale_factor[ch][sb] == 0)
98 bitneed[ch][sb] = -5;
99 else {
100 if (subbands == 4)
101 loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb];
102 else
103 loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb];
104 if (loudness > 0)
105 bitneed[ch][sb] = loudness / 2;
106 else
107 bitneed[ch][sb] = loudness;
108 }
109 if (bitneed[ch][sb] > max_bitneed)
110 max_bitneed = bitneed[ch][sb];
111 }
112 }
113
114 bitcount = 0;
115 slicecount = 0;
116 bitslice = max_bitneed + 1;
117 do {
118 bitslice--;
119 bitcount += slicecount;
120 slicecount = 0;
121 for (sb = 0; sb < subbands; sb++) {
122 if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16))
123 slicecount++;
124 else if (bitneed[ch][sb] == bitslice + 1)
125 slicecount += 2;
126 }
127 } while (bitcount + slicecount < frame->bitpool);
128
129 if (bitcount + slicecount == frame->bitpool) {
130 bitcount += slicecount;
131 bitslice--;
132 }
133
134 for (sb = 0; sb < subbands; sb++) {
135 if (bitneed[ch][sb] < bitslice + 2)
136 bits[ch][sb] = 0;
137 else {
138 bits[ch][sb] = bitneed[ch][sb] - bitslice;
139 if (bits[ch][sb] > 16)
140 bits[ch][sb] = 16;
141 }
142 }
143
144 for (sb = 0; bitcount < frame->bitpool &&
145 sb < subbands; sb++) {
146 if ((bits[ch][sb] >= 2) && (bits[ch][sb] < 16)) {
147 bits[ch][sb]++;
148 bitcount++;
149 } else if ((bitneed[ch][sb] == bitslice + 1) && (frame->bitpool > bitcount + 1)) {
150 bits[ch][sb] = 2;
151 bitcount += 2;
152 }
153 }
154
155 for (sb = 0; bitcount < frame->bitpool &&
156 sb < subbands; sb++) {
157 if (bits[ch][sb] < 16) {
158 bits[ch][sb]++;
159 bitcount++;
160 }
161 }
162
163 }
164
165 } else if (frame->mode == STEREO || frame->mode == JOINT_STEREO) {
166 int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice;
167 int ch, sb;
168
169 max_bitneed = 0;
170 if (frame->allocation == SNR) {
171 for (ch = 0; ch < 2; ch++) {
172 for (sb = 0; sb < subbands; sb++) {
173 bitneed[ch][sb] = frame->scale_factor[ch][sb];
174 if (bitneed[ch][sb] > max_bitneed)
175 max_bitneed = bitneed[ch][sb];
176 }
177 }
178 } else {
179 for (ch = 0; ch < 2; ch++) {
180 for (sb = 0; sb < subbands; sb++) {
181 if (frame->scale_factor[ch][sb] == 0)
182 bitneed[ch][sb] = -5;
183 else {
184 if (subbands == 4)
185 loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb];
186 else
187 loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb];
188 if (loudness > 0)
189 bitneed[ch][sb] = loudness / 2;
190 else
191 bitneed[ch][sb] = loudness;
192 }
193 if (bitneed[ch][sb] > max_bitneed)
194 max_bitneed = bitneed[ch][sb];
195 }
196 }
197 }
198
199 bitcount = 0;
200 slicecount = 0;
201 bitslice = max_bitneed + 1;
202 do {
203 bitslice--;
204 bitcount += slicecount;
205 slicecount = 0;
206 for (ch = 0; ch < 2; ch++) {
207 for (sb = 0; sb < subbands; sb++) {
208 if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16))
209 slicecount++;
210 else if (bitneed[ch][sb] == bitslice + 1)
211 slicecount += 2;
212 }
213 }
214 } while (bitcount + slicecount < frame->bitpool);
215
216 if (bitcount + slicecount == frame->bitpool) {
217 bitcount += slicecount;
218 bitslice--;
219 }
220
221 for (ch = 0; ch < 2; ch++) {
222 for (sb = 0; sb < subbands; sb++) {
223 if (bitneed[ch][sb] < bitslice + 2) {
224 bits[ch][sb] = 0;
225 } else {
226 bits[ch][sb] = bitneed[ch][sb] - bitslice;
227 if (bits[ch][sb] > 16)
228 bits[ch][sb] = 16;
229 }
230 }
231 }
232
233 ch = 0;
234 sb = 0;
235 while (bitcount < frame->bitpool) {
236 if ((bits[ch][sb] >= 2) && (bits[ch][sb] < 16)) {
237 bits[ch][sb]++;
238 bitcount++;
239 } else if ((bitneed[ch][sb] == bitslice + 1) && (frame->bitpool > bitcount + 1)) {
240 bits[ch][sb] = 2;
241 bitcount += 2;
242 }
243 if (ch == 1) {
244 ch = 0;
245 sb++;
246 if (sb >= subbands)
247 break;
248 } else
249 ch = 1;
250 }
251
252 ch = 0;
253 sb = 0;
254 while (bitcount < frame->bitpool) {
255 if (bits[ch][sb] < 16) {
256 bits[ch][sb]++;
257 bitcount++;
258 }
259 if (ch == 1) {
260 ch = 0;
261 sb++;
262 if (sb >= subbands)
263 break;
264 } else
265 ch = 1;
266 }
267
268 }
269
270 }
271