1 /* Copyright (c) 2007-2008 CSIRO 2 Copyright (c) 2007-2010 Xiph.Org Foundation 3 Copyright (c) 2008 Gregory Maxwell 4 Written by Jean-Marc Valin and Gregory Maxwell */ 5 /* 6 Redistribution and use in source and binary forms, with or without 7 modification, are permitted provided that the following conditions 8 are met: 9 10 - Redistributions of source code must retain the above copyright 11 notice, this list of conditions and the following disclaimer. 12 13 - Redistributions in binary form must reproduce the above copyright 14 notice, this list of conditions and the following disclaimer in the 15 documentation and/or other materials provided with the distribution. 16 17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 21 OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 22 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 23 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 24 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 25 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 26 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 27 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 #ifdef HAVE_CONFIG_H 31 #include "config.h" 32 #endif 33 34 #define CELT_ENCODER_C 35 36 #include "cpu_support.h" 37 #include "os_support.h" 38 #include "mdct.h" 39 #include <math.h> 40 #include "celt.h" 41 #include "pitch.h" 42 #include "bands.h" 43 #include "modes.h" 44 #include "entcode.h" 45 #include "quant_bands.h" 46 #include "rate.h" 47 #include "stack_alloc.h" 48 #include "mathops.h" 49 #include "float_cast.h" 50 #include <stdarg.h> 51 #include "celt_lpc.h" 52 #include "vq.h" 53 54 55 /** Encoder state 56 @brief Encoder state 57 */ 58 struct OpusCustomEncoder { 59 const OpusCustomMode *mode; /**< Mode used by the encoder */ 60 int channels; 61 int stream_channels; 62 63 int force_intra; 64 int clip; 65 int disable_pf; 66 int complexity; 67 int upsample; 68 int start, end; 69 70 opus_int32 bitrate; 71 int vbr; 72 int signalling; 73 int constrained_vbr; /* If zero, VBR can do whatever it likes with the rate */ 74 int loss_rate; 75 int lsb_depth; 76 int variable_duration; 77 int lfe; 78 int arch; 79 80 /* Everything beyond this point gets cleared on a reset */ 81 #define ENCODER_RESET_START rng 82 83 opus_uint32 rng; 84 int spread_decision; 85 opus_val32 delayedIntra; 86 int tonal_average; 87 int lastCodedBands; 88 int hf_average; 89 int tapset_decision; 90 91 int prefilter_period; 92 opus_val16 prefilter_gain; 93 int prefilter_tapset; 94 #ifdef RESYNTH 95 int prefilter_period_old; 96 opus_val16 prefilter_gain_old; 97 int prefilter_tapset_old; 98 #endif 99 int consec_transient; 100 AnalysisInfo analysis; 101 102 opus_val32 preemph_memE[2]; 103 opus_val32 preemph_memD[2]; 104 105 /* VBR-related parameters */ 106 opus_int32 vbr_reservoir; 107 opus_int32 vbr_drift; 108 opus_int32 vbr_offset; 109 opus_int32 vbr_count; 110 opus_val32 overlap_max; 111 opus_val16 stereo_saving; 112 int intensity; 113 opus_val16 *energy_mask; 114 opus_val16 spec_avg; 115 116 #ifdef RESYNTH 117 /* +MAX_PERIOD/2 to make space for overlap */ 118 celt_sig syn_mem[2][2*MAX_PERIOD+MAX_PERIOD/2]; 119 #endif 120 121 celt_sig in_mem[1]; /* Size = channels*mode->overlap */ 122 /* celt_sig prefilter_mem[], Size = channels*COMBFILTER_MAXPERIOD */ 123 /* opus_val16 oldBandE[], Size = channels*mode->nbEBands */ 124 /* opus_val16 oldLogE[], Size = channels*mode->nbEBands */ 125 /* opus_val16 oldLogE2[], Size = channels*mode->nbEBands */ 126 }; 127 128 int celt_encoder_get_size(int channels) 129 { 130 CELTMode *mode = opus_custom_mode_create(48000, 960, NULL); 131 return opus_custom_encoder_get_size(mode, channels); 132 } 133 134 OPUS_CUSTOM_NOSTATIC int opus_custom_encoder_get_size(const CELTMode *mode, int channels) 135 { 136 int size = sizeof(struct CELTEncoder) 137 + (channels*mode->overlap-1)*sizeof(celt_sig) /* celt_sig in_mem[channels*mode->overlap]; */ 138 + channels*COMBFILTER_MAXPERIOD*sizeof(celt_sig) /* celt_sig prefilter_mem[channels*COMBFILTER_MAXPERIOD]; */ 139 + 3*channels*mode->nbEBands*sizeof(opus_val16); /* opus_val16 oldBandE[channels*mode->nbEBands]; */ 140 /* opus_val16 oldLogE[channels*mode->nbEBands]; */ 141 /* opus_val16 oldLogE2[channels*mode->nbEBands]; */ 142 return size; 143 } 144 145 #ifdef CUSTOM_MODES 146 CELTEncoder *opus_custom_encoder_create(const CELTMode *mode, int channels, int *error) 147 { 148 int ret; 149 CELTEncoder *st = (CELTEncoder *)opus_alloc(opus_custom_encoder_get_size(mode, channels)); 150 /* init will handle the NULL case */ 151 ret = opus_custom_encoder_init(st, mode, channels); 152 if (ret != OPUS_OK) 153 { 154 opus_custom_encoder_destroy(st); 155 st = NULL; 156 } 157 if (error) 158 *error = ret; 159 return st; 160 } 161 #endif /* CUSTOM_MODES */ 162 163 static int opus_custom_encoder_init_arch(CELTEncoder *st, const CELTMode *mode, 164 int channels, int arch) 165 { 166 if (channels < 0 || channels > 2) 167 return OPUS_BAD_ARG; 168 169 if (st==NULL || mode==NULL) 170 return OPUS_ALLOC_FAIL; 171 172 OPUS_CLEAR((char*)st, opus_custom_encoder_get_size(mode, channels)); 173 174 st->mode = mode; 175 st->stream_channels = st->channels = channels; 176 177 st->upsample = 1; 178 st->start = 0; 179 st->end = st->mode->effEBands; 180 st->signalling = 1; 181 182 st->arch = arch; 183 184 st->constrained_vbr = 1; 185 st->clip = 1; 186 187 st->bitrate = OPUS_BITRATE_MAX; 188 st->vbr = 0; 189 st->force_intra = 0; 190 st->complexity = 5; 191 st->lsb_depth=24; 192 193 opus_custom_encoder_ctl(st, OPUS_RESET_STATE); 194 195 return OPUS_OK; 196 } 197 198 #ifdef CUSTOM_MODES 199 int opus_custom_encoder_init(CELTEncoder *st, const CELTMode *mode, int channels) 200 { 201 return opus_custom_encoder_init_arch(st, mode, channels, opus_select_arch()); 202 } 203 #endif 204 205 int celt_encoder_init(CELTEncoder *st, opus_int32 sampling_rate, int channels, 206 int arch) 207 { 208 int ret; 209 ret = opus_custom_encoder_init_arch(st, 210 opus_custom_mode_create(48000, 960, NULL), channels, arch); 211 if (ret != OPUS_OK) 212 return ret; 213 st->upsample = resampling_factor(sampling_rate); 214 return OPUS_OK; 215 } 216 217 #ifdef CUSTOM_MODES 218 void opus_custom_encoder_destroy(CELTEncoder *st) 219 { 220 opus_free(st); 221 } 222 #endif /* CUSTOM_MODES */ 223 224 225 static int transient_analysis(const opus_val32 * OPUS_RESTRICT in, int len, int C, 226 opus_val16 *tf_estimate, int *tf_chan) 227 { 228 int i; 229 VARDECL(opus_val16, tmp); 230 opus_val32 mem0,mem1; 231 int is_transient = 0; 232 opus_int32 mask_metric = 0; 233 int c; 234 opus_val16 tf_max; 235 int len2; 236 /* Table of 6*64/x, trained on real data to minimize the average error */ 237 static const unsigned char inv_table[128] = { 238 255,255,156,110, 86, 70, 59, 51, 45, 40, 37, 33, 31, 28, 26, 25, 239 23, 22, 21, 20, 19, 18, 17, 16, 16, 15, 15, 14, 13, 13, 12, 12, 240 12, 12, 11, 11, 11, 10, 10, 10, 9, 9, 9, 9, 9, 9, 8, 8, 241 8, 8, 8, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 242 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 243 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 244 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 245 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 246 }; 247 SAVE_STACK; 248 ALLOC(tmp, len, opus_val16); 249 250 len2=len/2; 251 for (c=0;c<C;c++) 252 { 253 opus_val32 mean; 254 opus_int32 unmask=0; 255 opus_val32 norm; 256 opus_val16 maxE; 257 mem0=0; 258 mem1=0; 259 /* High-pass filter: (1 - 2*z^-1 + z^-2) / (1 - z^-1 + .5*z^-2) */ 260 for (i=0;i<len;i++) 261 { 262 opus_val32 x,y; 263 x = SHR32(in[i+c*len],SIG_SHIFT); 264 y = ADD32(mem0, x); 265 #ifdef FIXED_POINT 266 mem0 = mem1 + y - SHL32(x,1); 267 mem1 = x - SHR32(y,1); 268 #else 269 mem0 = mem1 + y - 2*x; 270 mem1 = x - .5f*y; 271 #endif 272 tmp[i] = EXTRACT16(SHR32(y,2)); 273 /*printf("%f ", tmp[i]);*/ 274 } 275 /*printf("\n");*/ 276 /* First few samples are bad because we don't propagate the memory */ 277 OPUS_CLEAR(tmp, 12); 278 279 #ifdef FIXED_POINT 280 /* Normalize tmp to max range */ 281 { 282 int shift=0; 283 shift = 14-celt_ilog2(1+celt_maxabs16(tmp, len)); 284 if (shift!=0) 285 { 286 for (i=0;i<len;i++) 287 tmp[i] = SHL16(tmp[i], shift); 288 } 289 } 290 #endif 291 292 mean=0; 293 mem0=0; 294 /* Grouping by two to reduce complexity */ 295 /* Forward pass to compute the post-echo threshold*/ 296 for (i=0;i<len2;i++) 297 { 298 opus_val16 x2 = PSHR32(MULT16_16(tmp[2*i],tmp[2*i]) + MULT16_16(tmp[2*i+1],tmp[2*i+1]),16); 299 mean += x2; 300 #ifdef FIXED_POINT 301 /* FIXME: Use PSHR16() instead */ 302 tmp[i] = mem0 + PSHR32(x2-mem0,4); 303 #else 304 tmp[i] = mem0 + MULT16_16_P15(QCONST16(.0625f,15),x2-mem0); 305 #endif 306 mem0 = tmp[i]; 307 } 308 309 mem0=0; 310 maxE=0; 311 /* Backward pass to compute the pre-echo threshold */ 312 for (i=len2-1;i>=0;i--) 313 { 314 #ifdef FIXED_POINT 315 /* FIXME: Use PSHR16() instead */ 316 tmp[i] = mem0 + PSHR32(tmp[i]-mem0,3); 317 #else 318 tmp[i] = mem0 + MULT16_16_P15(QCONST16(0.125f,15),tmp[i]-mem0); 319 #endif 320 mem0 = tmp[i]; 321 maxE = MAX16(maxE, mem0); 322 } 323 /*for (i=0;i<len2;i++)printf("%f ", tmp[i]/mean);printf("\n");*/ 324 325 /* Compute the ratio of the "frame energy" over the harmonic mean of the energy. 326 This essentially corresponds to a bitrate-normalized temporal noise-to-mask 327 ratio */ 328 329 /* As a compromise with the old transient detector, frame energy is the 330 geometric mean of the energy and half the max */ 331 #ifdef FIXED_POINT 332 /* Costs two sqrt() to avoid overflows */ 333 mean = MULT16_16(celt_sqrt(mean), celt_sqrt(MULT16_16(maxE,len2>>1))); 334 #else 335 mean = celt_sqrt(mean * maxE*.5*len2); 336 #endif 337 /* Inverse of the mean energy in Q15+6 */ 338 norm = SHL32(EXTEND32(len2),6+14)/ADD32(EPSILON,SHR32(mean,1)); 339 /* Compute harmonic mean discarding the unreliable boundaries 340 The data is smooth, so we only take 1/4th of the samples */ 341 unmask=0; 342 for (i=12;i<len2-5;i+=4) 343 { 344 int id; 345 #ifdef FIXED_POINT 346 id = MAX32(0,MIN32(127,MULT16_32_Q15(tmp[i]+EPSILON,norm))); /* Do not round to nearest */ 347 #else 348 id = (int)MAX32(0,MIN32(127,floor(64*norm*(tmp[i]+EPSILON)))); /* Do not round to nearest */ 349 #endif 350 unmask += inv_table[id]; 351 } 352 /*printf("%d\n", unmask);*/ 353 /* Normalize, compensate for the 1/4th of the sample and the factor of 6 in the inverse table */ 354 unmask = 64*unmask*4/(6*(len2-17)); 355 if (unmask>mask_metric) 356 { 357 *tf_chan = c; 358 mask_metric = unmask; 359 } 360 } 361 is_transient = mask_metric>200; 362 363 /* Arbitrary metric for VBR boost */ 364 tf_max = MAX16(0,celt_sqrt(27*mask_metric)-42); 365 /* *tf_estimate = 1 + MIN16(1, sqrt(MAX16(0, tf_max-30))/20); */ 366 *tf_estimate = celt_sqrt(MAX32(0, SHL32(MULT16_16(QCONST16(0.0069,14),MIN16(163,tf_max)),14)-QCONST32(0.139,28))); 367 /*printf("%d %f\n", tf_max, mask_metric);*/ 368 RESTORE_STACK; 369 #ifdef FUZZING 370 is_transient = rand()&0x1; 371 #endif 372 /*printf("%d %f %d\n", is_transient, (float)*tf_estimate, tf_max);*/ 373 return is_transient; 374 } 375 376 /* Looks for sudden increases of energy to decide whether we need to patch 377 the transient decision */ 378 static int patch_transient_decision(opus_val16 *newE, opus_val16 *oldE, int nbEBands, 379 int start, int end, int C) 380 { 381 int i, c; 382 opus_val32 mean_diff=0; 383 opus_val16 spread_old[26]; 384 /* Apply an aggressive (-6 dB/Bark) spreading function to the old frame to 385 avoid false detection caused by irrelevant bands */ 386 if (C==1) 387 { 388 spread_old[start] = oldE[start]; 389 for (i=start+1;i<end;i++) 390 spread_old[i] = MAX16(spread_old[i-1]-QCONST16(1.0f, DB_SHIFT), oldE[i]); 391 } else { 392 spread_old[start] = MAX16(oldE[start],oldE[start+nbEBands]); 393 for (i=start+1;i<end;i++) 394 spread_old[i] = MAX16(spread_old[i-1]-QCONST16(1.0f, DB_SHIFT), 395 MAX16(oldE[i],oldE[i+nbEBands])); 396 } 397 for (i=end-2;i>=start;i--) 398 spread_old[i] = MAX16(spread_old[i], spread_old[i+1]-QCONST16(1.0f, DB_SHIFT)); 399 /* Compute mean increase */ 400 c=0; do { 401 for (i=IMAX(2,start);i<end-1;i++) 402 { 403 opus_val16 x1, x2; 404 x1 = MAX16(0, newE[i + c*nbEBands]); 405 x2 = MAX16(0, spread_old[i]); 406 mean_diff = ADD32(mean_diff, EXTEND32(MAX16(0, SUB16(x1, x2)))); 407 } 408 } while (++c<C); 409 mean_diff = DIV32(mean_diff, C*(end-1-IMAX(2,start))); 410 /*printf("%f %f %d\n", mean_diff, max_diff, count);*/ 411 return mean_diff > QCONST16(1.f, DB_SHIFT); 412 } 413 414 /** Apply window and compute the MDCT for all sub-frames and 415 all channels in a frame */ 416 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig * OPUS_RESTRICT in, 417 celt_sig * OPUS_RESTRICT out, int C, int CC, int LM, int upsample, 418 int arch) 419 { 420 const int overlap = mode->overlap; 421 int N; 422 int B; 423 int shift; 424 int i, b, c; 425 if (shortBlocks) 426 { 427 B = shortBlocks; 428 N = mode->shortMdctSize; 429 shift = mode->maxLM; 430 } else { 431 B = 1; 432 N = mode->shortMdctSize<<LM; 433 shift = mode->maxLM-LM; 434 } 435 c=0; do { 436 for (b=0;b<B;b++) 437 { 438 /* Interleaving the sub-frames while doing the MDCTs */ 439 clt_mdct_forward(&mode->mdct, in+c*(B*N+overlap)+b*N, 440 &out[b+c*N*B], mode->window, overlap, shift, B, 441 arch); 442 } 443 } while (++c<CC); 444 if (CC==2&&C==1) 445 { 446 for (i=0;i<B*N;i++) 447 out[i] = ADD32(HALF32(out[i]), HALF32(out[B*N+i])); 448 } 449 if (upsample != 1) 450 { 451 c=0; do 452 { 453 int bound = B*N/upsample; 454 for (i=0;i<bound;i++) 455 out[c*B*N+i] *= upsample; 456 OPUS_CLEAR(&out[c*B*N+bound], B*N-bound); 457 } while (++c<C); 458 } 459 } 460 461 462 void celt_preemphasis(const opus_val16 * OPUS_RESTRICT pcmp, celt_sig * OPUS_RESTRICT inp, 463 int N, int CC, int upsample, const opus_val16 *coef, celt_sig *mem, int clip) 464 { 465 int i; 466 opus_val16 coef0; 467 celt_sig m; 468 int Nu; 469 470 coef0 = coef[0]; 471 m = *mem; 472 473 /* Fast path for the normal 48kHz case and no clipping */ 474 if (coef[1] == 0 && upsample == 1 && !clip) 475 { 476 for (i=0;i<N;i++) 477 { 478 opus_val16 x; 479 x = SCALEIN(pcmp[CC*i]); 480 /* Apply pre-emphasis */ 481 inp[i] = SHL32(x, SIG_SHIFT) - m; 482 m = SHR32(MULT16_16(coef0, x), 15-SIG_SHIFT); 483 } 484 *mem = m; 485 return; 486 } 487 488 Nu = N/upsample; 489 if (upsample!=1) 490 { 491 OPUS_CLEAR(inp, N); 492 } 493 for (i=0;i<Nu;i++) 494 inp[i*upsample] = SCALEIN(pcmp[CC*i]); 495 496 #ifndef FIXED_POINT 497 if (clip) 498 { 499 /* Clip input to avoid encoding non-portable files */ 500 for (i=0;i<Nu;i++) 501 inp[i*upsample] = MAX32(-65536.f, MIN32(65536.f,inp[i*upsample])); 502 } 503 #else 504 (void)clip; /* Avoids a warning about clip being unused. */ 505 #endif 506 #ifdef CUSTOM_MODES 507 if (coef[1] != 0) 508 { 509 opus_val16 coef1 = coef[1]; 510 opus_val16 coef2 = coef[2]; 511 for (i=0;i<N;i++) 512 { 513 celt_sig x, tmp; 514 x = inp[i]; 515 /* Apply pre-emphasis */ 516 tmp = MULT16_16(coef2, x); 517 inp[i] = tmp + m; 518 m = MULT16_32_Q15(coef1, inp[i]) - MULT16_32_Q15(coef0, tmp); 519 } 520 } else 521 #endif 522 { 523 for (i=0;i<N;i++) 524 { 525 opus_val16 x; 526 x = inp[i]; 527 /* Apply pre-emphasis */ 528 inp[i] = SHL32(x, SIG_SHIFT) - m; 529 m = SHR32(MULT16_16(coef0, x), 15-SIG_SHIFT); 530 } 531 } 532 *mem = m; 533 } 534 535 536 537 static opus_val32 l1_metric(const celt_norm *tmp, int N, int LM, opus_val16 bias) 538 { 539 int i; 540 opus_val32 L1; 541 L1 = 0; 542 for (i=0;i<N;i++) 543 L1 += EXTEND32(ABS16(tmp[i])); 544 /* When in doubt, prefer good freq resolution */ 545 L1 = MAC16_32_Q15(L1, LM*bias, L1); 546 return L1; 547 548 } 549 550 static int tf_analysis(const CELTMode *m, int len, int isTransient, 551 int *tf_res, int lambda, celt_norm *X, int N0, int LM, 552 int *tf_sum, opus_val16 tf_estimate, int tf_chan) 553 { 554 int i; 555 VARDECL(int, metric); 556 int cost0; 557 int cost1; 558 VARDECL(int, path0); 559 VARDECL(int, path1); 560 VARDECL(celt_norm, tmp); 561 VARDECL(celt_norm, tmp_1); 562 int sel; 563 int selcost[2]; 564 int tf_select=0; 565 opus_val16 bias; 566 567 SAVE_STACK; 568 bias = MULT16_16_Q14(QCONST16(.04f,15), MAX16(-QCONST16(.25f,14), QCONST16(.5f,14)-tf_estimate)); 569 /*printf("%f ", bias);*/ 570 571 ALLOC(metric, len, int); 572 ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm); 573 ALLOC(tmp_1, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm); 574 ALLOC(path0, len, int); 575 ALLOC(path1, len, int); 576 577 *tf_sum = 0; 578 for (i=0;i<len;i++) 579 { 580 int k, N; 581 int narrow; 582 opus_val32 L1, best_L1; 583 int best_level=0; 584 N = (m->eBands[i+1]-m->eBands[i])<<LM; 585 /* band is too narrow to be split down to LM=-1 */ 586 narrow = (m->eBands[i+1]-m->eBands[i])==1; 587 OPUS_COPY(tmp, &X[tf_chan*N0 + (m->eBands[i]<<LM)], N); 588 /* Just add the right channel if we're in stereo */ 589 /*if (C==2) 590 for (j=0;j<N;j++) 591 tmp[j] = ADD16(SHR16(tmp[j], 1),SHR16(X[N0+j+(m->eBands[i]<<LM)], 1));*/ 592 L1 = l1_metric(tmp, N, isTransient ? LM : 0, bias); 593 best_L1 = L1; 594 /* Check the -1 case for transients */ 595 if (isTransient && !narrow) 596 { 597 OPUS_COPY(tmp_1, tmp, N); 598 haar1(tmp_1, N>>LM, 1<<LM); 599 L1 = l1_metric(tmp_1, N, LM+1, bias); 600 if (L1<best_L1) 601 { 602 best_L1 = L1; 603 best_level = -1; 604 } 605 } 606 /*printf ("%f ", L1);*/ 607 for (k=0;k<LM+!(isTransient||narrow);k++) 608 { 609 int B; 610 611 if (isTransient) 612 B = (LM-k-1); 613 else 614 B = k+1; 615 616 haar1(tmp, N>>k, 1<<k); 617 618 L1 = l1_metric(tmp, N, B, bias); 619 620 if (L1 < best_L1) 621 { 622 best_L1 = L1; 623 best_level = k+1; 624 } 625 } 626 /*printf ("%d ", isTransient ? LM-best_level : best_level);*/ 627 /* metric is in Q1 to be able to select the mid-point (-0.5) for narrower bands */ 628 if (isTransient) 629 metric[i] = 2*best_level; 630 else 631 metric[i] = -2*best_level; 632 *tf_sum += (isTransient ? LM : 0) - metric[i]/2; 633 /* For bands that can't be split to -1, set the metric to the half-way point to avoid 634 biasing the decision */ 635 if (narrow && (metric[i]==0 || metric[i]==-2*LM)) 636 metric[i]-=1; 637 /*printf("%d ", metric[i]);*/ 638 } 639 /*printf("\n");*/ 640 /* Search for the optimal tf resolution, including tf_select */ 641 tf_select = 0; 642 for (sel=0;sel<2;sel++) 643 { 644 cost0 = 0; 645 cost1 = isTransient ? 0 : lambda; 646 for (i=1;i<len;i++) 647 { 648 int curr0, curr1; 649 curr0 = IMIN(cost0, cost1 + lambda); 650 curr1 = IMIN(cost0 + lambda, cost1); 651 cost0 = curr0 + abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*sel+0]); 652 cost1 = curr1 + abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*sel+1]); 653 } 654 cost0 = IMIN(cost0, cost1); 655 selcost[sel]=cost0; 656 } 657 /* For now, we're conservative and only allow tf_select=1 for transients. 658 * If tests confirm it's useful for non-transients, we could allow it. */ 659 if (selcost[1]<selcost[0] && isTransient) 660 tf_select=1; 661 cost0 = 0; 662 cost1 = isTransient ? 0 : lambda; 663 /* Viterbi forward pass */ 664 for (i=1;i<len;i++) 665 { 666 int curr0, curr1; 667 int from0, from1; 668 669 from0 = cost0; 670 from1 = cost1 + lambda; 671 if (from0 < from1) 672 { 673 curr0 = from0; 674 path0[i]= 0; 675 } else { 676 curr0 = from1; 677 path0[i]= 1; 678 } 679 680 from0 = cost0 + lambda; 681 from1 = cost1; 682 if (from0 < from1) 683 { 684 curr1 = from0; 685 path1[i]= 0; 686 } else { 687 curr1 = from1; 688 path1[i]= 1; 689 } 690 cost0 = curr0 + abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*tf_select+0]); 691 cost1 = curr1 + abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*tf_select+1]); 692 } 693 tf_res[len-1] = cost0 < cost1 ? 0 : 1; 694 /* Viterbi backward pass to check the decisions */ 695 for (i=len-2;i>=0;i--) 696 { 697 if (tf_res[i+1] == 1) 698 tf_res[i] = path1[i+1]; 699 else 700 tf_res[i] = path0[i+1]; 701 } 702 /*printf("%d %f\n", *tf_sum, tf_estimate);*/ 703 RESTORE_STACK; 704 #ifdef FUZZING 705 tf_select = rand()&0x1; 706 tf_res[0] = rand()&0x1; 707 for (i=1;i<len;i++) 708 tf_res[i] = tf_res[i-1] ^ ((rand()&0xF) == 0); 709 #endif 710 return tf_select; 711 } 712 713 static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM, int tf_select, ec_enc *enc) 714 { 715 int curr, i; 716 int tf_select_rsv; 717 int tf_changed; 718 int logp; 719 opus_uint32 budget; 720 opus_uint32 tell; 721 budget = enc->storage*8; 722 tell = ec_tell(enc); 723 logp = isTransient ? 2 : 4; 724 /* Reserve space to code the tf_select decision. */ 725 tf_select_rsv = LM>0 && tell+logp+1 <= budget; 726 budget -= tf_select_rsv; 727 curr = tf_changed = 0; 728 for (i=start;i<end;i++) 729 { 730 if (tell+logp<=budget) 731 { 732 ec_enc_bit_logp(enc, tf_res[i] ^ curr, logp); 733 tell = ec_tell(enc); 734 curr = tf_res[i]; 735 tf_changed |= curr; 736 } 737 else 738 tf_res[i] = curr; 739 logp = isTransient ? 4 : 5; 740 } 741 /* Only code tf_select if it would actually make a difference. */ 742 if (tf_select_rsv && 743 tf_select_table[LM][4*isTransient+0+tf_changed]!= 744 tf_select_table[LM][4*isTransient+2+tf_changed]) 745 ec_enc_bit_logp(enc, tf_select, 1); 746 else 747 tf_select = 0; 748 for (i=start;i<end;i++) 749 tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]]; 750 /*for(i=0;i<end;i++)printf("%d ", isTransient ? tf_res[i] : LM+tf_res[i]);printf("\n");*/ 751 } 752 753 754 static int alloc_trim_analysis(const CELTMode *m, const celt_norm *X, 755 const opus_val16 *bandLogE, int end, int LM, int C, int N0, 756 AnalysisInfo *analysis, opus_val16 *stereo_saving, opus_val16 tf_estimate, 757 int intensity, opus_val16 surround_trim, int arch) 758 { 759 int i; 760 opus_val32 diff=0; 761 int c; 762 int trim_index; 763 opus_val16 trim = QCONST16(5.f, 8); 764 opus_val16 logXC, logXC2; 765 if (C==2) 766 { 767 opus_val16 sum = 0; /* Q10 */ 768 opus_val16 minXC; /* Q10 */ 769 /* Compute inter-channel correlation for low frequencies */ 770 for (i=0;i<8;i++) 771 { 772 opus_val32 partial; 773 partial = celt_inner_prod(&X[m->eBands[i]<<LM], &X[N0+(m->eBands[i]<<LM)], 774 (m->eBands[i+1]-m->eBands[i])<<LM, arch); 775 sum = ADD16(sum, EXTRACT16(SHR32(partial, 18))); 776 } 777 sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum); 778 sum = MIN16(QCONST16(1.f, 10), ABS16(sum)); 779 minXC = sum; 780 for (i=8;i<intensity;i++) 781 { 782 opus_val32 partial; 783 partial = celt_inner_prod(&X[m->eBands[i]<<LM], &X[N0+(m->eBands[i]<<LM)], 784 (m->eBands[i+1]-m->eBands[i])<<LM, arch); 785 minXC = MIN16(minXC, ABS16(EXTRACT16(SHR32(partial, 18)))); 786 } 787 minXC = MIN16(QCONST16(1.f, 10), ABS16(minXC)); 788 /*printf ("%f\n", sum);*/ 789 /* mid-side savings estimations based on the LF average*/ 790 logXC = celt_log2(QCONST32(1.001f, 20)-MULT16_16(sum, sum)); 791 /* mid-side savings estimations based on min correlation */ 792 logXC2 = MAX16(HALF16(logXC), celt_log2(QCONST32(1.001f, 20)-MULT16_16(minXC, minXC))); 793 #ifdef FIXED_POINT 794 /* Compensate for Q20 vs Q14 input and convert output to Q8 */ 795 logXC = PSHR32(logXC-QCONST16(6.f, DB_SHIFT),DB_SHIFT-8); 796 logXC2 = PSHR32(logXC2-QCONST16(6.f, DB_SHIFT),DB_SHIFT-8); 797 #endif 798 799 trim += MAX16(-QCONST16(4.f, 8), MULT16_16_Q15(QCONST16(.75f,15),logXC)); 800 *stereo_saving = MIN16(*stereo_saving + QCONST16(0.25f, 8), -HALF16(logXC2)); 801 } 802 803 /* Estimate spectral tilt */ 804 c=0; do { 805 for (i=0;i<end-1;i++) 806 { 807 diff += bandLogE[i+c*m->nbEBands]*(opus_int32)(2+2*i-end); 808 } 809 } while (++c<C); 810 diff /= C*(end-1); 811 /*printf("%f\n", diff);*/ 812 trim -= MAX16(-QCONST16(2.f, 8), MIN16(QCONST16(2.f, 8), SHR16(diff+QCONST16(1.f, DB_SHIFT),DB_SHIFT-8)/6 )); 813 trim -= SHR16(surround_trim, DB_SHIFT-8); 814 trim -= 2*SHR16(tf_estimate, 14-8); 815 #ifndef DISABLE_FLOAT_API 816 if (analysis->valid) 817 { 818 trim -= MAX16(-QCONST16(2.f, 8), MIN16(QCONST16(2.f, 8), 819 (opus_val16)(QCONST16(2.f, 8)*(analysis->tonality_slope+.05f)))); 820 } 821 #else 822 (void)analysis; 823 #endif 824 825 #ifdef FIXED_POINT 826 trim_index = PSHR32(trim, 8); 827 #else 828 trim_index = (int)floor(.5f+trim); 829 #endif 830 trim_index = IMAX(0, IMIN(10, trim_index)); 831 /*printf("%d\n", trim_index);*/ 832 #ifdef FUZZING 833 trim_index = rand()%11; 834 #endif 835 return trim_index; 836 } 837 838 static int stereo_analysis(const CELTMode *m, const celt_norm *X, 839 int LM, int N0) 840 { 841 int i; 842 int thetas; 843 opus_val32 sumLR = EPSILON, sumMS = EPSILON; 844 845 /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */ 846 for (i=0;i<13;i++) 847 { 848 int j; 849 for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++) 850 { 851 opus_val32 L, R, M, S; 852 /* We cast to 32-bit first because of the -32768 case */ 853 L = EXTEND32(X[j]); 854 R = EXTEND32(X[N0+j]); 855 M = ADD32(L, R); 856 S = SUB32(L, R); 857 sumLR = ADD32(sumLR, ADD32(ABS32(L), ABS32(R))); 858 sumMS = ADD32(sumMS, ADD32(ABS32(M), ABS32(S))); 859 } 860 } 861 sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS); 862 thetas = 13; 863 /* We don't need thetas for lower bands with LM<=1 */ 864 if (LM<=1) 865 thetas -= 8; 866 return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS) 867 > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR); 868 } 869 870 #define MSWAP(a,b) do {opus_val16 tmp = a;a=b;b=tmp;} while(0) 871 static opus_val16 median_of_5(const opus_val16 *x) 872 { 873 opus_val16 t0, t1, t2, t3, t4; 874 t2 = x[2]; 875 if (x[0] > x[1]) 876 { 877 t0 = x[1]; 878 t1 = x[0]; 879 } else { 880 t0 = x[0]; 881 t1 = x[1]; 882 } 883 if (x[3] > x[4]) 884 { 885 t3 = x[4]; 886 t4 = x[3]; 887 } else { 888 t3 = x[3]; 889 t4 = x[4]; 890 } 891 if (t0 > t3) 892 { 893 MSWAP(t0, t3); 894 MSWAP(t1, t4); 895 } 896 if (t2 > t1) 897 { 898 if (t1 < t3) 899 return MIN16(t2, t3); 900 else 901 return MIN16(t4, t1); 902 } else { 903 if (t2 < t3) 904 return MIN16(t1, t3); 905 else 906 return MIN16(t2, t4); 907 } 908 } 909 910 static opus_val16 median_of_3(const opus_val16 *x) 911 { 912 opus_val16 t0, t1, t2; 913 if (x[0] > x[1]) 914 { 915 t0 = x[1]; 916 t1 = x[0]; 917 } else { 918 t0 = x[0]; 919 t1 = x[1]; 920 } 921 t2 = x[2]; 922 if (t1 < t2) 923 return t1; 924 else if (t0 < t2) 925 return t2; 926 else 927 return t0; 928 } 929 930 static opus_val16 dynalloc_analysis(const opus_val16 *bandLogE, const opus_val16 *bandLogE2, 931 int nbEBands, int start, int end, int C, int *offsets, int lsb_depth, const opus_int16 *logN, 932 int isTransient, int vbr, int constrained_vbr, const opus_int16 *eBands, int LM, 933 int effectiveBytes, opus_int32 *tot_boost_, int lfe, opus_val16 *surround_dynalloc) 934 { 935 int i, c; 936 opus_int32 tot_boost=0; 937 opus_val16 maxDepth; 938 VARDECL(opus_val16, follower); 939 VARDECL(opus_val16, noise_floor); 940 SAVE_STACK; 941 ALLOC(follower, C*nbEBands, opus_val16); 942 ALLOC(noise_floor, C*nbEBands, opus_val16); 943 OPUS_CLEAR(offsets, nbEBands); 944 /* Dynamic allocation code */ 945 maxDepth=-QCONST16(31.9f, DB_SHIFT); 946 for (i=0;i<end;i++) 947 { 948 /* Noise floor must take into account eMeans, the depth, the width of the bands 949 and the preemphasis filter (approx. square of bark band ID) */ 950 noise_floor[i] = MULT16_16(QCONST16(0.0625f, DB_SHIFT),logN[i]) 951 +QCONST16(.5f,DB_SHIFT)+SHL16(9-lsb_depth,DB_SHIFT)-SHL16(eMeans[i],6) 952 +MULT16_16(QCONST16(.0062,DB_SHIFT),(i+5)*(i+5)); 953 } 954 c=0;do 955 { 956 for (i=0;i<end;i++) 957 maxDepth = MAX16(maxDepth, bandLogE[c*nbEBands+i]-noise_floor[i]); 958 } while (++c<C); 959 /* Make sure that dynamic allocation can't make us bust the budget */ 960 if (effectiveBytes > 50 && LM>=1 && !lfe) 961 { 962 int last=0; 963 c=0;do 964 { 965 opus_val16 offset; 966 opus_val16 tmp; 967 opus_val16 *f; 968 f = &follower[c*nbEBands]; 969 f[0] = bandLogE2[c*nbEBands]; 970 for (i=1;i<end;i++) 971 { 972 /* The last band to be at least 3 dB higher than the previous one 973 is the last we'll consider. Otherwise, we run into problems on 974 bandlimited signals. */ 975 if (bandLogE2[c*nbEBands+i] > bandLogE2[c*nbEBands+i-1]+QCONST16(.5f,DB_SHIFT)) 976 last=i; 977 f[i] = MIN16(f[i-1]+QCONST16(1.5f,DB_SHIFT), bandLogE2[c*nbEBands+i]); 978 } 979 for (i=last-1;i>=0;i--) 980 f[i] = MIN16(f[i], MIN16(f[i+1]+QCONST16(2.f,DB_SHIFT), bandLogE2[c*nbEBands+i])); 981 982 /* Combine with a median filter to avoid dynalloc triggering unnecessarily. 983 The "offset" value controls how conservative we are -- a higher offset 984 reduces the impact of the median filter and makes dynalloc use more bits. */ 985 offset = QCONST16(1.f, DB_SHIFT); 986 for (i=2;i<end-2;i++) 987 f[i] = MAX16(f[i], median_of_5(&bandLogE2[c*nbEBands+i-2])-offset); 988 tmp = median_of_3(&bandLogE2[c*nbEBands])-offset; 989 f[0] = MAX16(f[0], tmp); 990 f[1] = MAX16(f[1], tmp); 991 tmp = median_of_3(&bandLogE2[c*nbEBands+end-3])-offset; 992 f[end-2] = MAX16(f[end-2], tmp); 993 f[end-1] = MAX16(f[end-1], tmp); 994 995 for (i=0;i<end;i++) 996 f[i] = MAX16(f[i], noise_floor[i]); 997 } while (++c<C); 998 if (C==2) 999 { 1000 for (i=start;i<end;i++) 1001 { 1002 /* Consider 24 dB "cross-talk" */ 1003 follower[nbEBands+i] = MAX16(follower[nbEBands+i], follower[ i]-QCONST16(4.f,DB_SHIFT)); 1004 follower[ i] = MAX16(follower[ i], follower[nbEBands+i]-QCONST16(4.f,DB_SHIFT)); 1005 follower[i] = HALF16(MAX16(0, bandLogE[i]-follower[i]) + MAX16(0, bandLogE[nbEBands+i]-follower[nbEBands+i])); 1006 } 1007 } else { 1008 for (i=start;i<end;i++) 1009 { 1010 follower[i] = MAX16(0, bandLogE[i]-follower[i]); 1011 } 1012 } 1013 for (i=start;i<end;i++) 1014 follower[i] = MAX16(follower[i], surround_dynalloc[i]); 1015 /* For non-transient CBR/CVBR frames, halve the dynalloc contribution */ 1016 if ((!vbr || constrained_vbr)&&!isTransient) 1017 { 1018 for (i=start;i<end;i++) 1019 follower[i] = HALF16(follower[i]); 1020 } 1021 for (i=start;i<end;i++) 1022 { 1023 int width; 1024 int boost; 1025 int boost_bits; 1026 1027 if (i<8) 1028 follower[i] *= 2; 1029 if (i>=12) 1030 follower[i] = HALF16(follower[i]); 1031 follower[i] = MIN16(follower[i], QCONST16(4, DB_SHIFT)); 1032 1033 width = C*(eBands[i+1]-eBands[i])<<LM; 1034 if (width<6) 1035 { 1036 boost = (int)SHR32(EXTEND32(follower[i]),DB_SHIFT); 1037 boost_bits = boost*width<<BITRES; 1038 } else if (width > 48) { 1039 boost = (int)SHR32(EXTEND32(follower[i])*8,DB_SHIFT); 1040 boost_bits = (boost*width<<BITRES)/8; 1041 } else { 1042 boost = (int)SHR32(EXTEND32(follower[i])*width/6,DB_SHIFT); 1043 boost_bits = boost*6<<BITRES; 1044 } 1045 /* For CBR and non-transient CVBR frames, limit dynalloc to 1/4 of the bits */ 1046 if ((!vbr || (constrained_vbr&&!isTransient)) 1047 && (tot_boost+boost_bits)>>BITRES>>3 > effectiveBytes/4) 1048 { 1049 opus_int32 cap = ((effectiveBytes/4)<<BITRES<<3); 1050 offsets[i] = cap-tot_boost; 1051 tot_boost = cap; 1052 break; 1053 } else { 1054 offsets[i] = boost; 1055 tot_boost += boost_bits; 1056 } 1057 } 1058 } 1059 *tot_boost_ = tot_boost; 1060 RESTORE_STACK; 1061 return maxDepth; 1062 } 1063 1064 1065 static int run_prefilter(CELTEncoder *st, celt_sig *in, celt_sig *prefilter_mem, int CC, int N, 1066 int prefilter_tapset, int *pitch, opus_val16 *gain, int *qgain, int enabled, int nbAvailableBytes) 1067 { 1068 int c; 1069 VARDECL(celt_sig, _pre); 1070 celt_sig *pre[2]; 1071 const CELTMode *mode; 1072 int pitch_index; 1073 opus_val16 gain1; 1074 opus_val16 pf_threshold; 1075 int pf_on; 1076 int qg; 1077 int overlap; 1078 SAVE_STACK; 1079 1080 mode = st->mode; 1081 overlap = mode->overlap; 1082 ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig); 1083 1084 pre[0] = _pre; 1085 pre[1] = _pre + (N+COMBFILTER_MAXPERIOD); 1086 1087 1088 c=0; do { 1089 OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD); 1090 OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+overlap)+overlap, N); 1091 } while (++c<CC); 1092 1093 if (enabled) 1094 { 1095 VARDECL(opus_val16, pitch_buf); 1096 ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16); 1097 1098 pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC, st->arch); 1099 /* Don't search for the fir last 1.5 octave of the range because 1100 there's too many false-positives due to short-term correlation */ 1101 pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N, 1102 COMBFILTER_MAXPERIOD-3*COMBFILTER_MINPERIOD, &pitch_index, 1103 st->arch); 1104 pitch_index = COMBFILTER_MAXPERIOD-pitch_index; 1105 1106 gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD, 1107 N, &pitch_index, st->prefilter_period, st->prefilter_gain, st->arch); 1108 if (pitch_index > COMBFILTER_MAXPERIOD-2) 1109 pitch_index = COMBFILTER_MAXPERIOD-2; 1110 gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1); 1111 /*printf("%d %d %f %f\n", pitch_change, pitch_index, gain1, st->analysis.tonality);*/ 1112 if (st->loss_rate>2) 1113 gain1 = HALF32(gain1); 1114 if (st->loss_rate>4) 1115 gain1 = HALF32(gain1); 1116 if (st->loss_rate>8) 1117 gain1 = 0; 1118 } else { 1119 gain1 = 0; 1120 pitch_index = COMBFILTER_MINPERIOD; 1121 } 1122 1123 /* Gain threshold for enabling the prefilter/postfilter */ 1124 pf_threshold = QCONST16(.2f,15); 1125 1126 /* Adjusting the threshold based on rate and continuity */ 1127 if (abs(pitch_index-st->prefilter_period)*10>pitch_index) 1128 pf_threshold += QCONST16(.2f,15); 1129 if (nbAvailableBytes<25) 1130 pf_threshold += QCONST16(.1f,15); 1131 if (nbAvailableBytes<35) 1132 pf_threshold += QCONST16(.1f,15); 1133 if (st->prefilter_gain > QCONST16(.4f,15)) 1134 pf_threshold -= QCONST16(.1f,15); 1135 if (st->prefilter_gain > QCONST16(.55f,15)) 1136 pf_threshold -= QCONST16(.1f,15); 1137 1138 /* Hard threshold at 0.2 */ 1139 pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15)); 1140 if (gain1<pf_threshold) 1141 { 1142 gain1 = 0; 1143 pf_on = 0; 1144 qg = 0; 1145 } else { 1146 /*This block is not gated by a total bits check only because 1147 of the nbAvailableBytes check above.*/ 1148 if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15)) 1149 gain1=st->prefilter_gain; 1150 1151 #ifdef FIXED_POINT 1152 qg = ((gain1+1536)>>10)/3-1; 1153 #else 1154 qg = (int)floor(.5f+gain1*32/3)-1; 1155 #endif 1156 qg = IMAX(0, IMIN(7, qg)); 1157 gain1 = QCONST16(0.09375f,15)*(qg+1); 1158 pf_on = 1; 1159 } 1160 /*printf("%d %f\n", pitch_index, gain1);*/ 1161 1162 c=0; do { 1163 int offset = mode->shortMdctSize-overlap; 1164 st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD); 1165 OPUS_COPY(in+c*(N+overlap), st->in_mem+c*(overlap), overlap); 1166 if (offset) 1167 comb_filter(in+c*(N+overlap)+overlap, pre[c]+COMBFILTER_MAXPERIOD, 1168 st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain, 1169 st->prefilter_tapset, st->prefilter_tapset, NULL, 0, st->arch); 1170 1171 comb_filter(in+c*(N+overlap)+overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset, 1172 st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1, 1173 st->prefilter_tapset, prefilter_tapset, mode->window, overlap, st->arch); 1174 OPUS_COPY(st->in_mem+c*(overlap), in+c*(N+overlap)+N, overlap); 1175 1176 if (N>COMBFILTER_MAXPERIOD) 1177 { 1178 OPUS_COPY(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD); 1179 } else { 1180 OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N); 1181 OPUS_COPY(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N); 1182 } 1183 } while (++c<CC); 1184 1185 RESTORE_STACK; 1186 *gain = gain1; 1187 *pitch = pitch_index; 1188 *qgain = qg; 1189 return pf_on; 1190 } 1191 1192 static int compute_vbr(const CELTMode *mode, AnalysisInfo *analysis, opus_int32 base_target, 1193 int LM, opus_int32 bitrate, int lastCodedBands, int C, int intensity, 1194 int constrained_vbr, opus_val16 stereo_saving, int tot_boost, 1195 opus_val16 tf_estimate, int pitch_change, opus_val16 maxDepth, 1196 int variable_duration, int lfe, int has_surround_mask, opus_val16 surround_masking, 1197 opus_val16 temporal_vbr) 1198 { 1199 /* The target rate in 8th bits per frame */ 1200 opus_int32 target; 1201 int coded_bins; 1202 int coded_bands; 1203 opus_val16 tf_calibration; 1204 int nbEBands; 1205 const opus_int16 *eBands; 1206 1207 nbEBands = mode->nbEBands; 1208 eBands = mode->eBands; 1209 1210 coded_bands = lastCodedBands ? lastCodedBands : nbEBands; 1211 coded_bins = eBands[coded_bands]<<LM; 1212 if (C==2) 1213 coded_bins += eBands[IMIN(intensity, coded_bands)]<<LM; 1214 1215 target = base_target; 1216 1217 /*printf("%f %f %f %f %d %d ", st->analysis.activity, st->analysis.tonality, tf_estimate, st->stereo_saving, tot_boost, coded_bands);*/ 1218 #ifndef DISABLE_FLOAT_API 1219 if (analysis->valid && analysis->activity<.4) 1220 target -= (opus_int32)((coded_bins<<BITRES)*(.4f-analysis->activity)); 1221 #endif 1222 /* Stereo savings */ 1223 if (C==2) 1224 { 1225 int coded_stereo_bands; 1226 int coded_stereo_dof; 1227 opus_val16 max_frac; 1228 coded_stereo_bands = IMIN(intensity, coded_bands); 1229 coded_stereo_dof = (eBands[coded_stereo_bands]<<LM)-coded_stereo_bands; 1230 /* Maximum fraction of the bits we can save if the signal is mono. */ 1231 max_frac = DIV32_16(MULT16_16(QCONST16(0.8f, 15), coded_stereo_dof), coded_bins); 1232 stereo_saving = MIN16(stereo_saving, QCONST16(1.f, 8)); 1233 /*printf("%d %d %d ", coded_stereo_dof, coded_bins, tot_boost);*/ 1234 target -= (opus_int32)MIN32(MULT16_32_Q15(max_frac,target), 1235 SHR32(MULT16_16(stereo_saving-QCONST16(0.1f,8),(coded_stereo_dof<<BITRES)),8)); 1236 } 1237 /* Boost the rate according to dynalloc (minus the dynalloc average for calibration). */ 1238 target += tot_boost-(16<<LM); 1239 /* Apply transient boost, compensating for average boost. */ 1240 tf_calibration = variable_duration==OPUS_FRAMESIZE_VARIABLE ? 1241 QCONST16(0.02f,14) : QCONST16(0.04f,14); 1242 target += (opus_int32)SHL32(MULT16_32_Q15(tf_estimate-tf_calibration, target),1); 1243 1244 #ifndef DISABLE_FLOAT_API 1245 /* Apply tonality boost */ 1246 if (analysis->valid && !lfe) 1247 { 1248 opus_int32 tonal_target; 1249 float tonal; 1250 1251 /* Tonality boost (compensating for the average). */ 1252 tonal = MAX16(0.f,analysis->tonality-.15f)-0.09f; 1253 tonal_target = target + (opus_int32)((coded_bins<<BITRES)*1.2f*tonal); 1254 if (pitch_change) 1255 tonal_target += (opus_int32)((coded_bins<<BITRES)*.8f); 1256 /*printf("%f %f ", analysis->tonality, tonal);*/ 1257 target = tonal_target; 1258 } 1259 #else 1260 (void)analysis; 1261 (void)pitch_change; 1262 #endif 1263 1264 if (has_surround_mask&&!lfe) 1265 { 1266 opus_int32 surround_target = target + (opus_int32)SHR32(MULT16_16(surround_masking,coded_bins<<BITRES), DB_SHIFT); 1267 /*printf("%f %d %d %d %d %d %d ", surround_masking, coded_bins, st->end, st->intensity, surround_target, target, st->bitrate);*/ 1268 target = IMAX(target/4, surround_target); 1269 } 1270 1271 { 1272 opus_int32 floor_depth; 1273 int bins; 1274 bins = eBands[nbEBands-2]<<LM; 1275 /*floor_depth = SHR32(MULT16_16((C*bins<<BITRES),celt_log2(SHL32(MAX16(1,sample_max),13))), DB_SHIFT);*/ 1276 floor_depth = (opus_int32)SHR32(MULT16_16((C*bins<<BITRES),maxDepth), DB_SHIFT); 1277 floor_depth = IMAX(floor_depth, target>>2); 1278 target = IMIN(target, floor_depth); 1279 /*printf("%f %d\n", maxDepth, floor_depth);*/ 1280 } 1281 1282 if ((!has_surround_mask||lfe) && (constrained_vbr || bitrate<64000)) 1283 { 1284 opus_val16 rate_factor = Q15ONE; 1285 if (bitrate < 64000) 1286 { 1287 #ifdef FIXED_POINT 1288 rate_factor = MAX16(0,(bitrate-32000)); 1289 #else 1290 rate_factor = MAX16(0,(1.f/32768)*(bitrate-32000)); 1291 #endif 1292 } 1293 if (constrained_vbr) 1294 rate_factor = MIN16(rate_factor, QCONST16(0.67f, 15)); 1295 target = base_target + (opus_int32)MULT16_32_Q15(rate_factor, target-base_target); 1296 1297 } 1298 1299 if (!has_surround_mask && tf_estimate < QCONST16(.2f, 14)) 1300 { 1301 opus_val16 amount; 1302 opus_val16 tvbr_factor; 1303 amount = MULT16_16_Q15(QCONST16(.0000031f, 30), IMAX(0, IMIN(32000, 96000-bitrate))); 1304 tvbr_factor = SHR32(MULT16_16(temporal_vbr, amount), DB_SHIFT); 1305 target += (opus_int32)MULT16_32_Q15(tvbr_factor, target); 1306 } 1307 1308 /* Don't allow more than doubling the rate */ 1309 target = IMIN(2*base_target, target); 1310 1311 return target; 1312 } 1313 1314 int celt_encode_with_ec(CELTEncoder * OPUS_RESTRICT st, const opus_val16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc) 1315 { 1316 int i, c, N; 1317 opus_int32 bits; 1318 ec_enc _enc; 1319 VARDECL(celt_sig, in); 1320 VARDECL(celt_sig, freq); 1321 VARDECL(celt_norm, X); 1322 VARDECL(celt_ener, bandE); 1323 VARDECL(opus_val16, bandLogE); 1324 VARDECL(opus_val16, bandLogE2); 1325 VARDECL(int, fine_quant); 1326 VARDECL(opus_val16, error); 1327 VARDECL(int, pulses); 1328 VARDECL(int, cap); 1329 VARDECL(int, offsets); 1330 VARDECL(int, fine_priority); 1331 VARDECL(int, tf_res); 1332 VARDECL(unsigned char, collapse_masks); 1333 celt_sig *prefilter_mem; 1334 opus_val16 *oldBandE, *oldLogE, *oldLogE2; 1335 int shortBlocks=0; 1336 int isTransient=0; 1337 const int CC = st->channels; 1338 const int C = st->stream_channels; 1339 int LM, M; 1340 int tf_select; 1341 int nbFilledBytes, nbAvailableBytes; 1342 int start; 1343 int end; 1344 int effEnd; 1345 int codedBands; 1346 int tf_sum; 1347 int alloc_trim; 1348 int pitch_index=COMBFILTER_MINPERIOD; 1349 opus_val16 gain1 = 0; 1350 int dual_stereo=0; 1351 int effectiveBytes; 1352 int dynalloc_logp; 1353 opus_int32 vbr_rate; 1354 opus_int32 total_bits; 1355 opus_int32 total_boost; 1356 opus_int32 balance; 1357 opus_int32 tell; 1358 int prefilter_tapset=0; 1359 int pf_on; 1360 int anti_collapse_rsv; 1361 int anti_collapse_on=0; 1362 int silence=0; 1363 int tf_chan = 0; 1364 opus_val16 tf_estimate; 1365 int pitch_change=0; 1366 opus_int32 tot_boost; 1367 opus_val32 sample_max; 1368 opus_val16 maxDepth; 1369 const OpusCustomMode *mode; 1370 int nbEBands; 1371 int overlap; 1372 const opus_int16 *eBands; 1373 int secondMdct; 1374 int signalBandwidth; 1375 int transient_got_disabled=0; 1376 opus_val16 surround_masking=0; 1377 opus_val16 temporal_vbr=0; 1378 opus_val16 surround_trim = 0; 1379 opus_int32 equiv_rate = 510000; 1380 VARDECL(opus_val16, surround_dynalloc); 1381 ALLOC_STACK; 1382 1383 mode = st->mode; 1384 nbEBands = mode->nbEBands; 1385 overlap = mode->overlap; 1386 eBands = mode->eBands; 1387 start = st->start; 1388 end = st->end; 1389 tf_estimate = 0; 1390 if (nbCompressedBytes<2 || pcm==NULL) 1391 { 1392 RESTORE_STACK; 1393 return OPUS_BAD_ARG; 1394 } 1395 1396 frame_size *= st->upsample; 1397 for (LM=0;LM<=mode->maxLM;LM++) 1398 if (mode->shortMdctSize<<LM==frame_size) 1399 break; 1400 if (LM>mode->maxLM) 1401 { 1402 RESTORE_STACK; 1403 return OPUS_BAD_ARG; 1404 } 1405 M=1<<LM; 1406 N = M*mode->shortMdctSize; 1407 1408 prefilter_mem = st->in_mem+CC*(overlap); 1409 oldBandE = (opus_val16*)(st->in_mem+CC*(overlap+COMBFILTER_MAXPERIOD)); 1410 oldLogE = oldBandE + CC*nbEBands; 1411 oldLogE2 = oldLogE + CC*nbEBands; 1412 1413 if (enc==NULL) 1414 { 1415 tell=1; 1416 nbFilledBytes=0; 1417 } else { 1418 tell=ec_tell(enc); 1419 nbFilledBytes=(tell+4)>>3; 1420 } 1421 1422 #ifdef CUSTOM_MODES 1423 if (st->signalling && enc==NULL) 1424 { 1425 int tmp = (mode->effEBands-end)>>1; 1426 end = st->end = IMAX(1, mode->effEBands-tmp); 1427 compressed[0] = tmp<<5; 1428 compressed[0] |= LM<<3; 1429 compressed[0] |= (C==2)<<2; 1430 /* Convert "standard mode" to Opus header */ 1431 if (mode->Fs==48000 && mode->shortMdctSize==120) 1432 { 1433 int c0 = toOpus(compressed[0]); 1434 if (c0<0) 1435 { 1436 RESTORE_STACK; 1437 return OPUS_BAD_ARG; 1438 } 1439 compressed[0] = c0; 1440 } 1441 compressed++; 1442 nbCompressedBytes--; 1443 } 1444 #else 1445 celt_assert(st->signalling==0); 1446 #endif 1447 1448 /* Can't produce more than 1275 output bytes */ 1449 nbCompressedBytes = IMIN(nbCompressedBytes,1275); 1450 nbAvailableBytes = nbCompressedBytes - nbFilledBytes; 1451 1452 if (st->vbr && st->bitrate!=OPUS_BITRATE_MAX) 1453 { 1454 opus_int32 den=mode->Fs>>BITRES; 1455 vbr_rate=(st->bitrate*frame_size+(den>>1))/den; 1456 #ifdef CUSTOM_MODES 1457 if (st->signalling) 1458 vbr_rate -= 8<<BITRES; 1459 #endif 1460 effectiveBytes = vbr_rate>>(3+BITRES); 1461 } else { 1462 opus_int32 tmp; 1463 vbr_rate = 0; 1464 tmp = st->bitrate*frame_size; 1465 if (tell>1) 1466 tmp += tell; 1467 if (st->bitrate!=OPUS_BITRATE_MAX) 1468 nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes, 1469 (tmp+4*mode->Fs)/(8*mode->Fs)-!!st->signalling)); 1470 effectiveBytes = nbCompressedBytes; 1471 } 1472 if (st->bitrate != OPUS_BITRATE_MAX) 1473 equiv_rate = st->bitrate - (40*C+20)*((400>>LM) - 50); 1474 1475 if (enc==NULL) 1476 { 1477 ec_enc_init(&_enc, compressed, nbCompressedBytes); 1478 enc = &_enc; 1479 } 1480 1481 if (vbr_rate>0) 1482 { 1483 /* Computes the max bit-rate allowed in VBR mode to avoid violating the 1484 target rate and buffering. 1485 We must do this up front so that bust-prevention logic triggers 1486 correctly if we don't have enough bits. */ 1487 if (st->constrained_vbr) 1488 { 1489 opus_int32 vbr_bound; 1490 opus_int32 max_allowed; 1491 /* We could use any multiple of vbr_rate as bound (depending on the 1492 delay). 1493 This is clamped to ensure we use at least two bytes if the encoder 1494 was entirely empty, but to allow 0 in hybrid mode. */ 1495 vbr_bound = vbr_rate; 1496 max_allowed = IMIN(IMAX(tell==1?2:0, 1497 (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)), 1498 nbAvailableBytes); 1499 if(max_allowed < nbAvailableBytes) 1500 { 1501 nbCompressedBytes = nbFilledBytes+max_allowed; 1502 nbAvailableBytes = max_allowed; 1503 ec_enc_shrink(enc, nbCompressedBytes); 1504 } 1505 } 1506 } 1507 total_bits = nbCompressedBytes*8; 1508 1509 effEnd = end; 1510 if (effEnd > mode->effEBands) 1511 effEnd = mode->effEBands; 1512 1513 ALLOC(in, CC*(N+overlap), celt_sig); 1514 1515 sample_max=MAX32(st->overlap_max, celt_maxabs16(pcm, C*(N-overlap)/st->upsample)); 1516 st->overlap_max=celt_maxabs16(pcm+C*(N-overlap)/st->upsample, C*overlap/st->upsample); 1517 sample_max=MAX32(sample_max, st->overlap_max); 1518 #ifdef FIXED_POINT 1519 silence = (sample_max==0); 1520 #else 1521 silence = (sample_max <= (opus_val16)1/(1<<st->lsb_depth)); 1522 #endif 1523 #ifdef FUZZING 1524 if ((rand()&0x3F)==0) 1525 silence = 1; 1526 #endif 1527 if (tell==1) 1528 ec_enc_bit_logp(enc, silence, 15); 1529 else 1530 silence=0; 1531 if (silence) 1532 { 1533 /*In VBR mode there is no need to send more than the minimum. */ 1534 if (vbr_rate>0) 1535 { 1536 effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2); 1537 total_bits=nbCompressedBytes*8; 1538 nbAvailableBytes=2; 1539 ec_enc_shrink(enc, nbCompressedBytes); 1540 } 1541 /* Pretend we've filled all the remaining bits with zeros 1542 (that's what the initialiser did anyway) */ 1543 tell = nbCompressedBytes*8; 1544 enc->nbits_total+=tell-ec_tell(enc); 1545 } 1546 c=0; do { 1547 int need_clip=0; 1548 #ifndef FIXED_POINT 1549 need_clip = st->clip && sample_max>65536.f; 1550 #endif 1551 celt_preemphasis(pcm+c, in+c*(N+overlap)+overlap, N, CC, st->upsample, 1552 mode->preemph, st->preemph_memE+c, need_clip); 1553 } while (++c<CC); 1554 1555 1556 1557 /* Find pitch period and gain */ 1558 { 1559 int enabled; 1560 int qg; 1561 enabled = ((st->lfe&&nbAvailableBytes>3) || nbAvailableBytes>12*C) && start==0 && !silence && !st->disable_pf 1562 && st->complexity >= 5 && !(st->consec_transient && LM!=3 && st->variable_duration==OPUS_FRAMESIZE_VARIABLE); 1563 1564 prefilter_tapset = st->tapset_decision; 1565 pf_on = run_prefilter(st, in, prefilter_mem, CC, N, prefilter_tapset, &pitch_index, &gain1, &qg, enabled, nbAvailableBytes); 1566 if ((gain1 > QCONST16(.4f,15) || st->prefilter_gain > QCONST16(.4f,15)) && (!st->analysis.valid || st->analysis.tonality > .3) 1567 && (pitch_index > 1.26*st->prefilter_period || pitch_index < .79*st->prefilter_period)) 1568 pitch_change = 1; 1569 if (pf_on==0) 1570 { 1571 if(start==0 && tell+16<=total_bits) 1572 ec_enc_bit_logp(enc, 0, 1); 1573 } else { 1574 /*This block is not gated by a total bits check only because 1575 of the nbAvailableBytes check above.*/ 1576 int octave; 1577 ec_enc_bit_logp(enc, 1, 1); 1578 pitch_index += 1; 1579 octave = EC_ILOG(pitch_index)-5; 1580 ec_enc_uint(enc, octave, 6); 1581 ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave); 1582 pitch_index -= 1; 1583 ec_enc_bits(enc, qg, 3); 1584 ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2); 1585 } 1586 } 1587 1588 isTransient = 0; 1589 shortBlocks = 0; 1590 if (st->complexity >= 1 && !st->lfe) 1591 { 1592 isTransient = transient_analysis(in, N+overlap, CC, 1593 &tf_estimate, &tf_chan); 1594 } 1595 if (LM>0 && ec_tell(enc)+3<=total_bits) 1596 { 1597 if (isTransient) 1598 shortBlocks = M; 1599 } else { 1600 isTransient = 0; 1601 transient_got_disabled=1; 1602 } 1603 1604 ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */ 1605 ALLOC(bandE,nbEBands*CC, celt_ener); 1606 ALLOC(bandLogE,nbEBands*CC, opus_val16); 1607 1608 secondMdct = shortBlocks && st->complexity>=8; 1609 ALLOC(bandLogE2, C*nbEBands, opus_val16); 1610 if (secondMdct) 1611 { 1612 compute_mdcts(mode, 0, in, freq, C, CC, LM, st->upsample, st->arch); 1613 compute_band_energies(mode, freq, bandE, effEnd, C, LM); 1614 amp2Log2(mode, effEnd, end, bandE, bandLogE2, C); 1615 for (i=0;i<C*nbEBands;i++) 1616 bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT)); 1617 } 1618 1619 compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch); 1620 if (CC==2&&C==1) 1621 tf_chan = 0; 1622 compute_band_energies(mode, freq, bandE, effEnd, C, LM); 1623 1624 if (st->lfe) 1625 { 1626 for (i=2;i<end;i++) 1627 { 1628 bandE[i] = IMIN(bandE[i], MULT16_32_Q15(QCONST16(1e-4f,15),bandE[0])); 1629 bandE[i] = MAX32(bandE[i], EPSILON); 1630 } 1631 } 1632 amp2Log2(mode, effEnd, end, bandE, bandLogE, C); 1633 1634 ALLOC(surround_dynalloc, C*nbEBands, opus_val16); 1635 OPUS_CLEAR(surround_dynalloc, end); 1636 /* This computes how much masking takes place between surround channels */ 1637 if (start==0&&st->energy_mask&&!st->lfe) 1638 { 1639 int mask_end; 1640 int midband; 1641 int count_dynalloc; 1642 opus_val32 mask_avg=0; 1643 opus_val32 diff=0; 1644 int count=0; 1645 mask_end = IMAX(2,st->lastCodedBands); 1646 for (c=0;c<C;c++) 1647 { 1648 for(i=0;i<mask_end;i++) 1649 { 1650 opus_val16 mask; 1651 mask = MAX16(MIN16(st->energy_mask[nbEBands*c+i], 1652 QCONST16(.25f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT)); 1653 if (mask > 0) 1654 mask = HALF16(mask); 1655 mask_avg += MULT16_16(mask, eBands[i+1]-eBands[i]); 1656 count += eBands[i+1]-eBands[i]; 1657 diff += MULT16_16(mask, 1+2*i-mask_end); 1658 } 1659 } 1660 celt_assert(count>0); 1661 mask_avg = DIV32_16(mask_avg,count); 1662 mask_avg += QCONST16(.2f, DB_SHIFT); 1663 diff = diff*6/(C*(mask_end-1)*(mask_end+1)*mask_end); 1664 /* Again, being conservative */ 1665 diff = HALF32(diff); 1666 diff = MAX32(MIN32(diff, QCONST32(.031f, DB_SHIFT)), -QCONST32(.031f, DB_SHIFT)); 1667 /* Find the band that's in the middle of the coded spectrum */ 1668 for (midband=0;eBands[midband+1] < eBands[mask_end]/2;midband++); 1669 count_dynalloc=0; 1670 for(i=0;i<mask_end;i++) 1671 { 1672 opus_val32 lin; 1673 opus_val16 unmask; 1674 lin = mask_avg + diff*(i-midband); 1675 if (C==2) 1676 unmask = MAX16(st->energy_mask[i], st->energy_mask[nbEBands+i]); 1677 else 1678 unmask = st->energy_mask[i]; 1679 unmask = MIN16(unmask, QCONST16(.0f, DB_SHIFT)); 1680 unmask -= lin; 1681 if (unmask > QCONST16(.25f, DB_SHIFT)) 1682 { 1683 surround_dynalloc[i] = unmask - QCONST16(.25f, DB_SHIFT); 1684 count_dynalloc++; 1685 } 1686 } 1687 if (count_dynalloc>=3) 1688 { 1689 /* If we need dynalloc in many bands, it's probably because our 1690 initial masking rate was too low. */ 1691 mask_avg += QCONST16(.25f, DB_SHIFT); 1692 if (mask_avg>0) 1693 { 1694 /* Something went really wrong in the original calculations, 1695 disabling masking. */ 1696 mask_avg = 0; 1697 diff = 0; 1698 OPUS_CLEAR(surround_dynalloc, mask_end); 1699 } else { 1700 for(i=0;i<mask_end;i++) 1701 surround_dynalloc[i] = MAX16(0, surround_dynalloc[i]-QCONST16(.25f, DB_SHIFT)); 1702 } 1703 } 1704 mask_avg += QCONST16(.2f, DB_SHIFT); 1705 /* Convert to 1/64th units used for the trim */ 1706 surround_trim = 64*diff; 1707 /*printf("%d %d ", mask_avg, surround_trim);*/ 1708 surround_masking = mask_avg; 1709 } 1710 /* Temporal VBR (but not for LFE) */ 1711 if (!st->lfe) 1712 { 1713 opus_val16 follow=-QCONST16(10.0f,DB_SHIFT); 1714 opus_val32 frame_avg=0; 1715 opus_val16 offset = shortBlocks?HALF16(SHL16(LM, DB_SHIFT)):0; 1716 for(i=start;i<end;i++) 1717 { 1718 follow = MAX16(follow-QCONST16(1.f, DB_SHIFT), bandLogE[i]-offset); 1719 if (C==2) 1720 follow = MAX16(follow, bandLogE[i+nbEBands]-offset); 1721 frame_avg += follow; 1722 } 1723 frame_avg /= (end-start); 1724 temporal_vbr = SUB16(frame_avg,st->spec_avg); 1725 temporal_vbr = MIN16(QCONST16(3.f, DB_SHIFT), MAX16(-QCONST16(1.5f, DB_SHIFT), temporal_vbr)); 1726 st->spec_avg += MULT16_16_Q15(QCONST16(.02f, 15), temporal_vbr); 1727 } 1728 /*for (i=0;i<21;i++) 1729 printf("%f ", bandLogE[i]); 1730 printf("\n");*/ 1731 1732 if (!secondMdct) 1733 { 1734 OPUS_COPY(bandLogE2, bandLogE, C*nbEBands); 1735 } 1736 1737 /* Last chance to catch any transient we might have missed in the 1738 time-domain analysis */ 1739 if (LM>0 && ec_tell(enc)+3<=total_bits && !isTransient && st->complexity>=5 && !st->lfe) 1740 { 1741 if (patch_transient_decision(bandLogE, oldBandE, nbEBands, start, end, C)) 1742 { 1743 isTransient = 1; 1744 shortBlocks = M; 1745 compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch); 1746 compute_band_energies(mode, freq, bandE, effEnd, C, LM); 1747 amp2Log2(mode, effEnd, end, bandE, bandLogE, C); 1748 /* Compensate for the scaling of short vs long mdcts */ 1749 for (i=0;i<C*nbEBands;i++) 1750 bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT)); 1751 tf_estimate = QCONST16(.2f,14); 1752 } 1753 } 1754 1755 if (LM>0 && ec_tell(enc)+3<=total_bits) 1756 ec_enc_bit_logp(enc, isTransient, 3); 1757 1758 ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */ 1759 1760 /* Band normalisation */ 1761 normalise_bands(mode, freq, X, bandE, effEnd, C, M); 1762 1763 ALLOC(tf_res, nbEBands, int); 1764 /* Disable variable tf resolution for hybrid and at very low bitrate */ 1765 if (effectiveBytes>=15*C && start==0 && st->complexity>=2 && !st->lfe) 1766 { 1767 int lambda; 1768 if (effectiveBytes<40) 1769 lambda = 12; 1770 else if (effectiveBytes<60) 1771 lambda = 6; 1772 else if (effectiveBytes<100) 1773 lambda = 4; 1774 else 1775 lambda = 3; 1776 lambda*=2; 1777 tf_select = tf_analysis(mode, effEnd, isTransient, tf_res, lambda, X, N, LM, &tf_sum, tf_estimate, tf_chan); 1778 for (i=effEnd;i<end;i++) 1779 tf_res[i] = tf_res[effEnd-1]; 1780 } else { 1781 tf_sum = 0; 1782 for (i=0;i<end;i++) 1783 tf_res[i] = isTransient; 1784 tf_select=0; 1785 } 1786 1787 ALLOC(error, C*nbEBands, opus_val16); 1788 quant_coarse_energy(mode, start, end, effEnd, bandLogE, 1789 oldBandE, total_bits, error, enc, 1790 C, LM, nbAvailableBytes, st->force_intra, 1791 &st->delayedIntra, st->complexity >= 4, st->loss_rate, st->lfe); 1792 1793 tf_encode(start, end, isTransient, tf_res, LM, tf_select, enc); 1794 1795 if (ec_tell(enc)+4<=total_bits) 1796 { 1797 if (st->lfe) 1798 { 1799 st->tapset_decision = 0; 1800 st->spread_decision = SPREAD_NORMAL; 1801 } else if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C || start != 0) 1802 { 1803 if (st->complexity == 0) 1804 st->spread_decision = SPREAD_NONE; 1805 else 1806 st->spread_decision = SPREAD_NORMAL; 1807 } else { 1808 /* Disable new spreading+tapset estimator until we can show it works 1809 better than the old one. So far it seems like spreading_decision() 1810 works best. */ 1811 #if 0 1812 if (st->analysis.valid) 1813 { 1814 static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15), -QCONST16(.2f, 15), -QCONST16(.07f, 15)}; 1815 static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15), QCONST16(.07f, 15), QCONST16(.02f, 15)}; 1816 static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15), QCONST16(.15f, 15)}; 1817 static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15), QCONST16(.05f, 15)}; 1818 st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision); 1819 st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision); 1820 } else 1821 #endif 1822 { 1823 st->spread_decision = spreading_decision(mode, X, 1824 &st->tonal_average, st->spread_decision, &st->hf_average, 1825 &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M); 1826 } 1827 /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/ 1828 /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/ 1829 } 1830 ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5); 1831 } 1832 1833 ALLOC(offsets, nbEBands, int); 1834 1835 maxDepth = dynalloc_analysis(bandLogE, bandLogE2, nbEBands, start, end, C, offsets, 1836 st->lsb_depth, mode->logN, isTransient, st->vbr, st->constrained_vbr, 1837 eBands, LM, effectiveBytes, &tot_boost, st->lfe, surround_dynalloc); 1838 /* For LFE, everything interesting is in the first band */ 1839 if (st->lfe) 1840 offsets[0] = IMIN(8, effectiveBytes/3); 1841 ALLOC(cap, nbEBands, int); 1842 init_caps(mode,cap,LM,C); 1843 1844 dynalloc_logp = 6; 1845 total_bits<<=BITRES; 1846 total_boost = 0; 1847 tell = ec_tell_frac(enc); 1848 for (i=start;i<end;i++) 1849 { 1850 int width, quanta; 1851 int dynalloc_loop_logp; 1852 int boost; 1853 int j; 1854 width = C*(eBands[i+1]-eBands[i])<<LM; 1855 /* quanta is 6 bits, but no more than 1 bit/sample 1856 and no less than 1/8 bit/sample */ 1857 quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width)); 1858 dynalloc_loop_logp = dynalloc_logp; 1859 boost = 0; 1860 for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost 1861 && boost < cap[i]; j++) 1862 { 1863 int flag; 1864 flag = j<offsets[i]; 1865 ec_enc_bit_logp(enc, flag, dynalloc_loop_logp); 1866 tell = ec_tell_frac(enc); 1867 if (!flag) 1868 break; 1869 boost += quanta; 1870 total_boost += quanta; 1871 dynalloc_loop_logp = 1; 1872 } 1873 /* Making dynalloc more likely */ 1874 if (j) 1875 dynalloc_logp = IMAX(2, dynalloc_logp-1); 1876 offsets[i] = boost; 1877 } 1878 1879 if (C==2) 1880 { 1881 static const opus_val16 intensity_thresholds[21]= 1882 /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 off*/ 1883 { 1, 2, 3, 4, 5, 6, 7, 8,16,24,36,44,50,56,62,67,72,79,88,106,134}; 1884 static const opus_val16 intensity_histeresis[21]= 1885 { 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 5, 6, 8, 8}; 1886 1887 /* Always use MS for 2.5 ms frames until we can do a better analysis */ 1888 if (LM!=0) 1889 dual_stereo = stereo_analysis(mode, X, LM, N); 1890 1891 st->intensity = hysteresis_decision((opus_val16)(equiv_rate/1000), 1892 intensity_thresholds, intensity_histeresis, 21, st->intensity); 1893 st->intensity = IMIN(end,IMAX(start, st->intensity)); 1894 } 1895 1896 alloc_trim = 5; 1897 if (tell+(6<<BITRES) <= total_bits - total_boost) 1898 { 1899 if (st->lfe) 1900 alloc_trim = 5; 1901 else 1902 alloc_trim = alloc_trim_analysis(mode, X, bandLogE, 1903 end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate, 1904 st->intensity, surround_trim, st->arch); 1905 ec_enc_icdf(enc, alloc_trim, trim_icdf, 7); 1906 tell = ec_tell_frac(enc); 1907 } 1908 1909 /* Variable bitrate */ 1910 if (vbr_rate>0) 1911 { 1912 opus_val16 alpha; 1913 opus_int32 delta; 1914 /* The target rate in 8th bits per frame */ 1915 opus_int32 target, base_target; 1916 opus_int32 min_allowed; 1917 int lm_diff = mode->maxLM - LM; 1918 1919 /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms. 1920 The CELT allocator will just not be able to use more than that anyway. */ 1921 nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM)); 1922 base_target = vbr_rate - ((40*C+20)<<BITRES); 1923 1924 if (st->constrained_vbr) 1925 base_target += (st->vbr_offset>>lm_diff); 1926 1927 target = compute_vbr(mode, &st->analysis, base_target, LM, equiv_rate, 1928 st->lastCodedBands, C, st->intensity, st->constrained_vbr, 1929 st->stereo_saving, tot_boost, tf_estimate, pitch_change, maxDepth, 1930 st->variable_duration, st->lfe, st->energy_mask!=NULL, surround_masking, 1931 temporal_vbr); 1932 1933 /* The current offset is removed from the target and the space used 1934 so far is added*/ 1935 target=target+tell; 1936 /* In VBR mode the frame size must not be reduced so much that it would 1937 result in the encoder running out of bits. 1938 The margin of 2 bytes ensures that none of the bust-prevention logic 1939 in the decoder will have triggered so far. */ 1940 min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2 - nbFilledBytes; 1941 1942 nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3); 1943 nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes); 1944 nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes; 1945 1946 /* By how much did we "miss" the target on that frame */ 1947 delta = target - vbr_rate; 1948 1949 target=nbAvailableBytes<<(BITRES+3); 1950 1951 /*If the frame is silent we don't adjust our drift, otherwise 1952 the encoder will shoot to very high rates after hitting a 1953 span of silence, but we do allow the bitres to refill. 1954 This means that we'll undershoot our target in CVBR/VBR modes 1955 on files with lots of silence. */ 1956 if(silence) 1957 { 1958 nbAvailableBytes = 2; 1959 target = 2*8<<BITRES; 1960 delta = 0; 1961 } 1962 1963 if (st->vbr_count < 970) 1964 { 1965 st->vbr_count++; 1966 alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16)); 1967 } else 1968 alpha = QCONST16(.001f,15); 1969 /* How many bits have we used in excess of what we're allowed */ 1970 if (st->constrained_vbr) 1971 st->vbr_reservoir += target - vbr_rate; 1972 /*printf ("%d\n", st->vbr_reservoir);*/ 1973 1974 /* Compute the offset we need to apply in order to reach the target */ 1975 if (st->constrained_vbr) 1976 { 1977 st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift); 1978 st->vbr_offset = -st->vbr_drift; 1979 } 1980 /*printf ("%d\n", st->vbr_drift);*/ 1981 1982 if (st->constrained_vbr && st->vbr_reservoir < 0) 1983 { 1984 /* We're under the min value -- increase rate */ 1985 int adjust = (-st->vbr_reservoir)/(8<<BITRES); 1986 /* Unless we're just coding silence */ 1987 nbAvailableBytes += silence?0:adjust; 1988 st->vbr_reservoir = 0; 1989 /*printf ("+%d\n", adjust);*/ 1990 } 1991 nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes); 1992 /*printf("%d\n", nbCompressedBytes*50*8);*/ 1993 /* This moves the raw bits to take into account the new compressed size */ 1994 ec_enc_shrink(enc, nbCompressedBytes); 1995 } 1996 1997 /* Bit allocation */ 1998 ALLOC(fine_quant, nbEBands, int); 1999 ALLOC(pulses, nbEBands, int); 2000 ALLOC(fine_priority, nbEBands, int); 2001 2002 /* bits = packet size - where we are - safety*/ 2003 bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1; 2004 anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0; 2005 bits -= anti_collapse_rsv; 2006 signalBandwidth = end-1; 2007 #ifndef DISABLE_FLOAT_API 2008 if (st->analysis.valid) 2009 { 2010 int min_bandwidth; 2011 if (equiv_rate < (opus_int32)32000*C) 2012 min_bandwidth = 13; 2013 else if (equiv_rate < (opus_int32)48000*C) 2014 min_bandwidth = 16; 2015 else if (equiv_rate < (opus_int32)60000*C) 2016 min_bandwidth = 18; 2017 else if (equiv_rate < (opus_int32)80000*C) 2018 min_bandwidth = 19; 2019 else 2020 min_bandwidth = 20; 2021 signalBandwidth = IMAX(st->analysis.bandwidth, min_bandwidth); 2022 } 2023 #endif 2024 if (st->lfe) 2025 signalBandwidth = 1; 2026 codedBands = compute_allocation(mode, start, end, offsets, cap, 2027 alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses, 2028 fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands, signalBandwidth); 2029 if (st->lastCodedBands) 2030 st->lastCodedBands = IMIN(st->lastCodedBands+1,IMAX(st->lastCodedBands-1,codedBands)); 2031 else 2032 st->lastCodedBands = codedBands; 2033 2034 quant_fine_energy(mode, start, end, oldBandE, error, fine_quant, enc, C); 2035 2036 /* Residual quantisation */ 2037 ALLOC(collapse_masks, C*nbEBands, unsigned char); 2038 quant_all_bands(1, mode, start, end, X, C==2 ? X+N : NULL, collapse_masks, 2039 bandE, pulses, shortBlocks, st->spread_decision, 2040 dual_stereo, st->intensity, tf_res, nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, 2041 balance, enc, LM, codedBands, &st->rng, st->arch); 2042 2043 if (anti_collapse_rsv > 0) 2044 { 2045 anti_collapse_on = st->consec_transient<2; 2046 #ifdef FUZZING 2047 anti_collapse_on = rand()&0x1; 2048 #endif 2049 ec_enc_bits(enc, anti_collapse_on, 1); 2050 } 2051 quant_energy_finalise(mode, start, end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C); 2052 2053 if (silence) 2054 { 2055 for (i=0;i<C*nbEBands;i++) 2056 oldBandE[i] = -QCONST16(28.f,DB_SHIFT); 2057 } 2058 2059 #ifdef RESYNTH 2060 /* Re-synthesis of the coded audio if required */ 2061 { 2062 celt_sig *out_mem[2]; 2063 2064 if (anti_collapse_on) 2065 { 2066 anti_collapse(mode, X, collapse_masks, LM, C, N, 2067 start, end, oldBandE, oldLogE, oldLogE2, pulses, st->rng); 2068 } 2069 2070 c=0; do { 2071 OPUS_MOVE(st->syn_mem[c], st->syn_mem[c]+N, 2*MAX_PERIOD-N+overlap/2); 2072 } while (++c<CC); 2073 2074 c=0; do { 2075 out_mem[c] = st->syn_mem[c]+2*MAX_PERIOD-N; 2076 } while (++c<CC); 2077 2078 celt_synthesis(mode, X, out_mem, oldBandE, start, effEnd, 2079 C, CC, isTransient, LM, st->upsample, silence, st->arch); 2080 2081 c=0; do { 2082 st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD); 2083 st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD); 2084 comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, mode->shortMdctSize, 2085 st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset, 2086 mode->window, overlap); 2087 if (LM!=0) 2088 comb_filter(out_mem[c]+mode->shortMdctSize, out_mem[c]+mode->shortMdctSize, st->prefilter_period, pitch_index, N-mode->shortMdctSize, 2089 st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset, 2090 mode->window, overlap); 2091 } while (++c<CC); 2092 2093 /* We reuse freq[] as scratch space for the de-emphasis */ 2094 deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, mode->preemph, st->preemph_memD); 2095 st->prefilter_period_old = st->prefilter_period; 2096 st->prefilter_gain_old = st->prefilter_gain; 2097 st->prefilter_tapset_old = st->prefilter_tapset; 2098 } 2099 #endif 2100 2101 st->prefilter_period = pitch_index; 2102 st->prefilter_gain = gain1; 2103 st->prefilter_tapset = prefilter_tapset; 2104 #ifdef RESYNTH 2105 if (LM!=0) 2106 { 2107 st->prefilter_period_old = st->prefilter_period; 2108 st->prefilter_gain_old = st->prefilter_gain; 2109 st->prefilter_tapset_old = st->prefilter_tapset; 2110 } 2111 #endif 2112 2113 if (CC==2&&C==1) { 2114 OPUS_COPY(&oldBandE[nbEBands], oldBandE, nbEBands); 2115 } 2116 2117 if (!isTransient) 2118 { 2119 OPUS_COPY(oldLogE2, oldLogE, CC*nbEBands); 2120 OPUS_COPY(oldLogE, oldBandE, CC*nbEBands); 2121 } else { 2122 for (i=0;i<CC*nbEBands;i++) 2123 oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]); 2124 } 2125 /* In case start or end were to change */ 2126 c=0; do 2127 { 2128 for (i=0;i<start;i++) 2129 { 2130 oldBandE[c*nbEBands+i]=0; 2131 oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT); 2132 } 2133 for (i=end;i<nbEBands;i++) 2134 { 2135 oldBandE[c*nbEBands+i]=0; 2136 oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT); 2137 } 2138 } while (++c<CC); 2139 2140 if (isTransient || transient_got_disabled) 2141 st->consec_transient++; 2142 else 2143 st->consec_transient=0; 2144 st->rng = enc->rng; 2145 2146 /* If there's any room left (can only happen for very high rates), 2147 it's already filled with zeros */ 2148 ec_enc_done(enc); 2149 2150 #ifdef CUSTOM_MODES 2151 if (st->signalling) 2152 nbCompressedBytes++; 2153 #endif 2154 2155 RESTORE_STACK; 2156 if (ec_get_error(enc)) 2157 return OPUS_INTERNAL_ERROR; 2158 else 2159 return nbCompressedBytes; 2160 } 2161 2162 2163 #ifdef CUSTOM_MODES 2164 2165 #ifdef FIXED_POINT 2166 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) 2167 { 2168 return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL); 2169 } 2170 2171 #ifndef DISABLE_FLOAT_API 2172 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) 2173 { 2174 int j, ret, C, N; 2175 VARDECL(opus_int16, in); 2176 ALLOC_STACK; 2177 2178 if (pcm==NULL) 2179 return OPUS_BAD_ARG; 2180 2181 C = st->channels; 2182 N = frame_size; 2183 ALLOC(in, C*N, opus_int16); 2184 2185 for (j=0;j<C*N;j++) 2186 in[j] = FLOAT2INT16(pcm[j]); 2187 2188 ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL); 2189 #ifdef RESYNTH 2190 for (j=0;j<C*N;j++) 2191 ((float*)pcm)[j]=in[j]*(1.f/32768.f); 2192 #endif 2193 RESTORE_STACK; 2194 return ret; 2195 } 2196 #endif /* DISABLE_FLOAT_API */ 2197 #else 2198 2199 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) 2200 { 2201 int j, ret, C, N; 2202 VARDECL(celt_sig, in); 2203 ALLOC_STACK; 2204 2205 if (pcm==NULL) 2206 return OPUS_BAD_ARG; 2207 2208 C=st->channels; 2209 N=frame_size; 2210 ALLOC(in, C*N, celt_sig); 2211 for (j=0;j<C*N;j++) { 2212 in[j] = SCALEOUT(pcm[j]); 2213 } 2214 2215 ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL); 2216 #ifdef RESYNTH 2217 for (j=0;j<C*N;j++) 2218 ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]); 2219 #endif 2220 RESTORE_STACK; 2221 return ret; 2222 } 2223 2224 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) 2225 { 2226 return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL); 2227 } 2228 2229 #endif 2230 2231 #endif /* CUSTOM_MODES */ 2232 2233 int opus_custom_encoder_ctl(CELTEncoder * OPUS_RESTRICT st, int request, ...) 2234 { 2235 va_list ap; 2236 2237 va_start(ap, request); 2238 switch (request) 2239 { 2240 case OPUS_SET_COMPLEXITY_REQUEST: 2241 { 2242 int value = va_arg(ap, opus_int32); 2243 if (value<0 || value>10) 2244 goto bad_arg; 2245 st->complexity = value; 2246 } 2247 break; 2248 case CELT_SET_START_BAND_REQUEST: 2249 { 2250 opus_int32 value = va_arg(ap, opus_int32); 2251 if (value<0 || value>=st->mode->nbEBands) 2252 goto bad_arg; 2253 st->start = value; 2254 } 2255 break; 2256 case CELT_SET_END_BAND_REQUEST: 2257 { 2258 opus_int32 value = va_arg(ap, opus_int32); 2259 if (value<1 || value>st->mode->nbEBands) 2260 goto bad_arg; 2261 st->end = value; 2262 } 2263 break; 2264 case CELT_SET_PREDICTION_REQUEST: 2265 { 2266 int value = va_arg(ap, opus_int32); 2267 if (value<0 || value>2) 2268 goto bad_arg; 2269 st->disable_pf = value<=1; 2270 st->force_intra = value==0; 2271 } 2272 break; 2273 case OPUS_SET_PACKET_LOSS_PERC_REQUEST: 2274 { 2275 int value = va_arg(ap, opus_int32); 2276 if (value<0 || value>100) 2277 goto bad_arg; 2278 st->loss_rate = value; 2279 } 2280 break; 2281 case OPUS_SET_VBR_CONSTRAINT_REQUEST: 2282 { 2283 opus_int32 value = va_arg(ap, opus_int32); 2284 st->constrained_vbr = value; 2285 } 2286 break; 2287 case OPUS_SET_VBR_REQUEST: 2288 { 2289 opus_int32 value = va_arg(ap, opus_int32); 2290 st->vbr = value; 2291 } 2292 break; 2293 case OPUS_SET_BITRATE_REQUEST: 2294 { 2295 opus_int32 value = va_arg(ap, opus_int32); 2296 if (value<=500 && value!=OPUS_BITRATE_MAX) 2297 goto bad_arg; 2298 value = IMIN(value, 260000*st->channels); 2299 st->bitrate = value; 2300 } 2301 break; 2302 case CELT_SET_CHANNELS_REQUEST: 2303 { 2304 opus_int32 value = va_arg(ap, opus_int32); 2305 if (value<1 || value>2) 2306 goto bad_arg; 2307 st->stream_channels = value; 2308 } 2309 break; 2310 case OPUS_SET_LSB_DEPTH_REQUEST: 2311 { 2312 opus_int32 value = va_arg(ap, opus_int32); 2313 if (value<8 || value>24) 2314 goto bad_arg; 2315 st->lsb_depth=value; 2316 } 2317 break; 2318 case OPUS_GET_LSB_DEPTH_REQUEST: 2319 { 2320 opus_int32 *value = va_arg(ap, opus_int32*); 2321 *value=st->lsb_depth; 2322 } 2323 break; 2324 case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST: 2325 { 2326 opus_int32 value = va_arg(ap, opus_int32); 2327 st->variable_duration = value; 2328 } 2329 break; 2330 case OPUS_RESET_STATE: 2331 { 2332 int i; 2333 opus_val16 *oldBandE, *oldLogE, *oldLogE2; 2334 oldBandE = (opus_val16*)(st->in_mem+st->channels*(st->mode->overlap+COMBFILTER_MAXPERIOD)); 2335 oldLogE = oldBandE + st->channels*st->mode->nbEBands; 2336 oldLogE2 = oldLogE + st->channels*st->mode->nbEBands; 2337 OPUS_CLEAR((char*)&st->ENCODER_RESET_START, 2338 opus_custom_encoder_get_size(st->mode, st->channels)- 2339 ((char*)&st->ENCODER_RESET_START - (char*)st)); 2340 for (i=0;i<st->channels*st->mode->nbEBands;i++) 2341 oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT); 2342 st->vbr_offset = 0; 2343 st->delayedIntra = 1; 2344 st->spread_decision = SPREAD_NORMAL; 2345 st->tonal_average = 256; 2346 st->hf_average = 0; 2347 st->tapset_decision = 0; 2348 } 2349 break; 2350 #ifdef CUSTOM_MODES 2351 case CELT_SET_INPUT_CLIPPING_REQUEST: 2352 { 2353 opus_int32 value = va_arg(ap, opus_int32); 2354 st->clip = value; 2355 } 2356 break; 2357 #endif 2358 case CELT_SET_SIGNALLING_REQUEST: 2359 { 2360 opus_int32 value = va_arg(ap, opus_int32); 2361 st->signalling = value; 2362 } 2363 break; 2364 case CELT_SET_ANALYSIS_REQUEST: 2365 { 2366 AnalysisInfo *info = va_arg(ap, AnalysisInfo *); 2367 if (info) 2368 OPUS_COPY(&st->analysis, info, 1); 2369 } 2370 break; 2371 case CELT_GET_MODE_REQUEST: 2372 { 2373 const CELTMode ** value = va_arg(ap, const CELTMode**); 2374 if (value==0) 2375 goto bad_arg; 2376 *value=st->mode; 2377 } 2378 break; 2379 case OPUS_GET_FINAL_RANGE_REQUEST: 2380 { 2381 opus_uint32 * value = va_arg(ap, opus_uint32 *); 2382 if (value==0) 2383 goto bad_arg; 2384 *value=st->rng; 2385 } 2386 break; 2387 case OPUS_SET_LFE_REQUEST: 2388 { 2389 opus_int32 value = va_arg(ap, opus_int32); 2390 st->lfe = value; 2391 } 2392 break; 2393 case OPUS_SET_ENERGY_MASK_REQUEST: 2394 { 2395 opus_val16 *value = va_arg(ap, opus_val16*); 2396 st->energy_mask = value; 2397 } 2398 break; 2399 default: 2400 goto bad_request; 2401 } 2402 va_end(ap); 2403 return OPUS_OK; 2404 bad_arg: 2405 va_end(ap); 2406 return OPUS_BAD_ARG; 2407 bad_request: 2408 va_end(ap); 2409 return OPUS_UNIMPLEMENTED; 2410 } 2411
