1 /******************************************************************************
2 *
3 * Copyright 2022 Google LLC
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 #include "spec.h"
20 #include "bits.h"
21 #include "tables.h"
22
23
24 /* ----------------------------------------------------------------------------
25 * Global Gain / Quantization
26 * -------------------------------------------------------------------------- */
27
28 /**
29 * Resolve quantized gain index offset
30 * sr, nbytes Samplerate and size of the frame
31 * return Gain index offset
32 */
resolve_gain_offset(enum lc3_srate sr,int nbytes)33 static int resolve_gain_offset(enum lc3_srate sr, int nbytes)
34 {
35 int sr_ind = lc3_hr(sr) ? 4 + (sr - LC3_SRATE_48K_HR) : sr;
36
37 int g_off = (nbytes * 8) / (10 * (1 + sr_ind));
38 return LC3_MIN(sr >= LC3_SRATE_96K_HR ? 181 : 255,
39 105 + 5*(1 + sr_ind) + LC3_MIN(g_off, 115));
40 }
41
42 /**
43 * Unquantize gain
44 * g_int Quantization gain value
45 * return Unquantized gain value
46 */
unquantize_gain(int g_int)47 static float unquantize_gain(int g_int)
48 {
49 /* Unquantization gain table :
50 * G[i] = 10 ^ (i / 28) , i = [0..27] */
51
52 static const float iq_table[] = {
53 1.00000000e+00, 1.08571112e+00, 1.17876863e+00, 1.27980221e+00,
54 1.38949549e+00, 1.50859071e+00, 1.63789371e+00, 1.77827941e+00,
55 1.93069773e+00, 2.09617999e+00, 2.27584593e+00, 2.47091123e+00,
56 2.68269580e+00, 2.91263265e+00, 3.16227766e+00, 3.43332002e+00,
57 3.72759372e+00, 4.04708995e+00, 4.39397056e+00, 4.77058270e+00,
58 5.17947468e+00, 5.62341325e+00, 6.10540230e+00, 6.62870316e+00,
59 7.19685673e+00, 7.81370738e+00, 8.48342898e+00, 9.21055318e+00
60 };
61
62 float g = 1.f;
63
64 for ( ; g_int < 0; g_int += 28, g *= 0.1f);
65 for ( ; g_int >= 28; g_int -= 28, g *= 10.f);
66
67 return g * iq_table[g_int];
68 }
69
70 /**
71 * Global Gain Estimation
72 * dt, sr Duration and samplerate of the frame
73 * x Spectral coefficients
74 * nbytes Size of the frame
75 * nbits_budget Number of bits available coding the spectrum
76 * nbits_off Offset on the available bits, temporarily smoothed
77 * g_off Gain index offset
78 * reset_off Return True when the nbits_off must be reset
79 * g_min Return lower bound of quantized gain value
80 * return The quantized gain value
81 */
estimate_gain(enum lc3_dt dt,enum lc3_srate sr,const float * x,int nbytes,int nbits_budget,float nbits_off,int g_off,bool * reset_off,int * g_min)82 LC3_HOT static int estimate_gain(
83 enum lc3_dt dt, enum lc3_srate sr, const float *x,
84 int nbytes, int nbits_budget, float nbits_off, int g_off,
85 bool *reset_off, int *g_min)
86 {
87 int n4 = lc3_ne(dt, sr) / 4;
88 union { float f; int32_t q16; } e[LC3_MAX_NE / 4];
89
90 /* --- Signal adaptative noise floor --- */
91
92 int reg_bits = 0;
93 float low_bits = 0;
94
95 if (lc3_hr(sr)) {
96 int reg_c = (const int [LC3_NUM_DT][LC3_NUM_SRATE - LC3_SRATE_48K_HR]){
97 [LC3_DT_2M5] = { -6, -6 },
98 [LC3_DT_5M ] = { 0, 0 },
99 [LC3_DT_10M] = { 2, 5 }
100 }[dt][sr - LC3_SRATE_48K_HR];
101
102 reg_bits = (8*nbytes * 4) / (125 * (1 + dt));
103 reg_bits = LC3_CLIP(reg_bits + reg_c, 6, 23);
104
105 float m0 = 1e-5f, m1 = 1e-5f, k = 0;
106
107 for (int i = 0; i < n4; i++) {
108 m0 += fabsf(x[4*i + 0]), m1 += fabsf(x[4*i + 0]) * k++;
109 m0 += fabsf(x[4*i + 1]), m1 += fabsf(x[4*i + 1]) * k++;
110 m0 += fabsf(x[4*i + 2]), m1 += fabsf(x[4*i + 2]) * k++;
111 m0 += fabsf(x[4*i + 3]), m1 += fabsf(x[4*i + 3]) * k++;
112 }
113
114 int m = roundf((1.6f * m0) / ((1 + dt) * m1));
115 low_bits = 8 - LC3_MIN(m, 8);
116 }
117
118 /* --- Energy (dB) by 4 MDCT blocks --- */
119
120 float x2_max = 0;
121
122 for (int i = 0; i < n4; i++) {
123 float x0 = x[4*i + 0] * x[4*i + 0];
124 float x1 = x[4*i + 1] * x[4*i + 1];
125 float x2 = x[4*i + 2] * x[4*i + 2];
126 float x3 = x[4*i + 3] * x[4*i + 3];
127
128 x2_max = fmaxf(x2_max, x0);
129 x2_max = fmaxf(x2_max, x1);
130 x2_max = fmaxf(x2_max, x2);
131 x2_max = fmaxf(x2_max, x3);
132
133 e[i].f = x0 + x1 + x2 + x3;
134 }
135
136 float x_max = sqrtf(x2_max);
137 float nf = lc3_hr(sr) ?
138 lc3_ldexpf(x_max, -reg_bits) * lc3_exp2f(-low_bits) : 0;
139
140 for (int i = 0; i < n4; i++)
141 e[i].q16 = lc3_db_q16(fmaxf(e[i].f + nf, 1e-10f));
142
143 /* --- Determine gain index --- */
144
145 int nbits = nbits_budget + nbits_off + 0.5f;
146 int g_int = 255 - g_off;
147
148 const int k_20_28 = 20.f/28 * 0x1p16f + 0.5f;
149 const int k_2u7 = 2.7f * 0x1p16f + 0.5f;
150 const int k_1u4 = 1.4f * 0x1p16f + 0.5f;
151
152 for (int i = 128, j, j0 = n4-1, j1 ; i > 0; i >>= 1) {
153 int gn = (g_int - i) * k_20_28;
154 int v = 0;
155
156 for (j = j0; j >= 0 && e[j].q16 < gn; j--);
157
158 for (j1 = j; j >= 0; j--) {
159 int e_diff = e[j].q16 - gn;
160
161 v += e_diff < 0 ? k_2u7 :
162 e_diff < 43 << 16 ? e_diff + ( 7 << 16)
163 : 2*e_diff - (36 << 16);
164 }
165
166 if (v > nbits * k_1u4)
167 j0 = j1;
168 else
169 g_int = g_int - i;
170 }
171
172 /* --- Limit gain index --- */
173
174 float x_lim = lc3_hr(sr) ? 0x7fffp8f : 0x7fffp0f;
175
176 *g_min = 255 - g_off;
177 for (int i = 128 ; i > 0; i >>= 1)
178 if (x_lim * unquantize_gain(*g_min - i) > x_max)
179 *g_min -= i;
180
181 *reset_off = g_int < *g_min || x_max == 0;
182 if (*reset_off)
183 g_int = *g_min;
184
185 return g_int;
186 }
187
188 /**
189 * Global Gain Adjustment
190 * dt, sr Duration and samplerate of the frame
191 * g_idx The estimated quantized gain index
192 * nbits Computed number of bits coding the spectrum
193 * nbits_budget Number of bits available for coding the spectrum
194 * g_idx_min Minimum gain index value
195 * return Gain adjust value (-1 to 2)
196 */
adjust_gain(enum lc3_dt dt,enum lc3_srate sr,int g_idx,int nbits,int nbits_budget,int g_idx_min)197 LC3_HOT static int adjust_gain(
198 enum lc3_dt dt, enum lc3_srate sr,
199 int g_idx, int nbits, int nbits_budget, int g_idx_min)
200 {
201 /* --- Compute delta threshold --- */
202
203 const int *t = (const int [LC3_NUM_SRATE][3]){
204 { 80, 500, 850 }, { 230, 1025, 1700 }, { 380, 1550, 2550 },
205 { 530, 2075, 3400 }, { 680, 2600, 4250 },
206 { 680, 2600, 4250 }, { 830, 3125, 5100 }
207 }[sr];
208
209 int delta, den = 48;
210
211 if (nbits < t[0]) {
212 delta = 3*(nbits + 48);
213
214 } else if (nbits < t[1]) {
215 int n0 = 3*(t[0] + 48), range = t[1] - t[0];
216 delta = n0 * range + (nbits - t[0]) * (t[1] - n0);
217 den *= range;
218
219 } else {
220 delta = LC3_MIN(nbits, t[2]);
221 }
222
223 delta = (delta + den/2) / den;
224
225 /* --- Adjust gain --- */
226
227 if (lc3_hr(sr) && nbits > nbits_budget) {
228 int factor = 1 + (dt <= LC3_DT_5M) +
229 (dt <= LC3_DT_2M5) * (1 + (nbits >= 520));
230
231 int g_incr = factor + (factor * (nbits - nbits_budget)) / delta;
232 return LC3_MIN(g_idx + g_incr, 255) - g_idx;
233 }
234
235 if (!lc3_hr(sr) && nbits < nbits_budget - (delta + 2))
236 return -(g_idx > g_idx_min);
237
238 if (!lc3_hr(sr) && nbits > nbits_budget)
239 return (g_idx < 255) + (g_idx < 254 && nbits >= nbits_budget + delta);
240
241 return 0;
242 }
243
244 /**
245 * Spectrum quantization
246 * dt, sr Duration and samplerate of the frame
247 * g_int Quantization gain value
248 * x Spectral coefficients, scaled as output
249 * n Return count of significants
250 */
quantize(enum lc3_dt dt,enum lc3_srate sr,int g_int,float * x,int * n)251 LC3_HOT static void quantize(
252 enum lc3_dt dt, enum lc3_srate sr, int g_int, float *x, int *n)
253 {
254 float g_inv = unquantize_gain(-g_int);
255 int ne = lc3_ne(dt, sr);
256
257 *n = ne;
258
259 for (int i = 0; i < ne; i += 2) {
260 float xq_min = lc3_hr(sr) ? 0.5f : 10.f/16;
261
262 x[i+0] *= g_inv;
263 x[i+1] *= g_inv;
264
265 *n = fabsf(x[i+0]) >= xq_min ||
266 fabsf(x[i+1]) >= xq_min ? ne : *n - 2;
267 }
268 }
269
270 /**
271 * Spectrum quantization inverse
272 * dt, sr Duration and samplerate of the frame
273 * g_int Quantization gain value
274 * x, nq Spectral quantized, and count of significants
275 * return Unquantized gain value
276 */
unquantize(enum lc3_dt dt,enum lc3_srate sr,int g_int,float * x,int nq)277 LC3_HOT static float unquantize(
278 enum lc3_dt dt, enum lc3_srate sr,
279 int g_int, float *x, int nq)
280 {
281 float g = unquantize_gain(g_int);
282 int i, ne = lc3_ne(dt, sr);
283
284 for (i = 0; i < nq; i++)
285 x[i] = x[i] * g;
286
287 for ( ; i < ne; i++)
288 x[i] = 0;
289
290 return g;
291 }
292
293
294 /* ----------------------------------------------------------------------------
295 * Spectrum coding
296 * -------------------------------------------------------------------------- */
297
298 /**
299 * Resolve High-bitrate and LSB modes according size of the frame
300 * sr, nbytes Samplerate and size of the frame
301 * p_lsb_mode True when LSB mode allowed, when not NULL
302 * return True when High-Rate mode enabled
303 */
resolve_modes(enum lc3_srate sr,int nbytes,bool * p_lsb_mode)304 static bool resolve_modes(enum lc3_srate sr, int nbytes, bool *p_lsb_mode)
305 {
306 int sr_ind = lc3_hr(sr) ? 4 + (sr - LC3_SRATE_48K_HR) : sr;
307
308 if (p_lsb_mode)
309 *p_lsb_mode = (nbytes >= 20 * (3 + sr_ind)) && (sr < LC3_SRATE_96K_HR);
310
311 return (nbytes > 20 * (1 + sr_ind)) && (sr < LC3_SRATE_96K_HR);
312 }
313
314 /**
315 * Bit consumption
316 * dt, sr, nbytes Duration, samplerate and size of the frame
317 * x Spectral quantized coefficients
318 * n Count of significant coefficients, updated on truncation
319 * nbits_budget Truncate to stay in budget, when not zero
320 * p_lsb_mode Return True when LSB's are not AC coded, or NULL
321 * return The number of bits coding the spectrum
322 */
compute_nbits(enum lc3_dt dt,enum lc3_srate sr,int nbytes,const float * x,int * n,int nbits_budget,bool * p_lsb_mode)323 LC3_HOT static int compute_nbits(
324 enum lc3_dt dt, enum lc3_srate sr, int nbytes,
325 const float *x, int *n, int nbits_budget, bool *p_lsb_mode)
326 {
327 bool lsb_mode, high_rate = resolve_modes(sr, nbytes, &lsb_mode);
328 int ne = lc3_ne(dt, sr);
329
330 /* --- Loop on quantized coefficients --- */
331
332 int nbits = 0, nbits_lsb = 0;
333 uint8_t state = 0;
334
335 int nbits_end = 0;
336 int n_end = 0;
337
338 nbits_budget = nbits_budget ? nbits_budget * 2048 : INT_MAX;
339
340 for (int i = 0, h = 0; h < 2; h++) {
341 const uint8_t (*lut_coeff)[4] = lc3_spectrum_lookup[high_rate][h];
342
343 for ( ; i < LC3_MIN(*n, (ne + 2) >> (1 - h))
344 && nbits <= nbits_budget; i += 2) {
345
346 float xq_off = lc3_hr(sr) ? 0.5f : 6.f/16;
347 uint32_t a = fabsf(x[i+0]) + xq_off;
348 uint32_t b = fabsf(x[i+1]) + xq_off;
349
350 const uint8_t *lut = lut_coeff[state];
351
352 /* --- Sign values --- */
353
354 int s = (a != 0) + (b != 0);
355 nbits += s * 2048;
356
357 /* --- LSB values Reduce to 2*2 bits MSB values ---
358 * Reduce to 2x2 bits MSB values. The LSB's pair are arithmetic
359 * coded with an escape code followed by 1 bit for each values.
360 * The LSB mode does not arthmetic code the first LSB,
361 * add the sign of the LSB when one of pair was at value 1 */
362
363 uint32_t m = (a | b) >> 2;
364 unsigned k = 0;
365
366 if (m) {
367
368 if (lsb_mode) {
369 nbits += lc3_spectrum_bits[lut[k++]][16] - 2*2048;
370 nbits_lsb += 2 + (a == 1) + (b == 1);
371 }
372
373 for (m >>= lsb_mode; m; m >>= 1, k++)
374 nbits += lc3_spectrum_bits[lut[LC3_MIN(k, 3)]][16];
375
376 nbits += k * 2*2048;
377 a >>= k;
378 b >>= k;
379
380 k = LC3_MIN(k, 3);
381 }
382
383 /* --- MSB values --- */
384
385 nbits += lc3_spectrum_bits[lut[k]][a + 4*b];
386
387 /* --- Update state --- */
388
389 if (s && nbits <= nbits_budget) {
390 n_end = i + 2;
391 nbits_end = nbits;
392 }
393
394 state = (state << 4) + (k > 1 ? 12 + k : 1 + (a + b) * (k + 1));
395 }
396 }
397
398 /* --- Return --- */
399
400 *n = n_end;
401
402 if (p_lsb_mode)
403 *p_lsb_mode = lsb_mode &&
404 nbits_end + nbits_lsb * 2048 > nbits_budget;
405
406 if (nbits_budget >= INT_MAX)
407 nbits_end += nbits_lsb * 2048;
408
409 return (nbits_end + 2047) / 2048;
410 }
411
412 /**
413 * Put quantized spectrum
414 * bits Bitstream context
415 * dt, sr, nbytes Duration, samplerate and size of the frame
416 * x Spectral quantized coefficients
417 * nq, lsb_mode Count of significants, and LSB discard indication
418 */
put_quantized(lc3_bits_t * bits,enum lc3_dt dt,enum lc3_srate sr,int nbytes,const float * x,int nq,bool lsb_mode)419 LC3_HOT static void put_quantized(lc3_bits_t *bits,
420 enum lc3_dt dt, enum lc3_srate sr, int nbytes,
421 const float *x, int nq, bool lsb_mode)
422 {
423 bool high_rate = resolve_modes(sr, nbytes, NULL);
424 int ne = lc3_ne(dt, sr);
425
426 /* --- Loop on quantized coefficients --- */
427
428 uint8_t state = 0;
429
430 for (int i = 0, h = 0; h < 2; h++) {
431 const uint8_t (*lut_coeff)[4] = lc3_spectrum_lookup[high_rate][h];
432
433 for ( ; i < LC3_MIN(nq, (ne + 2) >> (1 - h)); i += 2) {
434
435 float xq_off = lc3_hr(sr) ? 0.5f : 6.f/16;
436 uint32_t a = fabsf(x[i+0]) + xq_off;
437 uint32_t b = fabsf(x[i+1]) + xq_off;
438
439 const uint8_t *lut = lut_coeff[state];
440
441 /* --- LSB values Reduce to 2*2 bits MSB values ---
442 * Reduce to 2x2 bits MSB values. The LSB's pair are arithmetic
443 * coded with an escape code and 1 bits for each values.
444 * The LSB mode discard the first LSB (at this step) */
445
446 uint32_t m = (a | b) >> 2;
447 unsigned k = 0, shr = 0;
448
449 if (m) {
450
451 if (lsb_mode)
452 lc3_put_symbol(bits,
453 lc3_spectrum_models + lut[k++], 16);
454
455 for (m >>= lsb_mode; m; m >>= 1, k++) {
456 lc3_put_bit(bits, (a >> k) & 1);
457 lc3_put_bit(bits, (b >> k) & 1);
458 lc3_put_symbol(bits,
459 lc3_spectrum_models + lut[LC3_MIN(k, 3)], 16);
460 }
461
462 a >>= lsb_mode;
463 b >>= lsb_mode;
464
465 shr = k - lsb_mode;
466 k = LC3_MIN(k, 3);
467 }
468
469 /* --- Sign values --- */
470
471 if (a) lc3_put_bit(bits, x[i+0] < 0);
472 if (b) lc3_put_bit(bits, x[i+1] < 0);
473
474 /* --- MSB values --- */
475
476 a >>= shr;
477 b >>= shr;
478
479 lc3_put_symbol(bits, lc3_spectrum_models + lut[k], a + 4*b);
480
481 /* --- Update state --- */
482
483 state = (state << 4) + (k > 1 ? 12 + k : 1 + (a + b) * (k + 1));
484 }
485 }
486 }
487
488 /**
489 * Get quantized spectrum
490 * bits Bitstream context
491 * dt, sr, nbytes Duration, samplerate and size of the frame
492 * nq, lsb_mode Count of significants, and LSB discard indication
493 * x Return `nq` spectral quantized coefficients
494 * nf_seed Return the noise factor seed associated
495 * return 0: Ok -1: Invalid bitstream data
496 */
get_quantized(lc3_bits_t * bits,enum lc3_dt dt,enum lc3_srate sr,int nbytes,int nq,bool lsb_mode,float * x,uint16_t * nf_seed)497 LC3_HOT static int get_quantized(lc3_bits_t *bits,
498 enum lc3_dt dt, enum lc3_srate sr, int nbytes,
499 int nq, bool lsb_mode, float *x, uint16_t *nf_seed)
500 {
501 bool high_rate = resolve_modes(sr, nbytes, NULL);
502 int ne = lc3_ne(dt, sr);
503
504 *nf_seed = 0;
505
506 /* --- Loop on quantized coefficients --- */
507
508 uint8_t state = 0;
509
510 for (int i = 0, h = 0; h < 2; h++) {
511 const uint8_t (*lut_coeff)[4] = lc3_spectrum_lookup[high_rate][h];
512
513 for ( ; i < LC3_MIN(nq, (ne + 2) >> (1 - h)); i += 2) {
514
515 const uint8_t *lut = lut_coeff[state];
516 int max_shl = lc3_hr(sr) ? 22 : 14;
517
518 /* --- LSB values ---
519 * Until the symbol read indicates the escape value 16,
520 * read an LSB bit for each values.
521 * The LSB mode discard the first LSB (at this step) */
522
523 int u = 0, v = 0;
524 int k = 0, shl = 0;
525
526 unsigned s = lc3_get_symbol(bits, lc3_spectrum_models + lut[k]);
527
528 if (lsb_mode && s >= 16) {
529 s = lc3_get_symbol(bits, lc3_spectrum_models + lut[++k]);
530 shl++;
531 }
532
533 for ( ; s >= 16 && shl < max_shl; shl++) {
534 u |= lc3_get_bit(bits) << shl;
535 v |= lc3_get_bit(bits) << shl;
536
537 k += (k < 3);
538 s = lc3_get_symbol(bits, lc3_spectrum_models + lut[k]);
539 }
540
541 if (s >= 16)
542 return -1;
543
544 /* --- MSB & sign values --- */
545
546 int a = s % 4;
547 int b = s / 4;
548
549 u |= a << shl;
550 v |= b << shl;
551
552 x[i+0] = u && lc3_get_bit(bits) ? -u : u;
553 x[i+1] = v && lc3_get_bit(bits) ? -v : v;
554
555 *nf_seed = (*nf_seed + (u & 0x7fff) * (i )
556 + (v & 0x7fff) * (i+1)) & 0xffff;
557
558 /* --- Update state --- */
559
560 state = (state << 4) + (k > 1 ? 12 + k : 1 + (a + b) * (k + 1));
561 }
562 }
563
564 return 0;
565 }
566
567 /**
568 * Put residual bits of quantization
569 * bits Bitstream context
570 * nbits Maximum number of bits to output
571 * hrmode High-Resolution mode
572 * x, n Spectral quantized, and count of significants
573 */
put_residual(lc3_bits_t * bits,int nbits,bool hrmode,float * x,int n)574 LC3_HOT static void put_residual(lc3_bits_t *bits,
575 int nbits, bool hrmode, float *x, int n)
576 {
577 float xq_lim = hrmode ? 0.5f : 10.f/16;
578 float xq_off = xq_lim / 2;
579
580 for (int iter = 0; iter < (hrmode ? 20 : 1) && nbits > 0; iter++) {
581 for (int i = 0; i < n && nbits > 0; i++) {
582
583 float xr = fabsf(x[i]);
584 if (xr < xq_lim)
585 continue;
586
587 bool b = (xr - truncf(xr) < xq_lim) ^ (x[i] < 0);
588 lc3_put_bit(bits, b);
589 nbits--;
590
591 x[i] += b ? -xq_off : xq_off;
592 }
593
594 xq_off *= xq_lim;
595 }
596 }
597
598 /**
599 * Get residual bits of quantization
600 * bits Bitstream context
601 * nbits Maximum number of bits to output
602 * hrmode High-Resolution mode
603 * x, nq Spectral quantized, and count of significants
604 */
get_residual(lc3_bits_t * bits,int nbits,bool hrmode,float * x,int n)605 LC3_HOT static void get_residual(lc3_bits_t *bits,
606 int nbits, bool hrmode, float *x, int n)
607 {
608 float xq_off_1 = hrmode ? 0.25f : 5.f/16;
609 float xq_off_2 = hrmode ? 0.25f : 3.f/16;
610
611 for (int iter = 0; iter < (hrmode ? 20 : 1) && nbits > 0; iter++) {
612 for (int i = 0; i < n && nbits > 0; i++) {
613
614 if (x[i] == 0)
615 continue;
616
617 if (lc3_get_bit(bits) == 0)
618 x[i] -= x[i] < 0 ? xq_off_1 : xq_off_2;
619 else
620 x[i] += x[i] > 0 ? xq_off_1 : xq_off_2;
621
622 nbits--;
623 }
624
625 xq_off_1 *= 0.5f;
626 xq_off_2 *= 0.5f;
627 }
628 }
629
630 /**
631 * Put LSB values of quantized spectrum values
632 * bits Bitstream context
633 * nbits Maximum number of bits to output
634 * hrmode High-Resolution mode
635 * x, n Spectral quantized, and count of significants
636 */
put_lsb(lc3_bits_t * bits,int nbits,bool hrmode,const float * x,int n)637 LC3_HOT static void put_lsb(lc3_bits_t *bits,
638 int nbits, bool hrmode, const float *x, int n)
639 {
640 for (int i = 0; i < n && nbits > 0; i += 2) {
641
642 float xq_off = hrmode ? 0.5f : 6.f/16;
643 uint32_t a = fabsf(x[i+0]) + xq_off;
644 uint32_t b = fabsf(x[i+1]) + xq_off;
645
646 if ((a | b) >> 2 == 0)
647 continue;
648
649 if (nbits-- > 0)
650 lc3_put_bit(bits, a & 1);
651
652 if (a == 1 && nbits-- > 0)
653 lc3_put_bit(bits, x[i+0] < 0);
654
655 if (nbits-- > 0)
656 lc3_put_bit(bits, b & 1);
657
658 if (b == 1 && nbits-- > 0)
659 lc3_put_bit(bits, x[i+1] < 0);
660 }
661 }
662
663 /**
664 * Get LSB values of quantized spectrum values
665 * bits Bitstream context
666 * nbits Maximum number of bits to output
667 * x, nq Spectral quantized, and count of significants
668 * nf_seed Update the noise factor seed according
669 */
get_lsb(lc3_bits_t * bits,int nbits,float * x,int nq,uint16_t * nf_seed)670 LC3_HOT static void get_lsb(lc3_bits_t *bits,
671 int nbits, float *x, int nq, uint16_t *nf_seed)
672 {
673 for (int i = 0; i < nq && nbits > 0; i += 2) {
674
675 float a = fabsf(x[i]), b = fabsf(x[i+1]);
676
677 if (fmaxf(a, b) < 4)
678 continue;
679
680 if (nbits-- > 0 && lc3_get_bit(bits)) {
681 if (a) {
682 x[i] += x[i] < 0 ? -1 : 1;
683 *nf_seed = (*nf_seed + i) & 0xffff;
684 } else if (nbits-- > 0) {
685 x[i] = lc3_get_bit(bits) ? -1 : 1;
686 *nf_seed = (*nf_seed + i) & 0xffff;
687 }
688 }
689
690 if (nbits-- > 0 && lc3_get_bit(bits)) {
691 if (b) {
692 x[i+1] += x[i+1] < 0 ? -1 : 1;
693 *nf_seed = (*nf_seed + i+1) & 0xffff;
694 } else if (nbits-- > 0) {
695 x[i+1] = lc3_get_bit(bits) ? -1 : 1;
696 *nf_seed = (*nf_seed + i+1) & 0xffff;
697 }
698 }
699 }
700 }
701
702
703 /* ----------------------------------------------------------------------------
704 * Noise coding
705 * -------------------------------------------------------------------------- */
706
707 /**
708 * Estimate noise level
709 * dt, bw Duration and bandwidth of the frame
710 * hrmode High-Resolution mode
711 * x, n Spectral quantized, and count of significants
712 * return Noise factor (0 to 7)
713 */
estimate_noise(enum lc3_dt dt,enum lc3_bandwidth bw,bool hrmode,const float * x,int n)714 LC3_HOT static int estimate_noise(
715 enum lc3_dt dt, enum lc3_bandwidth bw, bool hrmode, const float *x, int n)
716 {
717 int bw_stop = lc3_ne(dt, (enum lc3_srate)LC3_MIN(bw, LC3_BANDWIDTH_FB));
718 int w = 1 + (dt >= LC3_DT_7M5) + (dt>= LC3_DT_10M);
719
720 float xq_lim = hrmode ? 0.5f : 10.f/16;
721 float sum = 0;
722 int i, ns = 0, z = 0;
723
724 for (i = 6 * (1 + dt) - w; i < LC3_MIN(n, bw_stop); i++) {
725 z = fabsf(x[i]) < xq_lim ? z + 1 : 0;
726 if (z > 2*w)
727 sum += fabsf(x[i - w]), ns++;
728 }
729
730 for ( ; i < bw_stop + w; i++)
731 if (++z > 2*w)
732 sum += fabsf(x[i - w]), ns++;
733
734 int nf = ns ? 8 - (int)((16 * sum) / ns + 0.5f) : 8;
735
736 return LC3_CLIP(nf, 0, 7);
737 }
738
739 /**
740 * Noise filling
741 * dt, bw Duration and bandwidth of the frame
742 * nf, nf_seed The noise factor and pseudo-random seed
743 * g Quantization gain
744 * x, nq Spectral quantized, and count of significants
745 */
fill_noise(enum lc3_dt dt,enum lc3_bandwidth bw,int nf,uint16_t nf_seed,float g,float * x,int nq)746 LC3_HOT static void fill_noise(enum lc3_dt dt, enum lc3_bandwidth bw,
747 int nf, uint16_t nf_seed, float g, float *x, int nq)
748 {
749 int bw_stop = lc3_ne(dt, (enum lc3_srate)LC3_MIN(bw, LC3_BANDWIDTH_FB));
750 int w = 1 + (dt >= LC3_DT_7M5) + (dt>= LC3_DT_10M);
751
752 float s = g * (float)(8 - nf) / 16;
753 int i, z = 0;
754
755 for (i = 6 * (1 + dt) - w; i < LC3_MIN(nq, bw_stop); i++) {
756 z = x[i] ? 0 : z + 1;
757 if (z > 2*w) {
758 nf_seed = (13849 + nf_seed*31821) & 0xffff;
759 x[i - w] = nf_seed & 0x8000 ? -s : s;
760 }
761 }
762
763 for ( ; i < bw_stop + w; i++)
764 if (++z > 2*w) {
765 nf_seed = (13849 + nf_seed*31821) & 0xffff;
766 x[i - w] = nf_seed & 0x8000 ? -s : s;
767 }
768 }
769
770 /**
771 * Put noise factor
772 * bits Bitstream context
773 * nf Noise factor (0 to 7)
774 */
put_noise_factor(lc3_bits_t * bits,int nf)775 static void put_noise_factor(lc3_bits_t *bits, int nf)
776 {
777 lc3_put_bits(bits, nf, 3);
778 }
779
780 /**
781 * Get noise factor
782 * bits Bitstream context
783 * return Noise factor (0 to 7)
784 */
get_noise_factor(lc3_bits_t * bits)785 static int get_noise_factor(lc3_bits_t *bits)
786 {
787 return lc3_get_bits(bits, 3);
788 }
789
790
791 /* ----------------------------------------------------------------------------
792 * Encoding
793 * -------------------------------------------------------------------------- */
794
795 /**
796 * Bit consumption of the number of coded coefficients
797 * dt, sr, nbytes Duration, samplerate and size of the frame
798 * return Bit consumpution of the number of coded coefficients
799 */
get_nbits_nq(enum lc3_dt dt,enum lc3_srate sr)800 static int get_nbits_nq(enum lc3_dt dt, enum lc3_srate sr)
801 {
802 int ne = lc3_ne(dt, sr);
803 return 4 + (ne > 32) + (ne > 64) + (ne > 128) + (ne > 256) + (ne > 512);
804 }
805
806 /**
807 * Bit consumption of the arithmetic coder
808 * dt, sr, nbytes Duration, samplerate and size of the frame
809 * return Bit consumption of bitstream data
810 */
get_nbits_ac(enum lc3_dt dt,enum lc3_srate sr,int nbytes)811 static int get_nbits_ac(enum lc3_dt dt, enum lc3_srate sr, int nbytes)
812 {
813 return get_nbits_nq(dt, sr) +
814 3 + lc3_hr(sr) + LC3_MIN((nbytes-1) / 160, 2);
815 }
816
817 /**
818 * Spectrum analysis
819 */
lc3_spec_analyze(enum lc3_dt dt,enum lc3_srate sr,int nbytes,bool pitch,const lc3_tns_data_t * tns,struct lc3_spec_analysis * spec,float * x,struct lc3_spec_side * side)820 void lc3_spec_analyze(
821 enum lc3_dt dt, enum lc3_srate sr, int nbytes,
822 bool pitch, const lc3_tns_data_t *tns,
823 struct lc3_spec_analysis *spec,
824 float *x, struct lc3_spec_side *side)
825 {
826 bool reset_off;
827
828 /* --- Bit budget --- */
829
830 const int nbits_gain = 8;
831 const int nbits_nf = 3;
832
833 int nbits_budget = 8*nbytes - get_nbits_ac(dt, sr, nbytes) -
834 lc3_bwdet_get_nbits(sr) - lc3_ltpf_get_nbits(pitch) -
835 lc3_sns_get_nbits() - lc3_tns_get_nbits(tns) - nbits_gain - nbits_nf;
836
837 /* --- Global gain --- */
838
839 float nbits_off = spec->nbits_off + spec->nbits_spare;
840 nbits_off = fminf(fmaxf(nbits_off, -40), 40);
841 nbits_off = 0.8f * spec->nbits_off + 0.2f * nbits_off;
842
843 int g_off = resolve_gain_offset(sr, nbytes);
844
845 int g_min, g_int = estimate_gain(dt, sr,
846 x, nbytes, nbits_budget, nbits_off, g_off, &reset_off, &g_min);
847
848 /* --- Quantization --- */
849
850 quantize(dt, sr, g_int, x, &side->nq);
851
852 int nbits = compute_nbits(dt, sr, nbytes, x, &side->nq, 0, NULL);
853
854 spec->nbits_off = reset_off ? 0 : nbits_off;
855 spec->nbits_spare = reset_off ? 0 : nbits_budget - nbits;
856
857 /* --- Adjust gain and requantize --- */
858
859 int g_adj = adjust_gain(dt, sr,
860 g_off + g_int, nbits, nbits_budget, g_off + g_min);
861
862 if (g_adj)
863 quantize(dt, sr, g_adj, x, &side->nq);
864
865 side->g_idx = g_int + g_adj + g_off;
866 nbits = compute_nbits(dt, sr, nbytes,
867 x, &side->nq, nbits_budget, &side->lsb_mode);
868 }
869
870 /**
871 * Put spectral quantization side data
872 */
lc3_spec_put_side(lc3_bits_t * bits,enum lc3_dt dt,enum lc3_srate sr,const struct lc3_spec_side * side)873 void lc3_spec_put_side(lc3_bits_t *bits,
874 enum lc3_dt dt, enum lc3_srate sr,
875 const struct lc3_spec_side *side)
876 {
877 int nbits_nq = get_nbits_nq(dt, sr);
878
879 lc3_put_bits(bits, LC3_MAX(side->nq >> 1, 1) - 1, nbits_nq);
880 lc3_put_bits(bits, side->lsb_mode, 1);
881 lc3_put_bits(bits, side->g_idx, 8);
882 }
883
884 /**
885 * Encode spectral coefficients
886 */
lc3_spec_encode(lc3_bits_t * bits,enum lc3_dt dt,enum lc3_srate sr,enum lc3_bandwidth bw,int nbytes,const lc3_spec_side_t * side,float * x)887 void lc3_spec_encode(lc3_bits_t *bits,
888 enum lc3_dt dt, enum lc3_srate sr, enum lc3_bandwidth bw,
889 int nbytes, const lc3_spec_side_t *side, float *x)
890 {
891 bool lsb_mode = side->lsb_mode;
892 int nq = side->nq;
893
894 put_noise_factor(bits, estimate_noise(dt, bw, lc3_hr(sr), x, nq));
895
896 put_quantized(bits, dt, sr, nbytes, x, nq, lsb_mode);
897
898 int nbits_left = lc3_get_bits_left(bits);
899
900 if (lsb_mode)
901 put_lsb(bits, nbits_left, lc3_hr(sr), x, nq);
902 else
903 put_residual(bits, nbits_left, lc3_hr(sr), x, nq);
904 }
905
906
907 /* ----------------------------------------------------------------------------
908 * Decoding
909 * -------------------------------------------------------------------------- */
910
911 /**
912 * Get spectral quantization side data
913 */
lc3_spec_get_side(lc3_bits_t * bits,enum lc3_dt dt,enum lc3_srate sr,struct lc3_spec_side * side)914 int lc3_spec_get_side(lc3_bits_t *bits,
915 enum lc3_dt dt, enum lc3_srate sr, struct lc3_spec_side *side)
916 {
917 int nbits_nq = get_nbits_nq(dt, sr);
918 int ne = lc3_ne(dt, sr);
919
920 side->nq = (lc3_get_bits(bits, nbits_nq) + 1) << 1;
921 side->lsb_mode = lc3_get_bit(bits);
922 side->g_idx = lc3_get_bits(bits, 8);
923
924 return side->nq > ne ? (side->nq = ne), -1 : 0;
925 }
926
927 /**
928 * Decode spectral coefficients
929 */
lc3_spec_decode(lc3_bits_t * bits,enum lc3_dt dt,enum lc3_srate sr,enum lc3_bandwidth bw,int nbytes,const lc3_spec_side_t * side,float * x)930 int lc3_spec_decode(lc3_bits_t *bits,
931 enum lc3_dt dt, enum lc3_srate sr, enum lc3_bandwidth bw,
932 int nbytes, const lc3_spec_side_t *side, float *x)
933 {
934 bool lsb_mode = side->lsb_mode;
935 int nq = side->nq;
936 int ret = 0;
937
938 int nf = get_noise_factor(bits);
939 uint16_t nf_seed;
940
941 if ((ret = get_quantized(bits, dt, sr, nbytes,
942 nq, lsb_mode, x, &nf_seed)) < 0)
943 return ret;
944
945 int nbits_left = lc3_get_bits_left(bits);
946
947 if (lsb_mode)
948 get_lsb(bits, nbits_left, x, nq, &nf_seed);
949 else
950 get_residual(bits, nbits_left, lc3_hr(sr), x, nq);
951
952 int g_int = side->g_idx - resolve_gain_offset(sr, nbytes);
953 float g = unquantize(dt, sr, g_int, x, nq);
954
955 if (nq > 2 || x[0] || x[1] || side->g_idx > 0 || nf < 7)
956 fill_noise(dt, bw, nf, nf_seed, g, x, nq);
957
958 return 0;
959 }
960
