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