diff options
Diffstat (limited to 'lib/rbcodec/codecs/libopus/celt/celt_encoder.c')
-rw-r--r-- | lib/rbcodec/codecs/libopus/celt/celt_encoder.c | 2607 |
1 files changed, 2607 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libopus/celt/celt_encoder.c b/lib/rbcodec/codecs/libopus/celt/celt_encoder.c new file mode 100644 index 0000000000..44cb0850ab --- /dev/null +++ b/lib/rbcodec/codecs/libopus/celt/celt_encoder.c | |||
@@ -0,0 +1,2607 @@ | |||
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 | 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 | |||
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 | ||
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 | 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 | ||
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 | 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 | ||
220 | void opus_custom_encoder_destroy(CELTEncoder *st) | ||
221 | { | ||
222 | opus_free(st); | ||
223 | } | ||
224 | #endif /* CUSTOM_MODES */ | ||
225 | |||
226 | |||
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 */ | ||
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 */ | ||
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 | |||
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 | |||
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 | |||
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 | |||
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 | |||
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 | |||
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) | ||
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 | |||
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 | |||
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 | |||
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 | |||
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 | |||
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 (i=0;i<C*nbEBands;i++) | ||
1723 | bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT)); | ||
1724 | } | ||
1725 | |||
1726 | compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch); | ||
1727 | /* This should catch any NaN in the CELT input. Since we're not supposed to see any (they're filtered | ||
1728 | at the Opus layer), just abort. */ | ||
1729 | celt_assert(!celt_isnan(freq[0]) && (C==1 || !celt_isnan(freq[N]))); | ||
1730 | if (CC==2&&C==1) | ||
1731 | tf_chan = 0; | ||
1732 | compute_band_energies(mode, freq, bandE, effEnd, C, LM, st->arch); | ||
1733 | |||
1734 | if (st->lfe) | ||
1735 | { | ||
1736 | for (i=2;i<end;i++) | ||
1737 | { | ||
1738 | bandE[i] = IMIN(bandE[i], MULT16_32_Q15(QCONST16(1e-4f,15),bandE[0])); | ||
1739 | bandE[i] = MAX32(bandE[i], EPSILON); | ||
1740 | } | ||
1741 | } | ||
1742 | amp2Log2(mode, effEnd, end, bandE, bandLogE, C); | ||
1743 | |||
1744 | ALLOC(surround_dynalloc, C*nbEBands, opus_val16); | ||
1745 | OPUS_CLEAR(surround_dynalloc, end); | ||
1746 | /* This computes how much masking takes place between surround channels */ | ||
1747 | if (!hybrid&&st->energy_mask&&!st->lfe) | ||
1748 | { | ||
1749 | int mask_end; | ||
1750 | int midband; | ||
1751 | int count_dynalloc; | ||
1752 | opus_val32 mask_avg=0; | ||
1753 | opus_val32 diff=0; | ||
1754 | int count=0; | ||
1755 | mask_end = IMAX(2,st->lastCodedBands); | ||
1756 | for (c=0;c<C;c++) | ||
1757 | { | ||
1758 | for(i=0;i<mask_end;i++) | ||
1759 | { | ||
1760 | opus_val16 mask; | ||
1761 | mask = MAX16(MIN16(st->energy_mask[nbEBands*c+i], | ||
1762 | QCONST16(.25f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT)); | ||
1763 | if (mask > 0) | ||
1764 | mask = HALF16(mask); | ||
1765 | mask_avg += MULT16_16(mask, eBands[i+1]-eBands[i]); | ||
1766 | count += eBands[i+1]-eBands[i]; | ||
1767 | diff += MULT16_16(mask, 1+2*i-mask_end); | ||
1768 | } | ||
1769 | } | ||
1770 | celt_assert(count>0); | ||
1771 | mask_avg = DIV32_16(mask_avg,count); | ||
1772 | mask_avg += QCONST16(.2f, DB_SHIFT); | ||
1773 | diff = diff*6/(C*(mask_end-1)*(mask_end+1)*mask_end); | ||
1774 | /* Again, being conservative */ | ||
1775 | diff = HALF32(diff); | ||
1776 | diff = MAX32(MIN32(diff, QCONST32(.031f, DB_SHIFT)), -QCONST32(.031f, DB_SHIFT)); | ||
1777 | /* Find the band that's in the middle of the coded spectrum */ | ||
1778 | for (midband=0;eBands[midband+1] < eBands[mask_end]/2;midband++); | ||
1779 | count_dynalloc=0; | ||
1780 | for(i=0;i<mask_end;i++) | ||
1781 | { | ||
1782 | opus_val32 lin; | ||
1783 | opus_val16 unmask; | ||
1784 | lin = mask_avg + diff*(i-midband); | ||
1785 | if (C==2) | ||
1786 | unmask = MAX16(st->energy_mask[i], st->energy_mask[nbEBands+i]); | ||
1787 | else | ||
1788 | unmask = st->energy_mask[i]; | ||
1789 | unmask = MIN16(unmask, QCONST16(.0f, DB_SHIFT)); | ||
1790 | unmask -= lin; | ||
1791 | if (unmask > QCONST16(.25f, DB_SHIFT)) | ||
1792 | { | ||
1793 | surround_dynalloc[i] = unmask - QCONST16(.25f, DB_SHIFT); | ||
1794 | count_dynalloc++; | ||
1795 | } | ||
1796 | } | ||
1797 | if (count_dynalloc>=3) | ||
1798 | { | ||
1799 | /* If we need dynalloc in many bands, it's probably because our | ||
1800 | initial masking rate was too low. */ | ||
1801 | mask_avg += QCONST16(.25f, DB_SHIFT); | ||
1802 | if (mask_avg>0) | ||
1803 | { | ||
1804 | /* Something went really wrong in the original calculations, | ||
1805 | disabling masking. */ | ||
1806 | mask_avg = 0; | ||
1807 | diff = 0; | ||
1808 | OPUS_CLEAR(surround_dynalloc, mask_end); | ||
1809 | } else { | ||
1810 | for(i=0;i<mask_end;i++) | ||
1811 | surround_dynalloc[i] = MAX16(0, surround_dynalloc[i]-QCONST16(.25f, DB_SHIFT)); | ||
1812 | } | ||
1813 | } | ||
1814 | mask_avg += QCONST16(.2f, DB_SHIFT); | ||
1815 | /* Convert to 1/64th units used for the trim */ | ||
1816 | surround_trim = 64*diff; | ||
1817 | /*printf("%d %d ", mask_avg, surround_trim);*/ | ||
1818 | surround_masking = mask_avg; | ||
1819 | } | ||
1820 | /* Temporal VBR (but not for LFE) */ | ||
1821 | if (!st->lfe) | ||
1822 | { | ||
1823 | opus_val16 follow=-QCONST16(10.0f,DB_SHIFT); | ||
1824 | opus_val32 frame_avg=0; | ||
1825 | opus_val16 offset = shortBlocks?HALF16(SHL16(LM, DB_SHIFT)):0; | ||
1826 | for(i=start;i<end;i++) | ||
1827 | { | ||
1828 | follow = MAX16(follow-QCONST16(1.f, DB_SHIFT), bandLogE[i]-offset); | ||
1829 | if (C==2) | ||
1830 | follow = MAX16(follow, bandLogE[i+nbEBands]-offset); | ||
1831 | frame_avg += follow; | ||
1832 | } | ||
1833 | frame_avg /= (end-start); | ||
1834 | temporal_vbr = SUB16(frame_avg,st->spec_avg); | ||
1835 | temporal_vbr = MIN16(QCONST16(3.f, DB_SHIFT), MAX16(-QCONST16(1.5f, DB_SHIFT), temporal_vbr)); | ||
1836 | st->spec_avg += MULT16_16_Q15(QCONST16(.02f, 15), temporal_vbr); | ||
1837 | } | ||
1838 | /*for (i=0;i<21;i++) | ||
1839 | printf("%f ", bandLogE[i]); | ||
1840 | printf("\n");*/ | ||
1841 | |||
1842 | if (!secondMdct) | ||
1843 | { | ||
1844 | OPUS_COPY(bandLogE2, bandLogE, C*nbEBands); | ||
1845 | } | ||
1846 | |||
1847 | /* Last chance to catch any transient we might have missed in the | ||
1848 | time-domain analysis */ | ||
1849 | if (LM>0 && ec_tell(enc)+3<=total_bits && !isTransient && st->complexity>=5 && !st->lfe && !hybrid) | ||
1850 | { | ||
1851 | if (patch_transient_decision(bandLogE, oldBandE, nbEBands, start, end, C)) | ||
1852 | { | ||
1853 | isTransient = 1; | ||
1854 | shortBlocks = M; | ||
1855 | compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch); | ||
1856 | compute_band_energies(mode, freq, bandE, effEnd, C, LM, st->arch); | ||
1857 | amp2Log2(mode, effEnd, end, bandE, bandLogE, C); | ||
1858 | /* Compensate for the scaling of short vs long mdcts */ | ||
1859 | for (i=0;i<C*nbEBands;i++) | ||
1860 | bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT)); | ||
1861 | tf_estimate = QCONST16(.2f,14); | ||
1862 | } | ||
1863 | } | ||
1864 | |||
1865 | if (LM>0 && ec_tell(enc)+3<=total_bits) | ||
1866 | ec_enc_bit_logp(enc, isTransient, 3); | ||
1867 | |||
1868 | ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */ | ||
1869 | |||
1870 | /* Band normalisation */ | ||
1871 | normalise_bands(mode, freq, X, bandE, effEnd, C, M); | ||
1872 | |||
1873 | enable_tf_analysis = effectiveBytes>=15*C && !hybrid && st->complexity>=2 && !st->lfe; | ||
1874 | |||
1875 | ALLOC(offsets, nbEBands, int); | ||
1876 | ALLOC(importance, nbEBands, int); | ||
1877 | ALLOC(spread_weight, nbEBands, int); | ||
1878 | |||
1879 | maxDepth = dynalloc_analysis(bandLogE, bandLogE2, nbEBands, start, end, C, offsets, | ||
1880 | st->lsb_depth, mode->logN, isTransient, st->vbr, st->constrained_vbr, | ||
1881 | eBands, LM, effectiveBytes, &tot_boost, st->lfe, surround_dynalloc, &st->analysis, importance, spread_weight); | ||
1882 | |||
1883 | ALLOC(tf_res, nbEBands, int); | ||
1884 | /* Disable variable tf resolution for hybrid and at very low bitrate */ | ||
1885 | if (enable_tf_analysis) | ||
1886 | { | ||
1887 | int lambda; | ||
1888 | lambda = IMAX(80, 20480/effectiveBytes + 2); | ||
1889 | tf_select = tf_analysis(mode, effEnd, isTransient, tf_res, lambda, X, N, LM, tf_estimate, tf_chan, importance); | ||
1890 | for (i=effEnd;i<end;i++) | ||
1891 | tf_res[i] = tf_res[effEnd-1]; | ||
1892 | } else if (hybrid && weak_transient) | ||
1893 | { | ||
1894 | /* For weak transients, we rely on the fact that improving time resolution using | ||
1895 | TF on a long window is imperfect and will not result in an energy collapse at | ||
1896 | low bitrate. */ | ||
1897 | for (i=0;i<end;i++) | ||
1898 | tf_res[i] = 1; | ||
1899 | tf_select=0; | ||
1900 | } else if (hybrid && effectiveBytes<15 && st->silk_info.signalType != 2) | ||
1901 | { | ||
1902 | /* For low bitrate hybrid, we force temporal resolution to 5 ms rather than 2.5 ms. */ | ||
1903 | for (i=0;i<end;i++) | ||
1904 | tf_res[i] = 0; | ||
1905 | tf_select=isTransient; | ||
1906 | } else { | ||
1907 | for (i=0;i<end;i++) | ||
1908 | tf_res[i] = isTransient; | ||
1909 | tf_select=0; | ||
1910 | } | ||
1911 | |||
1912 | ALLOC(error, C*nbEBands, opus_val16); | ||
1913 | c=0; | ||
1914 | do { | ||
1915 | for (i=start;i<end;i++) | ||
1916 | { | ||
1917 | /* When the energy is stable, slightly bias energy quantization towards | ||
1918 | the previous error to make the gain more stable (a constant offset is | ||
1919 | better than fluctuations). */ | ||
1920 | if (ABS32(SUB32(bandLogE[i+c*nbEBands], oldBandE[i+c*nbEBands])) < QCONST16(2.f, DB_SHIFT)) | ||
1921 | { | ||
1922 | bandLogE[i+c*nbEBands] -= MULT16_16_Q15(energyError[i+c*nbEBands], QCONST16(0.25f, 15)); | ||
1923 | } | ||
1924 | } | ||
1925 | } while (++c < C); | ||
1926 | quant_coarse_energy(mode, start, end, effEnd, bandLogE, | ||
1927 | oldBandE, total_bits, error, enc, | ||
1928 | C, LM, nbAvailableBytes, st->force_intra, | ||
1929 | &st->delayedIntra, st->complexity >= 4, st->loss_rate, st->lfe); | ||
1930 | |||
1931 | tf_encode(start, end, isTransient, tf_res, LM, tf_select, enc); | ||
1932 | |||
1933 | if (ec_tell(enc)+4<=total_bits) | ||
1934 | { | ||
1935 | if (st->lfe) | ||
1936 | { | ||
1937 | st->tapset_decision = 0; | ||
1938 | st->spread_decision = SPREAD_NORMAL; | ||
1939 | } else if (hybrid) | ||
1940 | { | ||
1941 | if (st->complexity == 0) | ||
1942 | st->spread_decision = SPREAD_NONE; | ||
1943 | else if (isTransient) | ||
1944 | st->spread_decision = SPREAD_NORMAL; | ||
1945 | else | ||
1946 | st->spread_decision = SPREAD_AGGRESSIVE; | ||
1947 | } else if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C) | ||
1948 | { | ||
1949 | if (st->complexity == 0) | ||
1950 | st->spread_decision = SPREAD_NONE; | ||
1951 | else | ||
1952 | st->spread_decision = SPREAD_NORMAL; | ||
1953 | } else { | ||
1954 | /* Disable new spreading+tapset estimator until we can show it works | ||
1955 | better than the old one. So far it seems like spreading_decision() | ||
1956 | works best. */ | ||
1957 | #if 0 | ||
1958 | if (st->analysis.valid) | ||
1959 | { | ||
1960 | static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15), -QCONST16(.2f, 15), -QCONST16(.07f, 15)}; | ||
1961 | static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15), QCONST16(.07f, 15), QCONST16(.02f, 15)}; | ||
1962 | static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15), QCONST16(.15f, 15)}; | ||
1963 | static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15), QCONST16(.05f, 15)}; | ||
1964 | st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision); | ||
1965 | st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision); | ||
1966 | } else | ||
1967 | #endif | ||
1968 | { | ||
1969 | st->spread_decision = spreading_decision(mode, X, | ||
1970 | &st->tonal_average, st->spread_decision, &st->hf_average, | ||
1971 | &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M, spread_weight); | ||
1972 | } | ||
1973 | /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/ | ||
1974 | /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/ | ||
1975 | } | ||
1976 | ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5); | ||
1977 | } | ||
1978 | |||
1979 | /* For LFE, everything interesting is in the first band */ | ||
1980 | if (st->lfe) | ||
1981 | offsets[0] = IMIN(8, effectiveBytes/3); | ||
1982 | ALLOC(cap, nbEBands, int); | ||
1983 | init_caps(mode,cap,LM,C); | ||
1984 | |||
1985 | dynalloc_logp = 6; | ||
1986 | total_bits<<=BITRES; | ||
1987 | total_boost = 0; | ||
1988 | tell = ec_tell_frac(enc); | ||
1989 | for (i=start;i<end;i++) | ||
1990 | { | ||
1991 | int width, quanta; | ||
1992 | int dynalloc_loop_logp; | ||
1993 | int boost; | ||
1994 | int j; | ||
1995 | width = C*(eBands[i+1]-eBands[i])<<LM; | ||
1996 | /* quanta is 6 bits, but no more than 1 bit/sample | ||
1997 | and no less than 1/8 bit/sample */ | ||
1998 | quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width)); | ||
1999 | dynalloc_loop_logp = dynalloc_logp; | ||
2000 | boost = 0; | ||
2001 | for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost | ||
2002 | && boost < cap[i]; j++) | ||
2003 | { | ||
2004 | int flag; | ||
2005 | flag = j<offsets[i]; | ||
2006 | ec_enc_bit_logp(enc, flag, dynalloc_loop_logp); | ||
2007 | tell = ec_tell_frac(enc); | ||
2008 | if (!flag) | ||
2009 | break; | ||
2010 | boost += quanta; | ||
2011 | total_boost += quanta; | ||
2012 | dynalloc_loop_logp = 1; | ||
2013 | } | ||
2014 | /* Making dynalloc more likely */ | ||
2015 | if (j) | ||
2016 | dynalloc_logp = IMAX(2, dynalloc_logp-1); | ||
2017 | offsets[i] = boost; | ||
2018 | } | ||
2019 | |||
2020 | if (C==2) | ||
2021 | { | ||
2022 | static const opus_val16 intensity_thresholds[21]= | ||
2023 | /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 off*/ | ||
2024 | { 1, 2, 3, 4, 5, 6, 7, 8,16,24,36,44,50,56,62,67,72,79,88,106,134}; | ||
2025 | static const opus_val16 intensity_histeresis[21]= | ||
2026 | { 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 5, 6, 8, 8}; | ||
2027 | |||
2028 | /* Always use MS for 2.5 ms frames until we can do a better analysis */ | ||
2029 | if (LM!=0) | ||
2030 | dual_stereo = stereo_analysis(mode, X, LM, N); | ||
2031 | |||
2032 | st->intensity = hysteresis_decision((opus_val16)(equiv_rate/1000), | ||
2033 | intensity_thresholds, intensity_histeresis, 21, st->intensity); | ||
2034 | st->intensity = IMIN(end,IMAX(start, st->intensity)); | ||
2035 | } | ||
2036 | |||
2037 | alloc_trim = 5; | ||
2038 | if (tell+(6<<BITRES) <= total_bits - total_boost) | ||
2039 | { | ||
2040 | if (start > 0 || st->lfe) | ||
2041 | { | ||
2042 | st->stereo_saving = 0; | ||
2043 | alloc_trim = 5; | ||
2044 | } else { | ||
2045 | alloc_trim = alloc_trim_analysis(mode, X, bandLogE, | ||
2046 | end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate, | ||
2047 | st->intensity, surround_trim, equiv_rate, st->arch); | ||
2048 | } | ||
2049 | ec_enc_icdf(enc, alloc_trim, trim_icdf, 7); | ||
2050 | tell = ec_tell_frac(enc); | ||
2051 | } | ||
2052 | |||
2053 | /* Variable bitrate */ | ||
2054 | if (vbr_rate>0) | ||
2055 | { | ||
2056 | opus_val16 alpha; | ||
2057 | opus_int32 delta; | ||
2058 | /* The target rate in 8th bits per frame */ | ||
2059 | opus_int32 target, base_target; | ||
2060 | opus_int32 min_allowed; | ||
2061 | int lm_diff = mode->maxLM - LM; | ||
2062 | |||
2063 | /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms. | ||
2064 | The CELT allocator will just not be able to use more than that anyway. */ | ||
2065 | nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM)); | ||
2066 | if (!hybrid) | ||
2067 | { | ||
2068 | base_target = vbr_rate - ((40*C+20)<<BITRES); | ||
2069 | } else { | ||
2070 | base_target = IMAX(0, vbr_rate - ((9*C+4)<<BITRES)); | ||
2071 | } | ||
2072 | |||
2073 | if (st->constrained_vbr) | ||
2074 | base_target += (st->vbr_offset>>lm_diff); | ||
2075 | |||
2076 | if (!hybrid) | ||
2077 | { | ||
2078 | target = compute_vbr(mode, &st->analysis, base_target, LM, equiv_rate, | ||
2079 | st->lastCodedBands, C, st->intensity, st->constrained_vbr, | ||
2080 | st->stereo_saving, tot_boost, tf_estimate, pitch_change, maxDepth, | ||
2081 | st->lfe, st->energy_mask!=NULL, surround_masking, | ||
2082 | temporal_vbr); | ||
2083 | } else { | ||
2084 | target = base_target; | ||
2085 | /* Tonal frames (offset<100) need more bits than noisy (offset>100) ones. */ | ||
2086 | if (st->silk_info.offset < 100) target += 12 << BITRES >> (3-LM); | ||
2087 | if (st->silk_info.offset > 100) target -= 18 << BITRES >> (3-LM); | ||
2088 | /* Boosting bitrate on transients and vowels with significant temporal | ||
2089 | spikes. */ | ||
2090 | target += (opus_int32)MULT16_16_Q14(tf_estimate-QCONST16(.25f,14), (50<<BITRES)); | ||
2091 | /* If we have a strong transient, let's make sure it has enough bits to code | ||
2092 | the first two bands, so that it can use folding rather than noise. */ | ||
2093 | if (tf_estimate > QCONST16(.7f,14)) | ||
2094 | target = IMAX(target, 50<<BITRES); | ||
2095 | } | ||
2096 | /* The current offset is removed from the target and the space used | ||
2097 | so far is added*/ | ||
2098 | target=target+tell; | ||
2099 | /* In VBR mode the frame size must not be reduced so much that it would | ||
2100 | result in the encoder running out of bits. | ||
2101 | The margin of 2 bytes ensures that none of the bust-prevention logic | ||
2102 | in the decoder will have triggered so far. */ | ||
2103 | min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2; | ||
2104 | /* Take into account the 37 bits we need to have left in the packet to | ||
2105 | signal a redundant frame in hybrid mode. Creating a shorter packet would | ||
2106 | create an entropy coder desync. */ | ||
2107 | if (hybrid) | ||
2108 | min_allowed = IMAX(min_allowed, (tell0_frac+(37<<BITRES)+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)); | ||
2109 | |||
2110 | nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3); | ||
2111 | nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes); | ||
2112 | nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes); | ||
2113 | |||
2114 | /* By how much did we "miss" the target on that frame */ | ||
2115 | delta = target - vbr_rate; | ||
2116 | |||
2117 | target=nbAvailableBytes<<(BITRES+3); | ||
2118 | |||
2119 | /*If the frame is silent we don't adjust our drift, otherwise | ||
2120 | the encoder will shoot to very high rates after hitting a | ||
2121 | span of silence, but we do allow the bitres to refill. | ||
2122 | This means that we'll undershoot our target in CVBR/VBR modes | ||
2123 | on files with lots of silence. */ | ||
2124 | if(silence) | ||
2125 | { | ||
2126 | nbAvailableBytes = 2; | ||
2127 | target = 2*8<<BITRES; | ||
2128 | delta = 0; | ||
2129 | } | ||
2130 | |||
2131 | if (st->vbr_count < 970) | ||
2132 | { | ||
2133 | st->vbr_count++; | ||
2134 | alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16)); | ||
2135 | } else | ||
2136 | alpha = QCONST16(.001f,15); | ||
2137 | /* How many bits have we used in excess of what we're allowed */ | ||
2138 | if (st->constrained_vbr) | ||
2139 | st->vbr_reservoir += target - vbr_rate; | ||
2140 | /*printf ("%d\n", st->vbr_reservoir);*/ | ||
2141 | |||
2142 | /* Compute the offset we need to apply in order to reach the target */ | ||
2143 | if (st->constrained_vbr) | ||
2144 | { | ||
2145 | st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift); | ||
2146 | st->vbr_offset = -st->vbr_drift; | ||
2147 | } | ||
2148 | /*printf ("%d\n", st->vbr_drift);*/ | ||
2149 | |||
2150 | if (st->constrained_vbr && st->vbr_reservoir < 0) | ||
2151 | { | ||
2152 | /* We're under the min value -- increase rate */ | ||
2153 | int adjust = (-st->vbr_reservoir)/(8<<BITRES); | ||
2154 | /* Unless we're just coding silence */ | ||
2155 | nbAvailableBytes += silence?0:adjust; | ||
2156 | st->vbr_reservoir = 0; | ||
2157 | /*printf ("+%d\n", adjust);*/ | ||
2158 | } | ||
2159 | nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes); | ||
2160 | /*printf("%d\n", nbCompressedBytes*50*8);*/ | ||
2161 | /* This moves the raw bits to take into account the new compressed size */ | ||
2162 | ec_enc_shrink(enc, nbCompressedBytes); | ||
2163 | } | ||
2164 | |||
2165 | /* Bit allocation */ | ||
2166 | ALLOC(fine_quant, nbEBands, int); | ||
2167 | ALLOC(pulses, nbEBands, int); | ||
2168 | ALLOC(fine_priority, nbEBands, int); | ||
2169 | |||
2170 | /* bits = packet size - where we are - safety*/ | ||
2171 | bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1; | ||
2172 | anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0; | ||
2173 | bits -= anti_collapse_rsv; | ||
2174 | signalBandwidth = end-1; | ||
2175 | #ifndef DISABLE_FLOAT_API | ||
2176 | if (st->analysis.valid) | ||
2177 | { | ||
2178 | int min_bandwidth; | ||
2179 | if (equiv_rate < (opus_int32)32000*C) | ||
2180 | min_bandwidth = 13; | ||
2181 | else if (equiv_rate < (opus_int32)48000*C) | ||
2182 | min_bandwidth = 16; | ||
2183 | else if (equiv_rate < (opus_int32)60000*C) | ||
2184 | min_bandwidth = 18; | ||
2185 | else if (equiv_rate < (opus_int32)80000*C) | ||
2186 | min_bandwidth = 19; | ||
2187 | else | ||
2188 | min_bandwidth = 20; | ||
2189 | signalBandwidth = IMAX(st->analysis.bandwidth, min_bandwidth); | ||
2190 | } | ||
2191 | #endif | ||
2192 | if (st->lfe) | ||
2193 | signalBandwidth = 1; | ||
2194 | codedBands = clt_compute_allocation(mode, start, end, offsets, cap, | ||
2195 | alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses, | ||
2196 | fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands, signalBandwidth); | ||
2197 | if (st->lastCodedBands) | ||
2198 | st->lastCodedBands = IMIN(st->lastCodedBands+1,IMAX(st->lastCodedBands-1,codedBands)); | ||
2199 | else | ||
2200 | st->lastCodedBands = codedBands; | ||
2201 | |||
2202 | quant_fine_energy(mode, start, end, oldBandE, error, fine_quant, enc, C); | ||
2203 | |||
2204 | /* Residual quantisation */ | ||
2205 | ALLOC(collapse_masks, C*nbEBands, unsigned char); | ||
2206 | quant_all_bands(1, mode, start, end, X, C==2 ? X+N : NULL, collapse_masks, | ||
2207 | bandE, pulses, shortBlocks, st->spread_decision, | ||
2208 | dual_stereo, st->intensity, tf_res, nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, | ||
2209 | balance, enc, LM, codedBands, &st->rng, st->complexity, st->arch, st->disable_inv); | ||
2210 | |||
2211 | if (anti_collapse_rsv > 0) | ||
2212 | { | ||
2213 | anti_collapse_on = st->consec_transient<2; | ||
2214 | #ifdef FUZZING | ||
2215 | anti_collapse_on = rand()&0x1; | ||
2216 | #endif | ||
2217 | ec_enc_bits(enc, anti_collapse_on, 1); | ||
2218 | } | ||
2219 | quant_energy_finalise(mode, start, end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C); | ||
2220 | OPUS_CLEAR(energyError, nbEBands*CC); | ||
2221 | c=0; | ||
2222 | do { | ||
2223 | for (i=start;i<end;i++) | ||
2224 | { | ||
2225 | energyError[i+c*nbEBands] = MAX16(-QCONST16(0.5f, 15), MIN16(QCONST16(0.5f, 15), error[i+c*nbEBands])); | ||
2226 | } | ||
2227 | } while (++c < C); | ||
2228 | |||
2229 | if (silence) | ||
2230 | { | ||
2231 | for (i=0;i<C*nbEBands;i++) | ||
2232 | oldBandE[i] = -QCONST16(28.f,DB_SHIFT); | ||
2233 | } | ||
2234 | |||
2235 | #ifdef RESYNTH | ||
2236 | /* Re-synthesis of the coded audio if required */ | ||
2237 | { | ||
2238 | celt_sig *out_mem[2]; | ||
2239 | |||
2240 | if (anti_collapse_on) | ||
2241 | { | ||
2242 | anti_collapse(mode, X, collapse_masks, LM, C, N, | ||
2243 | start, end, oldBandE, oldLogE, oldLogE2, pulses, st->rng); | ||
2244 | } | ||
2245 | |||
2246 | c=0; do { | ||
2247 | OPUS_MOVE(st->syn_mem[c], st->syn_mem[c]+N, 2*MAX_PERIOD-N+overlap/2); | ||
2248 | } while (++c<CC); | ||
2249 | |||
2250 | c=0; do { | ||
2251 | out_mem[c] = st->syn_mem[c]+2*MAX_PERIOD-N; | ||
2252 | } while (++c<CC); | ||
2253 | |||
2254 | celt_synthesis(mode, X, out_mem, oldBandE, start, effEnd, | ||
2255 | C, CC, isTransient, LM, st->upsample, silence, st->arch); | ||
2256 | |||
2257 | c=0; do { | ||
2258 | st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD); | ||
2259 | st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD); | ||
2260 | comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, mode->shortMdctSize, | ||
2261 | st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset, | ||
2262 | mode->window, overlap); | ||
2263 | if (LM!=0) | ||
2264 | comb_filter(out_mem[c]+mode->shortMdctSize, out_mem[c]+mode->shortMdctSize, st->prefilter_period, pitch_index, N-mode->shortMdctSize, | ||
2265 | st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset, | ||
2266 | mode->window, overlap); | ||
2267 | } while (++c<CC); | ||
2268 | |||
2269 | /* We reuse freq[] as scratch space for the de-emphasis */ | ||
2270 | deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, mode->preemph, st->preemph_memD); | ||
2271 | st->prefilter_period_old = st->prefilter_period; | ||
2272 | st->prefilter_gain_old = st->prefilter_gain; | ||
2273 | st->prefilter_tapset_old = st->prefilter_tapset; | ||
2274 | } | ||
2275 | #endif | ||
2276 | |||
2277 | st->prefilter_period = pitch_index; | ||
2278 | st->prefilter_gain = gain1; | ||
2279 | st->prefilter_tapset = prefilter_tapset; | ||
2280 | #ifdef RESYNTH | ||
2281 | if (LM!=0) | ||
2282 | { | ||
2283 | st->prefilter_period_old = st->prefilter_period; | ||
2284 | st->prefilter_gain_old = st->prefilter_gain; | ||
2285 | st->prefilter_tapset_old = st->prefilter_tapset; | ||
2286 | } | ||
2287 | #endif | ||
2288 | |||
2289 | if (CC==2&&C==1) { | ||
2290 | OPUS_COPY(&oldBandE[nbEBands], oldBandE, nbEBands); | ||
2291 | } | ||
2292 | |||
2293 | if (!isTransient) | ||
2294 | { | ||
2295 | OPUS_COPY(oldLogE2, oldLogE, CC*nbEBands); | ||
2296 | OPUS_COPY(oldLogE, oldBandE, CC*nbEBands); | ||
2297 | } else { | ||
2298 | for (i=0;i<CC*nbEBands;i++) | ||
2299 | oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]); | ||
2300 | } | ||
2301 | /* In case start or end were to change */ | ||
2302 | c=0; do | ||
2303 | { | ||
2304 | for (i=0;i<start;i++) | ||
2305 | { | ||
2306 | oldBandE[c*nbEBands+i]=0; | ||
2307 | oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT); | ||
2308 | } | ||
2309 | for (i=end;i<nbEBands;i++) | ||
2310 | { | ||
2311 | oldBandE[c*nbEBands+i]=0; | ||
2312 | oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT); | ||
2313 | } | ||
2314 | } while (++c<CC); | ||
2315 | |||
2316 | if (isTransient || transient_got_disabled) | ||
2317 | st->consec_transient++; | ||
2318 | else | ||
2319 | st->consec_transient=0; | ||
2320 | st->rng = enc->rng; | ||
2321 | |||
2322 | /* If there's any room left (can only happen for very high rates), | ||
2323 | it's already filled with zeros */ | ||
2324 | ec_enc_done(enc); | ||
2325 | |||
2326 | #ifdef CUSTOM_MODES | ||
2327 | if (st->signalling) | ||
2328 | nbCompressedBytes++; | ||
2329 | #endif | ||
2330 | |||
2331 | RESTORE_STACK; | ||
2332 | if (ec_get_error(enc)) | ||
2333 | return OPUS_INTERNAL_ERROR; | ||
2334 | else | ||
2335 | return nbCompressedBytes; | ||
2336 | } | ||
2337 | |||
2338 | |||
2339 | #ifdef CUSTOM_MODES | ||
2340 | |||
2341 | #ifdef FIXED_POINT | ||
2342 | int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) | ||
2343 | { | ||
2344 | return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL); | ||
2345 | } | ||
2346 | |||
2347 | #ifndef DISABLE_FLOAT_API | ||
2348 | int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) | ||
2349 | { | ||
2350 | int j, ret, C, N; | ||
2351 | VARDECL(opus_int16, in); | ||
2352 | ALLOC_STACK; | ||
2353 | |||
2354 | if (pcm==NULL) | ||
2355 | return OPUS_BAD_ARG; | ||
2356 | |||
2357 | C = st->channels; | ||
2358 | N = frame_size; | ||
2359 | ALLOC(in, C*N, opus_int16); | ||
2360 | |||
2361 | for (j=0;j<C*N;j++) | ||
2362 | in[j] = FLOAT2INT16(pcm[j]); | ||
2363 | |||
2364 | ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL); | ||
2365 | #ifdef RESYNTH | ||
2366 | for (j=0;j<C*N;j++) | ||
2367 | ((float*)pcm)[j]=in[j]*(1.f/32768.f); | ||
2368 | #endif | ||
2369 | RESTORE_STACK; | ||
2370 | return ret; | ||
2371 | } | ||
2372 | #endif /* DISABLE_FLOAT_API */ | ||
2373 | #else | ||
2374 | |||
2375 | int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) | ||
2376 | { | ||
2377 | int j, ret, C, N; | ||
2378 | VARDECL(celt_sig, in); | ||
2379 | ALLOC_STACK; | ||
2380 | |||
2381 | if (pcm==NULL) | ||
2382 | return OPUS_BAD_ARG; | ||
2383 | |||
2384 | C=st->channels; | ||
2385 | N=frame_size; | ||
2386 | ALLOC(in, C*N, celt_sig); | ||
2387 | for (j=0;j<C*N;j++) { | ||
2388 | in[j] = SCALEOUT(pcm[j]); | ||
2389 | } | ||
2390 | |||
2391 | ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL); | ||
2392 | #ifdef RESYNTH | ||
2393 | for (j=0;j<C*N;j++) | ||
2394 | ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]); | ||
2395 | #endif | ||
2396 | RESTORE_STACK; | ||
2397 | return ret; | ||
2398 | } | ||
2399 | |||
2400 | int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) | ||
2401 | { | ||
2402 | return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL); | ||
2403 | } | ||
2404 | |||
2405 | #endif | ||
2406 | |||
2407 | #endif /* CUSTOM_MODES */ | ||
2408 | |||
2409 | int opus_custom_encoder_ctl(CELTEncoder * OPUS_RESTRICT st, int request, ...) | ||
2410 | { | ||
2411 | va_list ap; | ||
2412 | |||
2413 | va_start(ap, request); | ||
2414 | switch (request) | ||
2415 | { | ||
2416 | case OPUS_SET_COMPLEXITY_REQUEST: | ||
2417 | { | ||
2418 | int value = va_arg(ap, opus_int32); | ||
2419 | if (value<0 || value>10) | ||
2420 | goto bad_arg; | ||
2421 | st->complexity = value; | ||
2422 | } | ||
2423 | break; | ||
2424 | case CELT_SET_START_BAND_REQUEST: | ||
2425 | { | ||
2426 | opus_int32 value = va_arg(ap, opus_int32); | ||
2427 | if (value<0 || value>=st->mode->nbEBands) | ||
2428 | goto bad_arg; | ||
2429 | st->start = value; | ||
2430 | } | ||
2431 | break; | ||
2432 | case CELT_SET_END_BAND_REQUEST: | ||
2433 | { | ||
2434 | opus_int32 value = va_arg(ap, opus_int32); | ||
2435 | if (value<1 || value>st->mode->nbEBands) | ||
2436 | goto bad_arg; | ||
2437 | st->end = value; | ||
2438 | } | ||
2439 | break; | ||
2440 | case CELT_SET_PREDICTION_REQUEST: | ||
2441 | { | ||
2442 | int value = va_arg(ap, opus_int32); | ||
2443 | if (value<0 || value>2) | ||
2444 | goto bad_arg; | ||
2445 | st->disable_pf = value<=1; | ||
2446 | st->force_intra = value==0; | ||
2447 | } | ||
2448 | break; | ||
2449 | case OPUS_SET_PACKET_LOSS_PERC_REQUEST: | ||
2450 | { | ||
2451 | int value = va_arg(ap, opus_int32); | ||
2452 | if (value<0 || value>100) | ||
2453 | goto bad_arg; | ||
2454 | st->loss_rate = value; | ||
2455 | } | ||
2456 | break; | ||
2457 | case OPUS_SET_VBR_CONSTRAINT_REQUEST: | ||
2458 | { | ||
2459 | opus_int32 value = va_arg(ap, opus_int32); | ||
2460 | st->constrained_vbr = value; | ||
2461 | } | ||
2462 | break; | ||
2463 | case OPUS_SET_VBR_REQUEST: | ||
2464 | { | ||
2465 | opus_int32 value = va_arg(ap, opus_int32); | ||
2466 | st->vbr = value; | ||
2467 | } | ||
2468 | break; | ||
2469 | case OPUS_SET_BITRATE_REQUEST: | ||
2470 | { | ||
2471 | opus_int32 value = va_arg(ap, opus_int32); | ||
2472 | if (value<=500 && value!=OPUS_BITRATE_MAX) | ||
2473 | goto bad_arg; | ||
2474 | value = IMIN(value, 260000*st->channels); | ||
2475 | st->bitrate = value; | ||
2476 | } | ||
2477 | break; | ||
2478 | case CELT_SET_CHANNELS_REQUEST: | ||
2479 | { | ||
2480 | opus_int32 value = va_arg(ap, opus_int32); | ||
2481 | if (value<1 || value>2) | ||
2482 | goto bad_arg; | ||
2483 | st->stream_channels = value; | ||
2484 | } | ||
2485 | break; | ||
2486 | case OPUS_SET_LSB_DEPTH_REQUEST: | ||
2487 | { | ||
2488 | opus_int32 value = va_arg(ap, opus_int32); | ||
2489 | if (value<8 || value>24) | ||
2490 | goto bad_arg; | ||
2491 | st->lsb_depth=value; | ||
2492 | } | ||
2493 | break; | ||
2494 | case OPUS_GET_LSB_DEPTH_REQUEST: | ||
2495 | { | ||
2496 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2497 | *value=st->lsb_depth; | ||
2498 | } | ||
2499 | break; | ||
2500 | case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST: | ||
2501 | { | ||
2502 | opus_int32 value = va_arg(ap, opus_int32); | ||
2503 | if(value<0 || value>1) | ||
2504 | { | ||
2505 | goto bad_arg; | ||
2506 | } | ||
2507 | st->disable_inv = value; | ||
2508 | } | ||
2509 | break; | ||
2510 | case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST: | ||
2511 | { | ||
2512 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2513 | if (!value) | ||
2514 | { | ||
2515 | goto bad_arg; | ||
2516 | } | ||
2517 | *value = st->disable_inv; | ||
2518 | } | ||
2519 | break; | ||
2520 | case OPUS_RESET_STATE: | ||
2521 | { | ||
2522 | int i; | ||
2523 | opus_val16 *oldBandE, *oldLogE, *oldLogE2; | ||
2524 | oldBandE = (opus_val16*)(st->in_mem+st->channels*(st->mode->overlap+COMBFILTER_MAXPERIOD)); | ||
2525 | oldLogE = oldBandE + st->channels*st->mode->nbEBands; | ||
2526 | oldLogE2 = oldLogE + st->channels*st->mode->nbEBands; | ||
2527 | OPUS_CLEAR((char*)&st->ENCODER_RESET_START, | ||
2528 | opus_custom_encoder_get_size(st->mode, st->channels)- | ||
2529 | ((char*)&st->ENCODER_RESET_START - (char*)st)); | ||
2530 | for (i=0;i<st->channels*st->mode->nbEBands;i++) | ||
2531 | oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT); | ||
2532 | st->vbr_offset = 0; | ||
2533 | st->delayedIntra = 1; | ||
2534 | st->spread_decision = SPREAD_NORMAL; | ||
2535 | st->tonal_average = 256; | ||
2536 | st->hf_average = 0; | ||
2537 | st->tapset_decision = 0; | ||
2538 | } | ||
2539 | break; | ||
2540 | #ifdef CUSTOM_MODES | ||
2541 | case CELT_SET_INPUT_CLIPPING_REQUEST: | ||
2542 | { | ||
2543 | opus_int32 value = va_arg(ap, opus_int32); | ||
2544 | st->clip = value; | ||
2545 | } | ||
2546 | break; | ||
2547 | #endif | ||
2548 | case CELT_SET_SIGNALLING_REQUEST: | ||
2549 | { | ||
2550 | opus_int32 value = va_arg(ap, opus_int32); | ||
2551 | st->signalling = value; | ||
2552 | } | ||
2553 | break; | ||
2554 | case CELT_SET_ANALYSIS_REQUEST: | ||
2555 | { | ||
2556 | AnalysisInfo *info = va_arg(ap, AnalysisInfo *); | ||
2557 | if (info) | ||
2558 | OPUS_COPY(&st->analysis, info, 1); | ||
2559 | } | ||
2560 | break; | ||
2561 | case CELT_SET_SILK_INFO_REQUEST: | ||
2562 | { | ||
2563 | SILKInfo *info = va_arg(ap, SILKInfo *); | ||
2564 | if (info) | ||
2565 | OPUS_COPY(&st->silk_info, info, 1); | ||
2566 | } | ||
2567 | break; | ||
2568 | case CELT_GET_MODE_REQUEST: | ||
2569 | { | ||
2570 | const CELTMode ** value = va_arg(ap, const CELTMode**); | ||
2571 | if (value==0) | ||
2572 | goto bad_arg; | ||
2573 | *value=st->mode; | ||
2574 | } | ||
2575 | break; | ||
2576 | case OPUS_GET_FINAL_RANGE_REQUEST: | ||
2577 | { | ||
2578 | opus_uint32 * value = va_arg(ap, opus_uint32 *); | ||
2579 | if (value==0) | ||
2580 | goto bad_arg; | ||
2581 | *value=st->rng; | ||
2582 | } | ||
2583 | break; | ||
2584 | case OPUS_SET_LFE_REQUEST: | ||
2585 | { | ||
2586 | opus_int32 value = va_arg(ap, opus_int32); | ||
2587 | st->lfe = value; | ||
2588 | } | ||
2589 | break; | ||
2590 | case OPUS_SET_ENERGY_MASK_REQUEST: | ||
2591 | { | ||
2592 | opus_val16 *value = va_arg(ap, opus_val16*); | ||
2593 | st->energy_mask = value; | ||
2594 | } | ||
2595 | break; | ||
2596 | default: | ||
2597 | goto bad_request; | ||
2598 | } | ||
2599 | va_end(ap); | ||
2600 | return OPUS_OK; | ||
2601 | bad_arg: | ||
2602 | va_end(ap); | ||
2603 | return OPUS_BAD_ARG; | ||
2604 | bad_request: | ||
2605 | va_end(ap); | ||
2606 | return OPUS_UNIMPLEMENTED; | ||
2607 | } | ||