quant_bands.c (18965B)
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 "quant_bands.h" 34 #include "laplace.h" 35 #include <math.h> 36 #include "os_support.h" 37 #include "arch.h" 38 #include "mathops.h" 39 #include "stack_alloc.h" 40 #include "rate.h" 41 42 #ifdef FIXED_POINT 43 /* Mean energy in each band quantized in Q4 */ 44 const signed char eMeans[25] = { 45 103,100, 92, 85, 81, 46 77, 72, 70, 78, 75, 47 73, 71, 78, 74, 69, 48 72, 70, 74, 76, 71, 49 60, 60, 60, 60, 60 50 }; 51 #else 52 /* Mean energy in each band quantized in Q4 and converted back to float */ 53 const opus_val16 eMeans[25] = { 54 6.437500f, 6.250000f, 5.750000f, 5.312500f, 5.062500f, 55 4.812500f, 4.500000f, 4.375000f, 4.875000f, 4.687500f, 56 4.562500f, 4.437500f, 4.875000f, 4.625000f, 4.312500f, 57 4.500000f, 4.375000f, 4.625000f, 4.750000f, 4.437500f, 58 3.750000f, 3.750000f, 3.750000f, 3.750000f, 3.750000f 59 }; 60 #endif 61 /* prediction coefficients: 0.9, 0.8, 0.65, 0.5 */ 62 #ifdef FIXED_POINT 63 static const opus_val16 pred_coef[4] = {29440, 26112, 21248, 16384}; 64 static const opus_val16 beta_coef[4] = {30147, 22282, 12124, 6554}; 65 static const opus_val16 beta_intra = 4915; 66 #else 67 static const opus_val16 pred_coef[4] = {29440/32768., 26112/32768., 21248/32768., 16384/32768.}; 68 static const opus_val16 beta_coef[4] = {30147/32768., 22282/32768., 12124/32768., 6554/32768.}; 69 static const opus_val16 beta_intra = 4915/32768.; 70 #endif 71 72 /*Parameters of the Laplace-like probability models used for the coarse energy. 73 There is one pair of parameters for each frame size, prediction type 74 (inter/intra), and band number. 75 The first number of each pair is the probability of 0, and the second is the 76 decay rate, both in Q8 precision.*/ 77 static const unsigned char e_prob_model[4][2][42] = { 78 /*120 sample frames.*/ 79 { 80 /*Inter*/ 81 { 82 72, 127, 65, 129, 66, 128, 65, 128, 64, 128, 62, 128, 64, 128, 83 64, 128, 92, 78, 92, 79, 92, 78, 90, 79, 116, 41, 115, 40, 84 114, 40, 132, 26, 132, 26, 145, 17, 161, 12, 176, 10, 177, 11 85 }, 86 /*Intra*/ 87 { 88 24, 179, 48, 138, 54, 135, 54, 132, 53, 134, 56, 133, 55, 132, 89 55, 132, 61, 114, 70, 96, 74, 88, 75, 88, 87, 74, 89, 66, 90 91, 67, 100, 59, 108, 50, 120, 40, 122, 37, 97, 43, 78, 50 91 } 92 }, 93 /*240 sample frames.*/ 94 { 95 /*Inter*/ 96 { 97 83, 78, 84, 81, 88, 75, 86, 74, 87, 71, 90, 73, 93, 74, 98 93, 74, 109, 40, 114, 36, 117, 34, 117, 34, 143, 17, 145, 18, 99 146, 19, 162, 12, 165, 10, 178, 7, 189, 6, 190, 8, 177, 9 100 }, 101 /*Intra*/ 102 { 103 23, 178, 54, 115, 63, 102, 66, 98, 69, 99, 74, 89, 71, 91, 104 73, 91, 78, 89, 86, 80, 92, 66, 93, 64, 102, 59, 103, 60, 105 104, 60, 117, 52, 123, 44, 138, 35, 133, 31, 97, 38, 77, 45 106 } 107 }, 108 /*480 sample frames.*/ 109 { 110 /*Inter*/ 111 { 112 61, 90, 93, 60, 105, 42, 107, 41, 110, 45, 116, 38, 113, 38, 113 112, 38, 124, 26, 132, 27, 136, 19, 140, 20, 155, 14, 159, 16, 114 158, 18, 170, 13, 177, 10, 187, 8, 192, 6, 175, 9, 159, 10 115 }, 116 /*Intra*/ 117 { 118 21, 178, 59, 110, 71, 86, 75, 85, 84, 83, 91, 66, 88, 73, 119 87, 72, 92, 75, 98, 72, 105, 58, 107, 54, 115, 52, 114, 55, 120 112, 56, 129, 51, 132, 40, 150, 33, 140, 29, 98, 35, 77, 42 121 } 122 }, 123 /*960 sample frames.*/ 124 { 125 /*Inter*/ 126 { 127 42, 121, 96, 66, 108, 43, 111, 40, 117, 44, 123, 32, 120, 36, 128 119, 33, 127, 33, 134, 34, 139, 21, 147, 23, 152, 20, 158, 25, 129 154, 26, 166, 21, 173, 16, 184, 13, 184, 10, 150, 13, 139, 15 130 }, 131 /*Intra*/ 132 { 133 22, 178, 63, 114, 74, 82, 84, 83, 92, 82, 103, 62, 96, 72, 134 96, 67, 101, 73, 107, 72, 113, 55, 118, 52, 125, 52, 118, 52, 135 117, 55, 135, 49, 137, 39, 157, 32, 145, 29, 97, 33, 77, 40 136 } 137 } 138 }; 139 140 static const unsigned char small_energy_icdf[3]={2,1,0}; 141 142 static opus_val32 loss_distortion(const celt_glog *eBands, celt_glog *oldEBands, int start, int end, int len, int C) 143 { 144 int c, i; 145 opus_val32 dist = 0; 146 c=0; do { 147 for (i=start;i<end;i++) 148 { 149 celt_glog d = PSHR32(SUB32(eBands[i+c*len], oldEBands[i+c*len]), DB_SHIFT-7); 150 dist = MAC16_16(dist, d,d); 151 } 152 } while (++c<C); 153 return MIN32(200,SHR32(dist,14)); 154 } 155 156 static int quant_coarse_energy_impl(const CELTMode *m, int start, int end, 157 const celt_glog *eBands, celt_glog *oldEBands, 158 opus_int32 budget, opus_int32 tell, 159 const unsigned char *prob_model, celt_glog *error, ec_enc *enc, 160 int C, int LM, int intra, celt_glog max_decay, int lfe) 161 { 162 int i, c; 163 int badness = 0; 164 opus_val32 prev[2] = {0,0}; 165 opus_val16 coef; 166 opus_val16 beta; 167 168 if (tell+3 <= budget) 169 ec_enc_bit_logp(enc, intra, 3); 170 if (intra) 171 { 172 coef = 0; 173 beta = beta_intra; 174 } else { 175 beta = beta_coef[LM]; 176 coef = pred_coef[LM]; 177 } 178 179 /* Encode at a fixed coarse resolution */ 180 for (i=start;i<end;i++) 181 { 182 c=0; 183 do { 184 int bits_left; 185 int qi, qi0; 186 opus_val32 q; 187 celt_glog x; 188 opus_val32 f, tmp; 189 celt_glog oldE; 190 celt_glog decay_bound; 191 x = eBands[i+c*m->nbEBands]; 192 oldE = MAXG(-GCONST(9.f), oldEBands[i+c*m->nbEBands]); 193 #ifdef FIXED_POINT 194 f = x - MULT16_32_Q15(coef,oldE) - prev[c]; 195 /* Rounding to nearest integer here is really important! */ 196 qi = (f+QCONST32(.5f,DB_SHIFT))>>DB_SHIFT; 197 decay_bound = MAXG(-GCONST(28.f), SUB32((opus_val32)oldEBands[i+c*m->nbEBands],max_decay)); 198 #else 199 f = x-coef*oldE-prev[c]; 200 /* Rounding to nearest integer here is really important! */ 201 qi = (int)floor(.5f+f); 202 decay_bound = MAXG(-GCONST(28.f), oldEBands[i+c*m->nbEBands]) - max_decay; 203 #endif 204 /* Prevent the energy from going down too quickly (e.g. for bands 205 that have just one bin) */ 206 if (qi < 0 && x < decay_bound) 207 { 208 qi += (int)SHR32(SUB32(decay_bound,x), DB_SHIFT); 209 if (qi > 0) 210 qi = 0; 211 } 212 qi0 = qi; 213 /* If we don't have enough bits to encode all the energy, just assume 214 something safe. */ 215 tell = ec_tell(enc); 216 bits_left = budget-tell-3*C*(end-i); 217 if (i!=start && bits_left < 30) 218 { 219 if (bits_left < 24) 220 qi = IMIN(1, qi); 221 if (bits_left < 16) 222 qi = IMAX(-1, qi); 223 } 224 if (lfe && i>=2) 225 qi = IMIN(qi, 0); 226 if (budget-tell >= 15) 227 { 228 int pi; 229 pi = 2*IMIN(i,20); 230 ec_laplace_encode(enc, &qi, 231 prob_model[pi]<<7, prob_model[pi+1]<<6); 232 } 233 else if(budget-tell >= 2) 234 { 235 qi = IMAX(-1, IMIN(qi, 1)); 236 ec_enc_icdf(enc, 2*qi^-(qi<0), small_energy_icdf, 2); 237 } 238 else if(budget-tell >= 1) 239 { 240 qi = IMIN(0, qi); 241 ec_enc_bit_logp(enc, -qi, 1); 242 } 243 else 244 qi = -1; 245 error[i+c*m->nbEBands] = f - SHL32(qi,DB_SHIFT); 246 badness += abs(qi0-qi); 247 q = (opus_val32)SHL32(EXTEND32(qi),DB_SHIFT); 248 249 tmp = MULT16_32_Q15(coef,oldE) + prev[c] + q; 250 #ifdef FIXED_POINT 251 tmp = MAX32(-GCONST(28.f), tmp); 252 #endif 253 oldEBands[i+c*m->nbEBands] = tmp; 254 prev[c] = prev[c] + q - MULT16_32_Q15(beta,q); 255 } while (++c < C); 256 } 257 return lfe ? 0 : badness; 258 } 259 260 void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd, 261 const celt_glog *eBands, celt_glog *oldEBands, opus_uint32 budget, 262 celt_glog *error, ec_enc *enc, int C, int LM, int nbAvailableBytes, 263 int force_intra, opus_val32 *delayedIntra, int two_pass, int loss_rate, int lfe) 264 { 265 int intra; 266 celt_glog max_decay; 267 VARDECL(celt_glog, oldEBands_intra); 268 VARDECL(celt_glog, error_intra); 269 ec_enc enc_start_state; 270 opus_uint32 tell; 271 int badness1=0; 272 opus_int32 intra_bias; 273 opus_val32 new_distortion; 274 SAVE_STACK; 275 276 intra = force_intra || (!two_pass && *delayedIntra>2*C*(end-start) && nbAvailableBytes > (end-start)*C); 277 intra_bias = (opus_int32)((budget**delayedIntra*loss_rate)/(C*512)); 278 new_distortion = loss_distortion(eBands, oldEBands, start, effEnd, m->nbEBands, C); 279 280 tell = ec_tell(enc); 281 if (tell+3 > budget) 282 two_pass = intra = 0; 283 284 max_decay = GCONST(16.f); 285 if (end-start>10) 286 { 287 #ifdef FIXED_POINT 288 max_decay = SHL32(MIN32(SHR32(max_decay,DB_SHIFT-3), EXTEND32(nbAvailableBytes)),DB_SHIFT-3); 289 #else 290 max_decay = MIN32(max_decay, .125f*nbAvailableBytes); 291 #endif 292 } 293 if (lfe) 294 max_decay = GCONST(3.f); 295 enc_start_state = *enc; 296 297 ALLOC(oldEBands_intra, C*m->nbEBands, celt_glog); 298 ALLOC(error_intra, C*m->nbEBands, celt_glog); 299 OPUS_COPY(oldEBands_intra, oldEBands, C*m->nbEBands); 300 301 if (two_pass || intra) 302 { 303 badness1 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands_intra, budget, 304 tell, e_prob_model[LM][1], error_intra, enc, C, LM, 1, max_decay, lfe); 305 } 306 307 if (!intra) 308 { 309 unsigned char *intra_buf; 310 ec_enc enc_intra_state; 311 opus_int32 tell_intra; 312 opus_uint32 nstart_bytes; 313 opus_uint32 nintra_bytes; 314 opus_uint32 save_bytes; 315 int badness2; 316 VARDECL(unsigned char, intra_bits); 317 318 tell_intra = ec_tell_frac(enc); 319 320 enc_intra_state = *enc; 321 322 nstart_bytes = ec_range_bytes(&enc_start_state); 323 nintra_bytes = ec_range_bytes(&enc_intra_state); 324 intra_buf = ec_get_buffer(&enc_intra_state) + nstart_bytes; 325 save_bytes = nintra_bytes-nstart_bytes; 326 if (save_bytes == 0) 327 save_bytes = ALLOC_NONE; 328 ALLOC(intra_bits, save_bytes, unsigned char); 329 /* Copy bits from intra bit-stream */ 330 OPUS_COPY(intra_bits, intra_buf, nintra_bytes - nstart_bytes); 331 332 *enc = enc_start_state; 333 334 badness2 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands, budget, 335 tell, e_prob_model[LM][intra], error, enc, C, LM, 0, max_decay, lfe); 336 337 if (two_pass && (badness1 < badness2 || (badness1 == badness2 && ((opus_int32)ec_tell_frac(enc))+intra_bias > tell_intra))) 338 { 339 *enc = enc_intra_state; 340 /* Copy intra bits to bit-stream */ 341 OPUS_COPY(intra_buf, intra_bits, nintra_bytes - nstart_bytes); 342 OPUS_COPY(oldEBands, oldEBands_intra, C*m->nbEBands); 343 OPUS_COPY(error, error_intra, C*m->nbEBands); 344 intra = 1; 345 } 346 } else { 347 OPUS_COPY(oldEBands, oldEBands_intra, C*m->nbEBands); 348 OPUS_COPY(error, error_intra, C*m->nbEBands); 349 } 350 351 if (intra) 352 *delayedIntra = new_distortion; 353 else 354 *delayedIntra = ADD32(MULT16_32_Q15(MULT16_16_Q15(pred_coef[LM], pred_coef[LM]),*delayedIntra), 355 new_distortion); 356 357 RESTORE_STACK; 358 } 359 360 void quant_fine_energy(const CELTMode *m, int start, int end, celt_glog *oldEBands, celt_glog *error, int *prev_quant, int *extra_quant, ec_enc *enc, int C) 361 { 362 int i, c; 363 /* Encode finer resolution */ 364 for (i=start;i<end;i++) 365 { 366 opus_int16 extra, prev; 367 extra = 1<<extra_quant[i]; 368 if (extra_quant[i] <= 0) 369 continue; 370 if (ec_tell(enc)+C*extra_quant[i] > (opus_int32)enc->storage*8) continue; 371 prev = (prev_quant!=NULL) ? prev_quant[i] : 0; 372 c=0; 373 do { 374 int q2; 375 celt_glog offset; 376 #ifdef FIXED_POINT 377 /* Has to be without rounding */ 378 q2 = VSHR32(ADD32(error[i+c*m->nbEBands], SHR32(GCONST(.5f), prev)), DB_SHIFT-extra_quant[i]-prev); 379 #else 380 q2 = (int)floor((error[i+c*m->nbEBands]*(1<<prev)+.5f)*extra); 381 #endif 382 if (q2 > extra-1) 383 q2 = extra-1; 384 if (q2<0) 385 q2 = 0; 386 ec_enc_bits(enc, q2, extra_quant[i]); 387 #ifdef FIXED_POINT 388 offset = SUB32(VSHR32(2*q2+1, extra_quant[i]-DB_SHIFT+1), GCONST(.5f)); 389 offset = SHR32(offset, prev); 390 #else 391 offset = (q2+.5f)*(1<<(14-extra_quant[i]))*(1.f/16384) - .5f; 392 offset *= (1<<(14-prev))*(1.f/16384); 393 #endif 394 oldEBands[i+c*m->nbEBands] += offset; 395 error[i+c*m->nbEBands] -= offset; 396 /*printf ("%f ", error[i] - offset);*/ 397 } while (++c < C); 398 } 399 } 400 401 void quant_energy_finalise(const CELTMode *m, int start, int end, celt_glog *oldEBands, celt_glog *error, int *fine_quant, int *fine_priority, int bits_left, ec_enc *enc, int C) 402 { 403 int i, prio, c; 404 405 /* Use up the remaining bits */ 406 for (prio=0;prio<2;prio++) 407 { 408 for (i=start;i<end && bits_left>=C ;i++) 409 { 410 if (fine_quant[i] >= MAX_FINE_BITS || fine_priority[i]!=prio) 411 continue; 412 c=0; 413 do { 414 int q2; 415 celt_glog offset; 416 q2 = error[i+c*m->nbEBands]<0 ? 0 : 1; 417 ec_enc_bits(enc, q2, 1); 418 #ifdef FIXED_POINT 419 offset = SHR32(SHL32(q2,DB_SHIFT)-GCONST(.5f),fine_quant[i]+1); 420 #else 421 offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384); 422 #endif 423 if (oldEBands != NULL) oldEBands[i+c*m->nbEBands] += offset; 424 error[i+c*m->nbEBands] -= offset; 425 bits_left--; 426 } while (++c < C); 427 } 428 } 429 } 430 431 void unquant_coarse_energy(const CELTMode *m, int start, int end, celt_glog *oldEBands, int intra, ec_dec *dec, int C, int LM) 432 { 433 const unsigned char *prob_model = e_prob_model[LM][intra]; 434 int i, c; 435 opus_val64 prev[2] = {0, 0}; 436 opus_val16 coef; 437 opus_val16 beta; 438 opus_int32 budget; 439 opus_int32 tell; 440 441 if (intra) 442 { 443 coef = 0; 444 beta = beta_intra; 445 } else { 446 beta = beta_coef[LM]; 447 coef = pred_coef[LM]; 448 } 449 450 budget = dec->storage*8; 451 452 /* Decode at a fixed coarse resolution */ 453 for (i=start;i<end;i++) 454 { 455 c=0; 456 do { 457 int qi; 458 opus_val32 q; 459 opus_val32 tmp; 460 /* It would be better to express this invariant as a 461 test on C at function entry, but that isn't enough 462 to make the static analyzer happy. */ 463 celt_sig_assert(c<2); 464 tell = ec_tell(dec); 465 if(budget-tell>=15) 466 { 467 int pi; 468 pi = 2*IMIN(i,20); 469 qi = ec_laplace_decode(dec, 470 prob_model[pi]<<7, prob_model[pi+1]<<6); 471 } 472 else if(budget-tell>=2) 473 { 474 qi = ec_dec_icdf(dec, small_energy_icdf, 2); 475 qi = (qi>>1)^-(qi&1); 476 } 477 else if(budget-tell>=1) 478 { 479 qi = -ec_dec_bit_logp(dec, 1); 480 } 481 else 482 qi = -1; 483 q = (opus_val32)SHL32(EXTEND32(qi),DB_SHIFT); 484 485 oldEBands[i+c*m->nbEBands] = MAXG(-GCONST(9.f), oldEBands[i+c*m->nbEBands]); 486 tmp = MULT16_32_Q15(coef,oldEBands[i+c*m->nbEBands]) + prev[c] + q; 487 #ifdef FIXED_POINT 488 tmp = MIN32(GCONST(28.f), MAX32(-GCONST(28.f), tmp)); 489 #endif 490 oldEBands[i+c*m->nbEBands] = tmp; 491 prev[c] = prev[c] + q - MULT16_32_Q15(beta,q); 492 } while (++c < C); 493 } 494 } 495 496 void unquant_fine_energy(const CELTMode *m, int start, int end, celt_glog *oldEBands, int *prev_quant, int *extra_quant, ec_dec *dec, int C) 497 { 498 int i, c; 499 /* Decode finer resolution */ 500 for (i=start;i<end;i++) 501 { 502 opus_int16 extra, prev; 503 extra = extra_quant[i]; 504 if (extra_quant[i] <= 0) 505 continue; 506 if (ec_tell(dec)+C*extra_quant[i] > (opus_int32)dec->storage*8) continue; 507 prev = (prev_quant!=NULL) ? prev_quant[i] : 0; 508 c=0; 509 do { 510 int q2; 511 celt_glog offset; 512 q2 = ec_dec_bits(dec, extra); 513 #ifdef FIXED_POINT 514 offset = SUB32(VSHR32(2*q2+1, extra-DB_SHIFT+1), GCONST(.5f)); 515 offset = SHR32(offset, prev); 516 #else 517 offset = (q2+.5f)*(1<<(14-extra))*(1.f/16384) - .5f; 518 offset *= (1<<(14-prev))*(1.f/16384); 519 #endif 520 oldEBands[i+c*m->nbEBands] += offset; 521 } while (++c < C); 522 } 523 } 524 525 void unquant_energy_finalise(const CELTMode *m, int start, int end, celt_glog *oldEBands, int *fine_quant, int *fine_priority, int bits_left, ec_dec *dec, int C) 526 { 527 int i, prio, c; 528 529 /* Use up the remaining bits */ 530 for (prio=0;prio<2;prio++) 531 { 532 for (i=start;i<end && bits_left>=C ;i++) 533 { 534 if (fine_quant[i] >= MAX_FINE_BITS || fine_priority[i]!=prio) 535 continue; 536 c=0; 537 do { 538 int q2; 539 celt_glog offset; 540 q2 = ec_dec_bits(dec, 1); 541 #ifdef FIXED_POINT 542 offset = SHR32(SHL32(q2,DB_SHIFT)-GCONST(.5f),fine_quant[i]+1); 543 #else 544 offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384); 545 #endif 546 if (oldEBands != NULL) oldEBands[i+c*m->nbEBands] += offset; 547 bits_left--; 548 } while (++c < C); 549 } 550 } 551 } 552 553 void amp2Log2(const CELTMode *m, int effEnd, int end, 554 celt_ener *bandE, celt_glog *bandLogE, int C) 555 { 556 int c, i; 557 c=0; 558 do { 559 for (i=0;i<effEnd;i++) 560 { 561 bandLogE[i+c*m->nbEBands] = 562 celt_log2_db(bandE[i+c*m->nbEBands]) 563 - SHL32((celt_glog)eMeans[i],DB_SHIFT-4); 564 #ifdef FIXED_POINT 565 /* Compensate for bandE[] being Q12 but celt_log2() taking a Q14 input. */ 566 bandLogE[i+c*m->nbEBands] += GCONST(2.f); 567 #endif 568 } 569 for (i=effEnd;i<end;i++) 570 bandLogE[c*m->nbEBands+i] = -GCONST(14.f); 571 } while (++c < C); 572 }