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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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