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 opus_val16 *eBands, opus_val16 *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 opus_val16 d = SUB16(SHR16(eBands[i+c*len], 3), SHR16(oldEBands[i+c*len], 3)); 150 dist = MAC16_16(dist, d,d); 151 } 152 } while (++c<C); 153 return MIN32(200,SHR32(dist,2*DB_SHIFT-6)); 154 } 155 156 static int quant_coarse_energy_impl(const CELTMode *m, int start, int end, 157 const opus_val16 *eBands, opus_val16 *oldEBands, 158 opus_int32 budget, opus_int32 tell, 159 const unsigned char *prob_model, opus_val16 *error, ec_enc *enc, 160 int C, int LM, int intra, opus_val16 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 opus_val16 x; 188 opus_val32 f, tmp; 189 opus_val16 oldE; 190 opus_val16 decay_bound; 191 x = eBands[i+c*m->nbEBands]; 192 oldE = MAX16(-QCONST16(9.f,DB_SHIFT), oldEBands[i+c*m->nbEBands]); 193 #ifdef FIXED_POINT 194 f = SHL32(EXTEND32(x),7) - PSHR32(MULT16_16(coef,oldE), 8) - prev[c]; 195 /* Rounding to nearest integer here is really important! */ 196 qi = (f+QCONST32(.5f,DB_SHIFT+7))>>(DB_SHIFT+7); 197 decay_bound = EXTRACT16(MAX32(-QCONST16(28.f,DB_SHIFT), 198 SUB32((opus_val32)oldEBands[i+c*m->nbEBands],max_decay))); 199 #else 200 f = x-coef*oldE-prev[c]; 201 /* Rounding to nearest integer here is really important! */ 202 qi = (int)floor(.5f+f); 203 decay_bound = MAX16(-QCONST16(28.f,DB_SHIFT), oldEBands[i+c*m->nbEBands]) - max_decay; 204 #endif 205 /* Prevent the energy from going down too quickly (e.g. for bands 206 that have just one bin) */ 207 if (qi < 0 && x < decay_bound) 208 { 209 qi += (int)SHR16(SUB16(decay_bound,x), DB_SHIFT); 210 if (qi > 0) 211 qi = 0; 212 } 213 qi0 = qi; 214 /* If we don't have enough bits to encode all the energy, just assume 215 something safe. */ 216 tell = ec_tell(enc); 217 bits_left = budget-tell-3*C*(end-i); 218 if (i!=start && bits_left < 30) 219 { 220 if (bits_left < 24) 221 qi = IMIN(1, qi); 222 if (bits_left < 16) 223 qi = IMAX(-1, qi); 224 } 225 if (lfe && i>=2) 226 qi = IMIN(qi, 0); 227 if (budget-tell >= 15) 228 { 229 int pi; 230 pi = 2*IMIN(i,20); 231 ec_laplace_encode(enc, &qi, 232 prob_model[pi]<<7, prob_model[pi+1]<<6); 233 } 234 else if(budget-tell >= 2) 235 { 236 qi = IMAX(-1, IMIN(qi, 1)); 237 ec_enc_icdf(enc, 2*qi^-(qi<0), small_energy_icdf, 2); 238 } 239 else if(budget-tell >= 1) 240 { 241 qi = IMIN(0, qi); 242 ec_enc_bit_logp(enc, -qi, 1); 243 } 244 else 245 qi = -1; 246 error[i+c*m->nbEBands] = PSHR32(f,7) - SHL16(qi,DB_SHIFT); 247 badness += abs(qi0-qi); 248 q = (opus_val32)SHL32(EXTEND32(qi),DB_SHIFT); 249 250 tmp = PSHR32(MULT16_16(coef,oldE),8) + prev[c] + SHL32(q,7); 251 #ifdef FIXED_POINT 252 tmp = MAX32(-QCONST32(28.f, DB_SHIFT+7), tmp); 253 #endif 254 oldEBands[i+c*m->nbEBands] = PSHR32(tmp, 7); 255 prev[c] = prev[c] + SHL32(q,7) - MULT16_16(beta,PSHR32(q,8)); 256 } while (++c < C); 257 } 258 return lfe ? 0 : badness; 259 } 260 261 void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd, 262 const opus_val16 *eBands, opus_val16 *oldEBands, opus_uint32 budget, 263 opus_val16 *error, ec_enc *enc, int C, int LM, int nbAvailableBytes, 264 int force_intra, opus_val32 *delayedIntra, int two_pass, int loss_rate, int lfe) 265 { 266 int intra; 267 opus_val16 max_decay; 268 VARDECL(opus_val16, oldEBands_intra); 269 VARDECL(opus_val16, error_intra); 270 ec_enc enc_start_state; 271 opus_uint32 tell; 272 int badness1=0; 273 opus_int32 intra_bias; 274 opus_val32 new_distortion; 275 SAVE_STACK; 276 277 intra = force_intra || (!two_pass && *delayedIntra>2*C*(end-start) && nbAvailableBytes > (end-start)*C); 278 intra_bias = (opus_int32)((budget**delayedIntra*loss_rate)/(C*512)); 279 new_distortion = loss_distortion(eBands, oldEBands, start, effEnd, m->nbEBands, C); 280 281 tell = ec_tell(enc); 282 if (tell+3 > budget) 283 two_pass = intra = 0; 284 285 max_decay = QCONST16(16.f,DB_SHIFT); 286 if (end-start>10) 287 { 288 #ifdef FIXED_POINT 289 max_decay = MIN32(max_decay, SHL32(EXTEND32(nbAvailableBytes),DB_SHIFT-3)); 290 #else 291 max_decay = MIN32(max_decay, .125f*nbAvailableBytes); 292 #endif 293 } 294 if (lfe) 295 max_decay=3; 296 enc_start_state = *enc; 297 298 ALLOC(oldEBands_intra, C*m->nbEBands, opus_val16); 299 ALLOC(error_intra, C*m->nbEBands, opus_val16); 300 OPUS_COPY(oldEBands_intra, oldEBands, C*m->nbEBands); 301 302 if (two_pass || intra) 303 { 304 badness1 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands_intra, budget, 305 tell, e_prob_model[LM][1], error_intra, enc, C, LM, 1, max_decay, lfe); 306 } 307 308 if (!intra) 309 { 310 unsigned char *intra_buf; 311 ec_enc enc_intra_state; 312 opus_int32 tell_intra; 313 opus_uint32 nstart_bytes; 314 opus_uint32 nintra_bytes; 315 opus_uint32 save_bytes; 316 int badness2; 317 VARDECL(unsigned char, intra_bits); 318 319 tell_intra = ec_tell_frac(enc); 320 321 enc_intra_state = *enc; 322 323 nstart_bytes = ec_range_bytes(&enc_start_state); 324 nintra_bytes = ec_range_bytes(&enc_intra_state); 325 intra_buf = ec_get_buffer(&enc_intra_state) + nstart_bytes; 326 save_bytes = nintra_bytes-nstart_bytes; 327 if (save_bytes == 0) 328 save_bytes = ALLOC_NONE; 329 ALLOC(intra_bits, save_bytes, unsigned char); 330 /* Copy bits from intra bit-stream */ 331 OPUS_COPY(intra_bits, intra_buf, nintra_bytes - nstart_bytes); 332 333 *enc = enc_start_state; 334 335 badness2 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands, budget, 336 tell, e_prob_model[LM][intra], error, enc, C, LM, 0, max_decay, lfe); 337 338 if (two_pass && (badness1 < badness2 || (badness1 == badness2 && ((opus_int32)ec_tell_frac(enc))+intra_bias > tell_intra))) 339 { 340 *enc = enc_intra_state; 341 /* Copy intra bits to bit-stream */ 342 OPUS_COPY(intra_buf, intra_bits, nintra_bytes - nstart_bytes); 343 OPUS_COPY(oldEBands, oldEBands_intra, C*m->nbEBands); 344 OPUS_COPY(error, error_intra, C*m->nbEBands); 345 intra = 1; 346 } 347 } else { 348 OPUS_COPY(oldEBands, oldEBands_intra, C*m->nbEBands); 349 OPUS_COPY(error, error_intra, C*m->nbEBands); 350 } 351 352 if (intra) 353 *delayedIntra = new_distortion; 354 else 355 *delayedIntra = ADD32(MULT16_32_Q15(MULT16_16_Q15(pred_coef[LM], pred_coef[LM]),*delayedIntra), 356 new_distortion); 357 358 RESTORE_STACK; 359 } 360 361 void quant_fine_energy(const CELTMode *m, int start, int end, opus_val16 *oldEBands, opus_val16 *error, int *fine_quant, ec_enc *enc, int C) 362 { 363 int i, c; 364 365 /* Encode finer resolution */ 366 for (i=start;i<end;i++) 367 { 368 opus_int16 frac = 1<<fine_quant[i]; 369 if (fine_quant[i] <= 0) 370 continue; 371 c=0; 372 do { 373 int q2; 374 opus_val16 offset; 375 #ifdef FIXED_POINT 376 /* Has to be without rounding */ 377 q2 = (error[i+c*m->nbEBands]+QCONST16(.5f,DB_SHIFT))>>(DB_SHIFT-fine_quant[i]); 378 #else 379 q2 = (int)floor((error[i+c*m->nbEBands]+.5f)*frac); 380 #endif 381 if (q2 > frac-1) 382 q2 = frac-1; 383 if (q2<0) 384 q2 = 0; 385 ec_enc_bits(enc, q2, fine_quant[i]); 386 #ifdef FIXED_POINT 387 offset = SUB16(SHR32(SHL32(EXTEND32(q2),DB_SHIFT)+QCONST16(.5f,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT)); 388 #else 389 offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f; 390 #endif 391 oldEBands[i+c*m->nbEBands] += offset; 392 error[i+c*m->nbEBands] -= offset; 393 /*printf ("%f ", error[i] - offset);*/ 394 } while (++c < C); 395 } 396 } 397 398 void quant_energy_finalise(const CELTMode *m, int start, int end, opus_val16 *oldEBands, opus_val16 *error, int *fine_quant, int *fine_priority, int bits_left, ec_enc *enc, int C) 399 { 400 int i, prio, c; 401 402 /* Use up the remaining bits */ 403 for (prio=0;prio<2;prio++) 404 { 405 for (i=start;i<end && bits_left>=C ;i++) 406 { 407 if (fine_quant[i] >= MAX_FINE_BITS || fine_priority[i]!=prio) 408 continue; 409 c=0; 410 do { 411 int q2; 412 opus_val16 offset; 413 q2 = error[i+c*m->nbEBands]<0 ? 0 : 1; 414 ec_enc_bits(enc, q2, 1); 415 #ifdef FIXED_POINT 416 offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5f,DB_SHIFT),fine_quant[i]+1); 417 #else 418 offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384); 419 #endif 420 oldEBands[i+c*m->nbEBands] += offset; 421 bits_left--; 422 } while (++c < C); 423 } 424 } 425 } 426 427 void unquant_coarse_energy(const CELTMode *m, int start, int end, opus_val16 *oldEBands, int intra, ec_dec *dec, int C, int LM) 428 { 429 const unsigned char *prob_model = e_prob_model[LM][intra]; 430 int i, c; 431 opus_val32 prev[2] = {0, 0}; 432 opus_val16 coef; 433 opus_val16 beta; 434 opus_int32 budget; 435 opus_int32 tell; 436 437 if (intra) 438 { 439 coef = 0; 440 beta = beta_intra; 441 } else { 442 beta = beta_coef[LM]; 443 coef = pred_coef[LM]; 444 } 445 446 budget = dec->storage*8; 447 448 /* Decode at a fixed coarse resolution */ 449 for (i=start;i<end;i++) 450 { 451 c=0; 452 do { 453 int qi; 454 opus_val32 q; 455 opus_val32 tmp; 456 /* It would be better to express this invariant as a 457 test on C at function entry, but that isn't enough 458 to make the static analyzer happy. */ 459 celt_assert(c<2); 460 tell = ec_tell(dec); 461 if(budget-tell>=15) 462 { 463 int pi; 464 pi = 2*IMIN(i,20); 465 qi = ec_laplace_decode(dec, 466 prob_model[pi]<<7, prob_model[pi+1]<<6); 467 } 468 else if(budget-tell>=2) 469 { 470 qi = ec_dec_icdf(dec, small_energy_icdf, 2); 471 qi = (qi>>1)^-(qi&1); 472 } 473 else if(budget-tell>=1) 474 { 475 qi = -ec_dec_bit_logp(dec, 1); 476 } 477 else 478 qi = -1; 479 q = (opus_val32)SHL32(EXTEND32(qi),DB_SHIFT); 480 481 oldEBands[i+c*m->nbEBands] = MAX16(-QCONST16(9.f,DB_SHIFT), oldEBands[i+c*m->nbEBands]); 482 tmp = PSHR32(MULT16_16(coef,oldEBands[i+c*m->nbEBands]),8) + prev[c] + SHL32(q,7); 483 #ifdef FIXED_POINT 484 tmp = MAX32(-QCONST32(28.f, DB_SHIFT+7), tmp); 485 #endif 486 oldEBands[i+c*m->nbEBands] = PSHR32(tmp, 7); 487 prev[c] = prev[c] + SHL32(q,7) - MULT16_16(beta,PSHR32(q,8)); 488 } while (++c < C); 489 } 490 } 491 492 void unquant_fine_energy(const CELTMode *m, int start, int end, opus_val16 *oldEBands, int *fine_quant, ec_dec *dec, int C) 493 { 494 int i, c; 495 /* Decode finer resolution */ 496 for (i=start;i<end;i++) 497 { 498 if (fine_quant[i] <= 0) 499 continue; 500 c=0; 501 do { 502 int q2; 503 opus_val16 offset; 504 q2 = ec_dec_bits(dec, fine_quant[i]); 505 #ifdef FIXED_POINT 506 offset = SUB16(SHR32(SHL32(EXTEND32(q2),DB_SHIFT)+QCONST16(.5f,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT)); 507 #else 508 offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f; 509 #endif 510 oldEBands[i+c*m->nbEBands] += offset; 511 } while (++c < C); 512 } 513 } 514 515 void unquant_energy_finalise(const CELTMode *m, int start, int end, opus_val16 *oldEBands, int *fine_quant, int *fine_priority, int bits_left, ec_dec *dec, int C) 516 { 517 int i, prio, c; 518 519 /* Use up the remaining bits */ 520 for (prio=0;prio<2;prio++) 521 { 522 for (i=start;i<end && bits_left>=C ;i++) 523 { 524 if (fine_quant[i] >= MAX_FINE_BITS || fine_priority[i]!=prio) 525 continue; 526 c=0; 527 do { 528 int q2; 529 opus_val16 offset; 530 q2 = ec_dec_bits(dec, 1); 531 #ifdef FIXED_POINT 532 offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5f,DB_SHIFT),fine_quant[i]+1); 533 #else 534 offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384); 535 #endif 536 oldEBands[i+c*m->nbEBands] += offset; 537 bits_left--; 538 } while (++c < C); 539 } 540 } 541 } 542 543 void amp2Log2(const CELTMode *m, int effEnd, int end, 544 celt_ener *bandE, opus_val16 *bandLogE, int C) 545 { 546 int c, i; 547 c=0; 548 do { 549 for (i=0;i<effEnd;i++) 550 bandLogE[i+c*m->nbEBands] = 551 celt_log2(SHL32(bandE[i+c*m->nbEBands],2)) 552 - SHL16((opus_val16)eMeans[i],6); 553 for (i=effEnd;i<end;i++) 554 bandLogE[c*m->nbEBands+i] = -QCONST16(14.f,DB_SHIFT); 555 } while (++c < C); 556 } 557
