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