rate.c (29415B)
1 /* Copyright (c) 2007-2008 CSIRO 2 Copyright (c) 2007-2009 Xiph.Org Foundation 3 Written by Jean-Marc Valin */ 4 /* 5 Redistribution and use in source and binary forms, with or without 6 modification, are permitted provided that the following conditions 7 are met: 8 9 - Redistributions of source code must retain the above copyright 10 notice, this list of conditions and the following disclaimer. 11 12 - Redistributions in binary form must reproduce the above copyright 13 notice, this list of conditions and the following disclaimer in the 14 documentation and/or other materials provided with the distribution. 15 16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 20 OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 21 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 22 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 23 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 24 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 25 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 26 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #ifdef HAVE_CONFIG_H 30 #include "config.h" 31 #endif 32 33 #include <math.h> 34 #include "modes.h" 35 #include "cwrs.h" 36 #include "arch.h" 37 #include "os_support.h" 38 39 #include "entcode.h" 40 #include "rate.h" 41 #include "quant_bands.h" 42 43 static const unsigned char LOG2_FRAC_TABLE[24]={ 44 0, 45 8,13, 46 16,19,21,23, 47 24,26,27,28,29,30,31,32, 48 32,33,34,34,35,36,36,37,37 49 }; 50 51 #if defined(CUSTOM_MODES) 52 53 /*Determines if V(N,K) fits in a 32-bit unsigned integer. 54 N and K are themselves limited to 15 bits.*/ 55 static int fits_in32(int _n, int _k) 56 { 57 static const opus_int16 maxN[15] = { 58 32767, 32767, 32767, 1476, 283, 109, 60, 40, 59 29, 24, 20, 18, 16, 14, 13}; 60 static const opus_int16 maxK[15] = { 61 32767, 32767, 32767, 32767, 1172, 238, 95, 53, 62 36, 27, 22, 18, 16, 15, 13}; 63 if (_n>=14) 64 { 65 if (_k>=14) 66 return 0; 67 else 68 return _n <= maxN[_k]; 69 } else { 70 return _k <= maxK[_n]; 71 } 72 } 73 74 void compute_pulse_cache(CELTMode *m, int LM) 75 { 76 int C; 77 int i; 78 int j; 79 int curr=0; 80 int nbEntries=0; 81 int entryN[100], entryK[100], entryI[100]; 82 const opus_int16 *eBands = m->eBands; 83 PulseCache *cache = &m->cache; 84 opus_int16 *cindex; 85 unsigned char *bits; 86 unsigned char *cap; 87 88 cindex = (opus_int16 *)opus_alloc(sizeof(cache->index[0])*m->nbEBands*(LM+2)); 89 cache->index = cindex; 90 91 /* Scan for all unique band sizes */ 92 for (i=0;i<=LM+1;i++) 93 { 94 for (j=0;j<m->nbEBands;j++) 95 { 96 int k; 97 int N = (eBands[j+1]-eBands[j])<<i>>1; 98 cindex[i*m->nbEBands+j] = -1; 99 /* Find other bands that have the same size */ 100 for (k=0;k<=i;k++) 101 { 102 int n; 103 for (n=0;n<m->nbEBands && (k!=i || n<j);n++) 104 { 105 if (N == (eBands[n+1]-eBands[n])<<k>>1) 106 { 107 cindex[i*m->nbEBands+j] = cindex[k*m->nbEBands+n]; 108 break; 109 } 110 } 111 } 112 if (cache->index[i*m->nbEBands+j] == -1 && N!=0) 113 { 114 int K; 115 entryN[nbEntries] = N; 116 K = 0; 117 while (fits_in32(N,get_pulses(K+1)) && K<MAX_PSEUDO) 118 K++; 119 entryK[nbEntries] = K; 120 cindex[i*m->nbEBands+j] = curr; 121 entryI[nbEntries] = curr; 122 123 curr += K+1; 124 nbEntries++; 125 } 126 } 127 } 128 bits = (unsigned char *)opus_alloc(sizeof(unsigned char)*curr); 129 cache->bits = bits; 130 cache->size = curr; 131 /* Compute the cache for all unique sizes */ 132 for (i=0;i<nbEntries;i++) 133 { 134 unsigned char *ptr = bits+entryI[i]; 135 opus_int16 tmp[CELT_MAX_PULSES+1]; 136 get_required_bits(tmp, entryN[i], get_pulses(entryK[i]), BITRES); 137 for (j=1;j<=entryK[i];j++) 138 ptr[j] = tmp[get_pulses(j)]-1; 139 ptr[0] = entryK[i]; 140 } 141 142 /* Compute the maximum rate for each band at which we'll reliably use as 143 many bits as we ask for. */ 144 cache->caps = cap = (unsigned char *)opus_alloc(sizeof(cache->caps[0])*(LM+1)*2*m->nbEBands); 145 for (i=0;i<=LM;i++) 146 { 147 for (C=1;C<=2;C++) 148 { 149 for (j=0;j<m->nbEBands;j++) 150 { 151 int N0; 152 int max_bits; 153 N0 = m->eBands[j+1]-m->eBands[j]; 154 /* N=1 bands only have a sign bit and fine bits. */ 155 if (N0<<i == 1) 156 max_bits = C*(1+MAX_FINE_BITS)<<BITRES; 157 else 158 { 159 const unsigned char *pcache; 160 opus_int32 num; 161 opus_int32 den; 162 int LM0; 163 int N; 164 int offset; 165 int ndof; 166 int qb; 167 int k; 168 LM0 = 0; 169 /* Even-sized bands bigger than N=2 can be split one more time. 170 As of commit 44203907 all bands >1 are even, including custom modes.*/ 171 if (N0 > 2) 172 { 173 N0>>=1; 174 LM0--; 175 } 176 /* N0=1 bands can't be split down to N<2. */ 177 else if (N0 <= 1) 178 { 179 LM0=IMIN(i,1); 180 N0<<=LM0; 181 } 182 /* Compute the cost for the lowest-level PVQ of a fully split 183 band. */ 184 pcache = bits + cindex[(LM0+1)*m->nbEBands+j]; 185 max_bits = pcache[pcache[0]]+1; 186 /* Add in the cost of coding regular splits. */ 187 N = N0; 188 for(k=0;k<i-LM0;k++){ 189 max_bits <<= 1; 190 /* Offset the number of qtheta bits by log2(N)/2 191 + QTHETA_OFFSET compared to their "fair share" of 192 total/N */ 193 offset = ((m->logN[j]+(opus_int32)((opus_uint32)(LM0+k)<<BITRES))>>1)-QTHETA_OFFSET; 194 /* The number of qtheta bits we'll allocate if the remainder 195 is to be max_bits. 196 The average measured cost for theta is 0.89701 times qb, 197 approximated here as 459/512. */ 198 num=459*(opus_int32)((2*N-1)*offset+max_bits); 199 den=((opus_int32)(2*N-1)<<9)-459; 200 qb = IMIN((num+(den>>1))/den, 57); 201 celt_assert(qb >= 0); 202 max_bits += qb; 203 N <<= 1; 204 } 205 /* Add in the cost of a stereo split, if necessary. */ 206 if (C==2) 207 { 208 max_bits <<= 1; 209 offset = ((m->logN[j]+(i<<BITRES))>>1)-(N==2?QTHETA_OFFSET_TWOPHASE:QTHETA_OFFSET); 210 ndof = 2*N-1-(N==2); 211 /* The average measured cost for theta with the step PDF is 212 0.95164 times qb, approximated here as 487/512. */ 213 num = (N==2?512:487)*(opus_int32)(max_bits+ndof*offset); 214 den = ((opus_int32)ndof<<9)-(N==2?512:487); 215 qb = IMIN((num+(den>>1))/den, (N==2?64:61)); 216 celt_assert(qb >= 0); 217 max_bits += qb; 218 } 219 /* Add the fine bits we'll use. */ 220 /* Compensate for the extra DoF in stereo */ 221 ndof = C*N + ((C==2 && N>2) ? 1 : 0); 222 /* Offset the number of fine bits by log2(N)/2 + FINE_OFFSET 223 compared to their "fair share" of total/N */ 224 offset = ((m->logN[j] + (i<<BITRES))>>1)-FINE_OFFSET; 225 /* N=2 is the only point that doesn't match the curve */ 226 if (N==2) 227 offset += 1<<BITRES>>2; 228 /* The number of fine bits we'll allocate if the remainder is 229 to be max_bits. */ 230 num = max_bits+ndof*offset; 231 den = (ndof-1)<<BITRES; 232 qb = IMIN((num+(den>>1))/den, MAX_FINE_BITS); 233 celt_assert(qb >= 0); 234 max_bits += C*qb<<BITRES; 235 } 236 max_bits = (4*max_bits/(C*((m->eBands[j+1]-m->eBands[j])<<i)))-64; 237 celt_assert(max_bits >= 0); 238 celt_assert(max_bits < 256); 239 *cap++ = (unsigned char)max_bits; 240 } 241 } 242 } 243 } 244 245 #endif /* CUSTOM_MODES */ 246 247 #define ALLOC_STEPS 6 248 249 static OPUS_INLINE int interp_bits2pulses(const CELTMode *m, int start, int end, int skip_start, 250 const int *bits1, const int *bits2, const int *thresh, const int *cap, opus_int32 total, opus_int32 *_balance, 251 int skip_rsv, int *intensity, int intensity_rsv, int *dual_stereo, int dual_stereo_rsv, int *bits, 252 int *ebits, int *fine_priority, int C, int LM, ec_ctx *ec, int encode, int prev, int signalBandwidth) 253 { 254 opus_int32 psum; 255 int lo, hi; 256 int i, j; 257 int logM; 258 int stereo; 259 int codedBands=-1; 260 int alloc_floor; 261 opus_int32 left, percoeff; 262 int done; 263 opus_int32 balance; 264 SAVE_STACK; 265 266 alloc_floor = C<<BITRES; 267 stereo = C>1; 268 269 logM = LM<<BITRES; 270 lo = 0; 271 hi = 1<<ALLOC_STEPS; 272 for (i=0;i<ALLOC_STEPS;i++) 273 { 274 int mid = (lo+hi)>>1; 275 psum = 0; 276 done = 0; 277 for (j=end;j-->start;) 278 { 279 int tmp = bits1[j] + (mid*(opus_int32)bits2[j]>>ALLOC_STEPS); 280 if (tmp >= thresh[j] || done) 281 { 282 done = 1; 283 /* Don't allocate more than we can actually use */ 284 psum += IMIN(tmp, cap[j]); 285 } else { 286 if (tmp >= alloc_floor) 287 psum += alloc_floor; 288 } 289 } 290 if (psum > total) 291 hi = mid; 292 else 293 lo = mid; 294 } 295 psum = 0; 296 /*printf ("interp bisection gave %d\n", lo);*/ 297 done = 0; 298 for (j=end;j-->start;) 299 { 300 int tmp = bits1[j] + ((opus_int32)lo*bits2[j]>>ALLOC_STEPS); 301 if (tmp < thresh[j] && !done) 302 { 303 if (tmp >= alloc_floor) 304 tmp = alloc_floor; 305 else 306 tmp = 0; 307 } else 308 done = 1; 309 /* Don't allocate more than we can actually use */ 310 tmp = IMIN(tmp, cap[j]); 311 bits[j] = tmp; 312 psum += tmp; 313 } 314 315 /* Decide which bands to skip, working backwards from the end. */ 316 for (codedBands=end;;codedBands--) 317 { 318 int band_width; 319 int band_bits; 320 int rem; 321 j = codedBands-1; 322 /* Never skip the first band, nor a band that has been boosted by 323 dynalloc. 324 In the first case, we'd be coding a bit to signal we're going to waste 325 all the other bits. 326 In the second case, we'd be coding a bit to redistribute all the bits 327 we just signaled should be concentrated in this band. */ 328 if (j<=skip_start) 329 { 330 /* Give the bit we reserved to end skipping back. */ 331 total += skip_rsv; 332 break; 333 } 334 /*Figure out how many left-over bits we would be adding to this band. 335 This can include bits we've stolen back from higher, skipped bands.*/ 336 left = total-psum; 337 percoeff = celt_udiv(left, m->eBands[codedBands]-m->eBands[start]); 338 left -= (m->eBands[codedBands]-m->eBands[start])*percoeff; 339 rem = IMAX(left-(m->eBands[j]-m->eBands[start]),0); 340 band_width = m->eBands[codedBands]-m->eBands[j]; 341 band_bits = (int)(bits[j] + percoeff*band_width + rem); 342 /*Only code a skip decision if we're above the threshold for this band. 343 Otherwise it is force-skipped. 344 This ensures that we have enough bits to code the skip flag.*/ 345 if (band_bits >= IMAX(thresh[j], alloc_floor+(1<<BITRES))) 346 { 347 if (encode) 348 { 349 /*This if() block is the only part of the allocation function that 350 is not a mandatory part of the bitstream: any bands we choose to 351 skip here must be explicitly signaled.*/ 352 int depth_threshold; 353 /*We choose a threshold with some hysteresis to keep bands from 354 fluctuating in and out, but we try not to fold below a certain point. */ 355 if (codedBands > 17) 356 depth_threshold = j<prev ? 7 : 9; 357 else 358 depth_threshold = 0; 359 #ifdef FUZZING 360 (void)signalBandwidth; 361 (void)depth_threshold; 362 if ((rand()&0x1) == 0) 363 #else 364 if (codedBands<=start+2 || (band_bits > (depth_threshold*band_width<<LM<<BITRES)>>4 && j<=signalBandwidth)) 365 #endif 366 { 367 ec_enc_bit_logp(ec, 1, 1); 368 break; 369 } 370 ec_enc_bit_logp(ec, 0, 1); 371 } else if (ec_dec_bit_logp(ec, 1)) { 372 break; 373 } 374 /*We used a bit to skip this band.*/ 375 psum += 1<<BITRES; 376 band_bits -= 1<<BITRES; 377 } 378 /*Reclaim the bits originally allocated to this band.*/ 379 psum -= bits[j]+intensity_rsv; 380 if (intensity_rsv > 0) 381 intensity_rsv = LOG2_FRAC_TABLE[j-start]; 382 psum += intensity_rsv; 383 if (band_bits >= alloc_floor) 384 { 385 /*If we have enough for a fine energy bit per channel, use it.*/ 386 psum += alloc_floor; 387 bits[j] = alloc_floor; 388 } else { 389 /*Otherwise this band gets nothing at all.*/ 390 bits[j] = 0; 391 } 392 } 393 394 celt_assert(codedBands > start); 395 /* Code the intensity and dual stereo parameters. */ 396 if (intensity_rsv > 0) 397 { 398 if (encode) 399 { 400 *intensity = IMIN(*intensity, codedBands); 401 ec_enc_uint(ec, *intensity-start, codedBands+1-start); 402 } 403 else 404 *intensity = start+ec_dec_uint(ec, codedBands+1-start); 405 } 406 else 407 *intensity = 0; 408 if (*intensity <= start) 409 { 410 total += dual_stereo_rsv; 411 dual_stereo_rsv = 0; 412 } 413 if (dual_stereo_rsv > 0) 414 { 415 if (encode) 416 ec_enc_bit_logp(ec, *dual_stereo, 1); 417 else 418 *dual_stereo = ec_dec_bit_logp(ec, 1); 419 } 420 else 421 *dual_stereo = 0; 422 423 /* Allocate the remaining bits */ 424 left = total-psum; 425 percoeff = celt_udiv(left, m->eBands[codedBands]-m->eBands[start]); 426 left -= (m->eBands[codedBands]-m->eBands[start])*percoeff; 427 for (j=start;j<codedBands;j++) 428 bits[j] += ((int)percoeff*(m->eBands[j+1]-m->eBands[j])); 429 for (j=start;j<codedBands;j++) 430 { 431 int tmp = (int)IMIN(left, m->eBands[j+1]-m->eBands[j]); 432 bits[j] += tmp; 433 left -= tmp; 434 } 435 /*for (j=0;j<end;j++)printf("%d ", bits[j]);printf("\n");*/ 436 437 balance = 0; 438 for (j=start;j<codedBands;j++) 439 { 440 int N0, N, den; 441 int offset; 442 int NClogN; 443 opus_int32 excess, bit; 444 445 celt_assert(bits[j] >= 0); 446 N0 = m->eBands[j+1]-m->eBands[j]; 447 N=N0<<LM; 448 bit = (opus_int32)bits[j]+balance; 449 450 if (N>1) 451 { 452 excess = MAX32(bit-cap[j],0); 453 bits[j] = bit-excess; 454 455 /* Compensate for the extra DoF in stereo */ 456 den=(C*N+ ((C==2 && N>2 && !*dual_stereo && j<*intensity) ? 1 : 0)); 457 458 NClogN = den*(m->logN[j] + logM); 459 460 /* Offset for the number of fine bits by log2(N)/2 + FINE_OFFSET 461 compared to their "fair share" of total/N */ 462 offset = (NClogN>>1)-den*FINE_OFFSET; 463 464 /* N=2 is the only point that doesn't match the curve */ 465 if (N==2) 466 offset += den<<BITRES>>2; 467 468 /* Changing the offset for allocating the second and third 469 fine energy bit */ 470 if (bits[j] + offset < den*2<<BITRES) 471 offset += NClogN>>2; 472 else if (bits[j] + offset < den*3<<BITRES) 473 offset += NClogN>>3; 474 475 /* Divide with rounding */ 476 ebits[j] = IMAX(0, (bits[j] + offset + (den<<(BITRES-1)))); 477 ebits[j] = celt_udiv(ebits[j], den)>>BITRES; 478 479 /* Make sure not to bust */ 480 if (C*ebits[j] > (bits[j]>>BITRES)) 481 ebits[j] = bits[j] >> stereo >> BITRES; 482 483 /* More than that is useless because that's about as far as PVQ can go */ 484 ebits[j] = IMIN(ebits[j], MAX_FINE_BITS); 485 486 /* If we rounded down or capped this band, make it a candidate for the 487 final fine energy pass */ 488 fine_priority[j] = ebits[j]*(den<<BITRES) >= bits[j]+offset; 489 490 /* Remove the allocated fine bits; the rest are assigned to PVQ */ 491 bits[j] -= C*ebits[j]<<BITRES; 492 493 } else { 494 /* For N=1, all bits go to fine energy except for a single sign bit */ 495 excess = MAX32(0,bit-(C<<BITRES)); 496 bits[j] = bit-excess; 497 ebits[j] = 0; 498 fine_priority[j] = 1; 499 } 500 501 /* Fine energy can't take advantage of the re-balancing in 502 quant_all_bands(). 503 Instead, do the re-balancing here.*/ 504 if(excess > 0) 505 { 506 int extra_fine; 507 int extra_bits; 508 extra_fine = IMIN(excess>>(stereo+BITRES),MAX_FINE_BITS-ebits[j]); 509 ebits[j] += extra_fine; 510 extra_bits = extra_fine*C<<BITRES; 511 fine_priority[j] = extra_bits >= excess-balance; 512 excess -= extra_bits; 513 } 514 balance = excess; 515 516 celt_assert(bits[j] >= 0); 517 celt_assert(ebits[j] >= 0); 518 } 519 /* Save any remaining bits over the cap for the rebalancing in 520 quant_all_bands(). */ 521 *_balance = balance; 522 523 /* The skipped bands use all their bits for fine energy. */ 524 for (;j<end;j++) 525 { 526 ebits[j] = bits[j] >> stereo >> BITRES; 527 celt_assert(C*ebits[j]<<BITRES == bits[j]); 528 bits[j] = 0; 529 fine_priority[j] = ebits[j]<1; 530 } 531 RESTORE_STACK; 532 return codedBands; 533 } 534 535 int clt_compute_allocation(const CELTMode *m, int start, int end, const int *offsets, const int *cap, int alloc_trim, int *intensity, int *dual_stereo, 536 opus_int32 total, opus_int32 *balance, int *pulses, int *ebits, int *fine_priority, int C, int LM, ec_ctx *ec, int encode, int prev, int signalBandwidth) 537 { 538 int lo, hi, len, j; 539 int codedBands; 540 int skip_start; 541 int skip_rsv; 542 int intensity_rsv; 543 int dual_stereo_rsv; 544 VARDECL(int, bits1); 545 VARDECL(int, bits2); 546 VARDECL(int, thresh); 547 VARDECL(int, trim_offset); 548 SAVE_STACK; 549 550 total = IMAX(total, 0); 551 len = m->nbEBands; 552 skip_start = start; 553 /* Reserve a bit to signal the end of manually skipped bands. */ 554 skip_rsv = total >= 1<<BITRES ? 1<<BITRES : 0; 555 total -= skip_rsv; 556 /* Reserve bits for the intensity and dual stereo parameters. */ 557 intensity_rsv = dual_stereo_rsv = 0; 558 if (C==2) 559 { 560 intensity_rsv = LOG2_FRAC_TABLE[end-start]; 561 if (intensity_rsv>total) 562 intensity_rsv = 0; 563 else 564 { 565 total -= intensity_rsv; 566 dual_stereo_rsv = total>=1<<BITRES ? 1<<BITRES : 0; 567 total -= dual_stereo_rsv; 568 } 569 } 570 ALLOC(bits1, len, int); 571 ALLOC(bits2, len, int); 572 ALLOC(thresh, len, int); 573 ALLOC(trim_offset, len, int); 574 575 for (j=start;j<end;j++) 576 { 577 /* Below this threshold, we're sure not to allocate any PVQ bits */ 578 thresh[j] = IMAX((C)<<BITRES, (3*(m->eBands[j+1]-m->eBands[j])<<LM<<BITRES)>>4); 579 /* Tilt of the allocation curve */ 580 trim_offset[j] = C*(m->eBands[j+1]-m->eBands[j])*(alloc_trim-5-LM)*(end-j-1) 581 *(1<<(LM+BITRES))>>6; 582 /* Giving less resolution to single-coefficient bands because they get 583 more benefit from having one coarse value per coefficient*/ 584 if ((m->eBands[j+1]-m->eBands[j])<<LM==1) 585 trim_offset[j] -= C<<BITRES; 586 } 587 lo = 1; 588 hi = m->nbAllocVectors - 1; 589 do 590 { 591 int done = 0; 592 int psum = 0; 593 int mid = (lo+hi) >> 1; 594 for (j=end;j-->start;) 595 { 596 int bitsj; 597 int N = m->eBands[j+1]-m->eBands[j]; 598 bitsj = C*N*m->allocVectors[mid*len+j]<<LM>>2; 599 if (bitsj > 0) 600 bitsj = IMAX(0, bitsj + trim_offset[j]); 601 bitsj += offsets[j]; 602 if (bitsj >= thresh[j] || done) 603 { 604 done = 1; 605 /* Don't allocate more than we can actually use */ 606 psum += IMIN(bitsj, cap[j]); 607 } else { 608 if (bitsj >= C<<BITRES) 609 psum += C<<BITRES; 610 } 611 } 612 if (psum > total) 613 hi = mid - 1; 614 else 615 lo = mid + 1; 616 /*printf ("lo = %d, hi = %d\n", lo, hi);*/ 617 } 618 while (lo <= hi); 619 hi = lo--; 620 /*printf ("interp between %d and %d\n", lo, hi);*/ 621 for (j=start;j<end;j++) 622 { 623 int bits1j, bits2j; 624 int N = m->eBands[j+1]-m->eBands[j]; 625 bits1j = C*N*m->allocVectors[lo*len+j]<<LM>>2; 626 bits2j = hi>=m->nbAllocVectors ? 627 cap[j] : C*N*m->allocVectors[hi*len+j]<<LM>>2; 628 if (bits1j > 0) 629 bits1j = IMAX(0, bits1j + trim_offset[j]); 630 if (bits2j > 0) 631 bits2j = IMAX(0, bits2j + trim_offset[j]); 632 if (lo > 0) 633 bits1j += offsets[j]; 634 bits2j += offsets[j]; 635 if (offsets[j]>0) 636 skip_start = j; 637 bits2j = IMAX(0,bits2j-bits1j); 638 bits1[j] = bits1j; 639 bits2[j] = bits2j; 640 } 641 codedBands = interp_bits2pulses(m, start, end, skip_start, bits1, bits2, thresh, cap, 642 total, balance, skip_rsv, intensity, intensity_rsv, dual_stereo, dual_stereo_rsv, 643 pulses, ebits, fine_priority, C, LM, ec, encode, prev, signalBandwidth); 644 RESTORE_STACK; 645 return codedBands; 646 } 647 #ifdef ENABLE_QEXT 648 649 static const unsigned char last_zero[3] = {64, 50, 0}; 650 static const unsigned char last_cap[3] = {110, 60, 0}; 651 static const unsigned char last_other[4] = {120, 112, 70, 0}; 652 653 static void ec_enc_depth(ec_enc *enc, opus_int32 depth, opus_int32 cap, opus_int32 *last) { 654 int sym = 3; 655 if (depth==*last) sym = 2; 656 if (depth==cap) sym = 1; 657 if (depth==0) sym = 0; 658 if (*last == 0) { 659 ec_enc_icdf(enc, IMIN(sym, 2), last_zero, 7); 660 } else if (*last == cap) { 661 ec_enc_icdf(enc, IMIN(sym, 2), last_cap, 7); 662 } else { 663 ec_enc_icdf(enc, sym, last_other, 7); 664 } 665 /* We accept some redundancy if depth==last (for last different from 0 and cap). */ 666 if (sym == 3) ec_enc_uint(enc, depth-1, cap); 667 *last = depth; 668 } 669 670 static int ec_dec_depth(ec_dec *dec, opus_int32 cap, opus_int32 *last) { 671 int depth, sym; 672 if (*last == 0) { 673 sym = ec_dec_icdf(dec, last_zero, 7); 674 if (sym==2) sym=3; 675 } else if (*last == cap) { 676 sym = ec_dec_icdf(dec, last_cap, 7); 677 if (sym==2) sym=3; 678 } else { 679 sym = ec_dec_icdf(dec, last_other, 7); 680 } 681 if (sym==0) depth=0; 682 else if (sym==1) depth=cap; 683 else if (sym==2) depth=*last; 684 else depth = 1 + ec_dec_uint(dec, cap); 685 *last = depth; 686 return depth; 687 } 688 689 #define MSWAP16(a,b) do {opus_val16 tmp = a;a=b;b=tmp;} while(0) 690 static opus_val16 median_of_5_val16(const opus_val16 *x) 691 { 692 opus_val16 t0, t1, t2, t3, t4; 693 t2 = x[2]; 694 if (x[0] > x[1]) 695 { 696 t0 = x[1]; 697 t1 = x[0]; 698 } else { 699 t0 = x[0]; 700 t1 = x[1]; 701 } 702 if (x[3] > x[4]) 703 { 704 t3 = x[4]; 705 t4 = x[3]; 706 } else { 707 t3 = x[3]; 708 t4 = x[4]; 709 } 710 if (t0 > t3) 711 { 712 MSWAP16(t0, t3); 713 MSWAP16(t1, t4); 714 } 715 if (t2 > t1) 716 { 717 if (t1 < t3) 718 return MIN16(t2, t3); 719 else 720 return MIN16(t4, t1); 721 } else { 722 if (t2 < t3) 723 return MIN16(t1, t3); 724 else 725 return MIN16(t2, t4); 726 } 727 } 728 729 void clt_compute_extra_allocation(const CELTMode *m, const CELTMode *qext_mode, int start, int end, int qext_end, const celt_glog *bandLogE, const celt_glog *qext_bandLogE, 730 opus_int32 total, int *extra_pulses, int *extra_equant, int C, int LM, ec_ctx *ec, int encode, opus_val16 tone_freq, opus_val32 toneishness) 731 { 732 int i; 733 opus_int32 last=0; 734 opus_val32 sum; 735 opus_val32 fill; 736 int iter; 737 int tot_bands; 738 int tot_samples; 739 VARDECL(int, depth); 740 VARDECL(opus_int32, cap); 741 #ifdef FUZZING 742 float depth_std; 743 #endif 744 SAVE_STACK; 745 #ifdef FUZZING 746 depth_std = -10.f*log(1e-8+(float)rand()/(float)RAND_MAX); 747 depth_std = FMAX(0, FMIN(48, depth_std)); 748 #endif 749 if (qext_mode != NULL) { 750 celt_assert(end==m->nbEBands); 751 tot_bands = end + qext_end; 752 tot_samples = qext_mode->eBands[qext_end]*C<<LM; 753 } else { 754 tot_bands = end; 755 tot_samples = (m->eBands[end]-m->eBands[start])*C<<LM; 756 } 757 ALLOC(cap, tot_bands, opus_int32); 758 for (i=start;i<end;i++) cap[i] = 12; 759 if (qext_mode != NULL) { 760 for (i=0;i<qext_end;i++) cap[end+i] = 14; 761 } 762 if (total <= 0) { 763 for (i=start;i<m->nbEBands+qext_end;i++) { 764 extra_pulses[i] = extra_equant[i] = 0; 765 } 766 RESTORE_STACK; 767 return; 768 } 769 ALLOC(depth, tot_bands, int); 770 if (encode) { 771 VARDECL(opus_val16, flatE); 772 VARDECL(int, Ncoef); 773 VARDECL(opus_val16, min); 774 VARDECL(opus_val16, follower); 775 776 ALLOC(flatE, tot_bands, opus_val16); 777 ALLOC(min, tot_bands, opus_val16); 778 ALLOC(Ncoef, tot_bands, int); 779 for (i=start;i<end;i++) { 780 Ncoef[i] = (m->eBands[i+1]-m->eBands[i])*C<<LM; 781 } 782 /* Remove the effect of band width, eMeans and pre-emphasis to compute the real (flat) spectrum. */ 783 for (i=start;i<end;i++) { 784 flatE[i] = PSHR32(bandLogE[i] - GCONST(0.0625f)*m->logN[i] + SHL32(eMeans[i],DB_SHIFT-4) - GCONST(.0062f)*(i+5)*(i+5), DB_SHIFT-10); 785 min[i] = 0; 786 } 787 if (C==2) { 788 for (i=start;i<end;i++) { 789 flatE[i] = MAXG(flatE[i], PSHR32(bandLogE[m->nbEBands+i] - GCONST(0.0625f)*m->logN[i] + SHL32(eMeans[i],DB_SHIFT-4) - GCONST(.0062f)*(i+5)*(i+5), DB_SHIFT-10)); 790 } 791 } 792 flatE[end-1] += QCONST16(2.f, 10); 793 if (qext_mode != NULL) { 794 opus_val16 min_depth = 0; 795 /* If we have enough bits, give at least 1 bit of depth to all higher bands. */ 796 if (total >= 3*C*(qext_mode->eBands[qext_end]-qext_mode->eBands[start])<<LM<<BITRES && (toneishness < QCONST32(.98f, 29) || tone_freq > 1.33f)) 797 min_depth = QCONST16(1.f, 10); 798 for (i=0;i<qext_end;i++) { 799 Ncoef[end+i] = (qext_mode->eBands[i+1]-qext_mode->eBands[i])*C<<LM; 800 min[end+i] = min_depth; 801 } 802 for (i=0;i<qext_end;i++) { 803 flatE[end+i] = PSHR32(qext_bandLogE[i] - GCONST(0.0625f)*qext_mode->logN[i] + SHL32(eMeans[i],DB_SHIFT-4) - GCONST(.0062f)*(end+i+5)*(end+i+5), DB_SHIFT-10); 804 } 805 if (C==2) { 806 for (i=0;i<qext_end;i++) { 807 flatE[end+i] = MAXG(flatE[end+i], PSHR32(qext_bandLogE[NB_QEXT_BANDS+i] - GCONST(0.0625f)*qext_mode->logN[i] + SHL32(eMeans[i],DB_SHIFT-4) - GCONST(.0062f)*(end+i+5)*(end+i+5), DB_SHIFT-10)); 808 } 809 } 810 } 811 ALLOC(follower, tot_bands, opus_val16); 812 for (i=start+2;i<tot_bands-2;i++) { 813 follower[i] = median_of_5_val16(&flatE[i-2]); 814 } 815 follower[start] = follower[start+1] = follower[start+2]; 816 follower[tot_bands-1] = follower[tot_bands-2] = follower[tot_bands-3]; 817 for (i=start+1;i<tot_bands;i++) { 818 follower[i] = MAX16(follower[i], follower[i-1]-QCONST16(1.f, 10)); 819 } 820 for (i=tot_bands-2;i>=start;i--) { 821 follower[i] = MAX16(follower[i], follower[i+1]-QCONST16(1.f, 10)); 822 } 823 for (i=start;i<tot_bands;i++) flatE[i] -= MULT16_16_Q15(Q15ONE-PSHR32(toneishness, 14), follower[i]); 824 if (qext_mode != NULL) { 825 for (i=0;i<qext_end;i++) flatE[end+i] = flatE[end+i] + QCONST16(3.f, 10) + QCONST16(.2f, 10)*i; 826 } 827 /* Approximate fill level assuming all bands contribute fully. */ 828 sum = 0; 829 for (i=start;i<tot_bands;i++) { 830 sum += MULT16_16(Ncoef[i], flatE[i]); 831 } 832 total >>= BITRES; 833 fill = (SHL32(total, 10) + sum)/tot_samples; 834 /* Iteratively refine the fill level considering the depth min and cap. */ 835 for (iter=0;iter<10;iter++) { 836 sum = 0; 837 for (i=start;i<tot_bands;i++) 838 sum += Ncoef[i] * MIN32(SHL32(cap[i], 10), MAX32(min[i], flatE[i]-fill)); 839 fill -= (SHL32(total, 10) - sum)/tot_samples; 840 } 841 for (i=start;i<tot_bands;i++) { 842 #ifdef FIXED_POINT 843 depth[i] = PSHR32(MIN32(SHL32(cap[i], 10), MAX32(min[i], flatE[i]-fill)), 10-2); 844 #else 845 depth[i] = (int)floor(.5+4*MIN32(SHL32(cap[i], 10), MAX32(min[i], flatE[i]-fill))); 846 #endif 847 #ifdef FUZZING 848 depth[i] = (int)-depth_std*log(1e-8+(float)rand()/(float)RAND_MAX); 849 depth[i] = IMAX(0, IMIN(cap[i]<<2, depth[i])); 850 #endif 851 if (ec_tell_frac(ec) + 80 < ec->storage*8<<BITRES) 852 ec_enc_depth(ec, depth[i], 4*cap[i], &last); 853 else 854 depth[i] = 0; 855 } 856 } else { 857 for (i=start;i<tot_bands;i++) { 858 if (ec_tell_frac(ec) + 80 < ec->storage*8<<BITRES) 859 depth[i] = ec_dec_depth(ec, 4*cap[i], &last); 860 else 861 depth[i] = 0; 862 } 863 } 864 for (i=start;i<end;i++) { 865 extra_equant[i] = (depth[i]+3)>>2; 866 extra_pulses[i] = ((((m->eBands[i+1]-m->eBands[i])<<LM)-1)*C * depth[i] * (1<<BITRES) + 2)>>2; 867 } 868 if (qext_mode) { 869 for (i=0;i<qext_end;i++) { 870 extra_equant[end+i] = (depth[end+i]+3)>>2; 871 extra_pulses[end+i] = ((((qext_mode->eBands[i+1]-qext_mode->eBands[i])<<LM)-1)*C * depth[end+i] * (1<<BITRES) + 2)>>2; 872 } 873 } 874 RESTORE_STACK; 875 } 876 #endif