The Tor Browser / file comparison

comparison: media/libopus/celt/celt_decoder.c

media/libopus/celt/celt_decoder.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:7a0a7406c5c8
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_DECODER_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 /* */
56 /* DECODER */
57 /* */
58 /**********************************************************************/
59 #define DECODE_BUFFER_SIZE 2048
60
61 /** Decoder state
62 @brief Decoder state
63 */
64 struct OpusCustomDecoder {
65 const OpusCustomMode *mode;
66 int overlap;
67 int channels;
68 int stream_channels;
69
70 int downsample;
71 int start, end;
72 int signalling;
73 int arch;
74
75 /* Everything beyond this point gets cleared on a reset */
76 #define DECODER_RESET_START rng
77
78 opus_uint32 rng;
79 int error;
80 int last_pitch_index;
81 int loss_count;
82 int postfilter_period;
83 int postfilter_period_old;
84 opus_val16 postfilter_gain;
85 opus_val16 postfilter_gain_old;
86 int postfilter_tapset;
87 int postfilter_tapset_old;
88
89 celt_sig preemph_memD[2];
90
91 celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
92 /* opus_val16 lpc[], Size = channels*LPC_ORDER */
93 /* opus_val16 oldEBands[], Size = 2*mode->nbEBands */
94 /* opus_val16 oldLogE[], Size = 2*mode->nbEBands */
95 /* opus_val16 oldLogE2[], Size = 2*mode->nbEBands */
96 /* opus_val16 backgroundLogE[], Size = 2*mode->nbEBands */
97 };
98
99 int celt_decoder_get_size(int channels)
100 {
101 const CELTMode *mode = opus_custom_mode_create(48000, 960, NULL);
102 return opus_custom_decoder_get_size(mode, channels);
103 }
104
105 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_get_size(const CELTMode *mode, int channels)
106 {
107 int size = sizeof(struct CELTDecoder)
108 + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
109 + channels*LPC_ORDER*sizeof(opus_val16)
110 + 4*2*mode->nbEBands*sizeof(opus_val16);
111 return size;
112 }
113
114 #ifdef CUSTOM_MODES
115 CELTDecoder *opus_custom_decoder_create(const CELTMode *mode, int channels, int *error)
116 {
117 int ret;
118 CELTDecoder *st = (CELTDecoder *)opus_alloc(opus_custom_decoder_get_size(mode, channels));
119 ret = opus_custom_decoder_init(st, mode, channels);
120 if (ret != OPUS_OK)
121 {
122 opus_custom_decoder_destroy(st);
123 st = NULL;
124 }
125 if (error)
126 *error = ret;
127 return st;
128 }
129 #endif /* CUSTOM_MODES */
130
131 int celt_decoder_init(CELTDecoder *st, opus_int32 sampling_rate, int channels)
132 {
133 int ret;
134 ret = opus_custom_decoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels);
135 if (ret != OPUS_OK)
136 return ret;
137 st->downsample = resampling_factor(sampling_rate);
138 if (st->downsample==0)
139 return OPUS_BAD_ARG;
140 else
141 return OPUS_OK;
142 }
143
144 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels)
145 {
146 if (channels < 0 || channels > 2)
147 return OPUS_BAD_ARG;
148
149 if (st==NULL)
150 return OPUS_ALLOC_FAIL;
151
152 OPUS_CLEAR((char*)st, opus_custom_decoder_get_size(mode, channels));
153
154 st->mode = mode;
155 st->overlap = mode->overlap;
156 st->stream_channels = st->channels = channels;
157
158 st->downsample = 1;
159 st->start = 0;
160 st->end = st->mode->effEBands;
161 st->signalling = 1;
162 st->arch = opus_select_arch();
163
164 st->loss_count = 0;
165
166 opus_custom_decoder_ctl(st, OPUS_RESET_STATE);
167
168 return OPUS_OK;
169 }
170
171 #ifdef CUSTOM_MODES
172 void opus_custom_decoder_destroy(CELTDecoder *st)
173 {
174 opus_free(st);
175 }
176 #endif /* CUSTOM_MODES */
177
178 static OPUS_INLINE opus_val16 SIG2WORD16(celt_sig x)
179 {
180 #ifdef FIXED_POINT
181 x = PSHR32(x, SIG_SHIFT);
182 x = MAX32(x, -32768);
183 x = MIN32(x, 32767);
184 return EXTRACT16(x);
185 #else
186 return (opus_val16)x;
187 #endif
188 }
189
190 #ifndef RESYNTH
191 static
192 #endif
193 void deemphasis(celt_sig *in[], opus_val16 *pcm, int N, int C, int downsample, const opus_val16 *coef, celt_sig *mem, celt_sig * OPUS_RESTRICT scratch)
194 {
195 int c;
196 int Nd;
197 int apply_downsampling=0;
198 opus_val16 coef0;
199
200 coef0 = coef[0];
201 Nd = N/downsample;
202 c=0; do {
203 int j;
204 celt_sig * OPUS_RESTRICT x;
205 opus_val16 * OPUS_RESTRICT y;
206 celt_sig m = mem[c];
207 x =in[c];
208 y = pcm+c;
209 #ifdef CUSTOM_MODES
210 if (coef[1] != 0)
211 {
212 opus_val16 coef1 = coef[1];
213 opus_val16 coef3 = coef[3];
214 for (j=0;j<N;j++)
215 {
216 celt_sig tmp = x[j] + m + VERY_SMALL;
217 m = MULT16_32_Q15(coef0, tmp)
218 - MULT16_32_Q15(coef1, x[j]);
219 tmp = SHL32(MULT16_32_Q15(coef3, tmp), 2);
220 scratch[j] = tmp;
221 }
222 apply_downsampling=1;
223 } else
224 #endif
225 if (downsample>1)
226 {
227 /* Shortcut for the standard (non-custom modes) case */
228 for (j=0;j<N;j++)
229 {
230 celt_sig tmp = x[j] + m + VERY_SMALL;
231 m = MULT16_32_Q15(coef0, tmp);
232 scratch[j] = tmp;
233 }
234 apply_downsampling=1;
235 } else {
236 /* Shortcut for the standard (non-custom modes) case */
237 for (j=0;j<N;j++)
238 {
239 celt_sig tmp = x[j] + m + VERY_SMALL;
240 m = MULT16_32_Q15(coef0, tmp);
241 y[j*C] = SCALEOUT(SIG2WORD16(tmp));
242 }
243 }
244 mem[c] = m;
245
246 if (apply_downsampling)
247 {
248 /* Perform down-sampling */
249 for (j=0;j<Nd;j++)
250 y[j*C] = SCALEOUT(SIG2WORD16(scratch[j*downsample]));
251 }
252 } while (++c<C);
253 }
254
255 /** Compute the IMDCT and apply window for all sub-frames and
256 all channels in a frame */
257 #ifndef RESYNTH
258 static
259 #endif
260 void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X,
261 celt_sig * OPUS_RESTRICT out_mem[], int C, int LM)
262 {
263 int b, c;
264 int B;
265 int N;
266 int shift;
267 const int overlap = OVERLAP(mode);
268
269 if (shortBlocks)
270 {
271 B = shortBlocks;
272 N = mode->shortMdctSize;
273 shift = mode->maxLM;
274 } else {
275 B = 1;
276 N = mode->shortMdctSize<<LM;
277 shift = mode->maxLM-LM;
278 }
279 c=0; do {
280 /* IMDCT on the interleaved the sub-frames, overlap-add is performed by the IMDCT */
281 for (b=0;b<B;b++)
282 clt_mdct_backward(&mode->mdct, &X[b+c*N*B], out_mem[c]+N*b, mode->window, overlap, shift, B);
283 } while (++c<C);
284 }
285
286 static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec)
287 {
288 int i, curr, tf_select;
289 int tf_select_rsv;
290 int tf_changed;
291 int logp;
292 opus_uint32 budget;
293 opus_uint32 tell;
294
295 budget = dec->storage*8;
296 tell = ec_tell(dec);
297 logp = isTransient ? 2 : 4;
298 tf_select_rsv = LM>0 && tell+logp+1<=budget;
299 budget -= tf_select_rsv;
300 tf_changed = curr = 0;
301 for (i=start;i<end;i++)
302 {
303 if (tell+logp<=budget)
304 {
305 curr ^= ec_dec_bit_logp(dec, logp);
306 tell = ec_tell(dec);
307 tf_changed |= curr;
308 }
309 tf_res[i] = curr;
310 logp = isTransient ? 4 : 5;
311 }
312 tf_select = 0;
313 if (tf_select_rsv &&
314 tf_select_table[LM][4*isTransient+0+tf_changed] !=
315 tf_select_table[LM][4*isTransient+2+tf_changed])
316 {
317 tf_select = ec_dec_bit_logp(dec, 1);
318 }
319 for (i=start;i<end;i++)
320 {
321 tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
322 }
323 }
324
325 /* The maximum pitch lag to allow in the pitch-based PLC. It's possible to save
326 CPU time in the PLC pitch search by making this smaller than MAX_PERIOD. The
327 current value corresponds to a pitch of 66.67 Hz. */
328 #define PLC_PITCH_LAG_MAX (720)
329 /* The minimum pitch lag to allow in the pitch-based PLC. This corresponds to a
330 pitch of 480 Hz. */
331 #define PLC_PITCH_LAG_MIN (100)
332
333 static void celt_decode_lost(CELTDecoder * OPUS_RESTRICT st, opus_val16 * OPUS_RESTRICT pcm, int N, int LM)
334 {
335 int c;
336 int i;
337 const int C = st->channels;
338 celt_sig *decode_mem[2];
339 celt_sig *out_syn[2];
340 opus_val16 *lpc;
341 opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
342 const OpusCustomMode *mode;
343 int nbEBands;
344 int overlap;
345 int start;
346 int downsample;
347 int loss_count;
348 int noise_based;
349 const opus_int16 *eBands;
350 VARDECL(celt_sig, scratch);
351 SAVE_STACK;
352
353 mode = st->mode;
354 nbEBands = mode->nbEBands;
355 overlap = mode->overlap;
356 eBands = mode->eBands;
357
358 c=0; do {
359 decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap);
360 out_syn[c] = decode_mem[c]+DECODE_BUFFER_SIZE-N;
361 } while (++c<C);
362 lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*C);
363 oldBandE = lpc+C*LPC_ORDER;
364 oldLogE = oldBandE + 2*nbEBands;
365 oldLogE2 = oldLogE + 2*nbEBands;
366 backgroundLogE = oldLogE2 + 2*nbEBands;
367
368 loss_count = st->loss_count;
369 start = st->start;
370 downsample = st->downsample;
371 noise_based = loss_count >= 5 || start != 0;
372 ALLOC(scratch, noise_based?N*C:N, celt_sig);
373 if (noise_based)
374 {
375 /* Noise-based PLC/CNG */
376 celt_sig *freq;
377 VARDECL(celt_norm, X);
378 opus_uint32 seed;
379 opus_val16 *plcLogE;
380 int end;
381 int effEnd;
382
383 end = st->end;
384 effEnd = IMAX(start, IMIN(end, mode->effEBands));
385
386 /* Share the interleaved signal MDCT coefficient buffer with the
387 deemphasis scratch buffer. */
388 freq = scratch;
389 ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */
390
391 if (loss_count >= 5)
392 plcLogE = backgroundLogE;
393 else {
394 /* Energy decay */
395 opus_val16 decay = loss_count==0 ?
396 QCONST16(1.5f, DB_SHIFT) : QCONST16(.5f, DB_SHIFT);
397 c=0; do
398 {
399 for (i=start;i<end;i++)
400 oldBandE[c*nbEBands+i] -= decay;
401 } while (++c<C);
402 plcLogE = oldBandE;
403 }
404 seed = st->rng;
405 for (c=0;c<C;c++)
406 {
407 for (i=start;i<effEnd;i++)
408 {
409 int j;
410 int boffs;
411 int blen;
412 boffs = N*c+(eBands[i]<<LM);
413 blen = (eBands[i+1]-eBands[i])<<LM;
414 for (j=0;j<blen;j++)
415 {
416 seed = celt_lcg_rand(seed);
417 X[boffs+j] = (celt_norm)((opus_int32)seed>>20);
418 }
419 renormalise_vector(X+boffs, blen, Q15ONE);
420 }
421 }
422 st->rng = seed;
423
424 denormalise_bands(mode, X, freq, plcLogE, start, effEnd, C, 1<<LM);
425
426 c=0; do {
427 int bound = eBands[effEnd]<<LM;
428 if (downsample!=1)
429 bound = IMIN(bound, N/downsample);
430 for (i=bound;i<N;i++)
431 freq[c*N+i] = 0;
432 } while (++c<C);
433 c=0; do {
434 OPUS_MOVE(decode_mem[c], decode_mem[c]+N,
435 DECODE_BUFFER_SIZE-N+(overlap>>1));
436 } while (++c<C);
437 compute_inv_mdcts(mode, 0, freq, out_syn, C, LM);
438 } else {
439 /* Pitch-based PLC */
440 const opus_val16 *window;
441 opus_val16 fade = Q15ONE;
442 int pitch_index;
443 VARDECL(opus_val32, etmp);
444 VARDECL(opus_val16, exc);
445
446 if (loss_count == 0)
447 {
448 VARDECL( opus_val16, lp_pitch_buf );
449 ALLOC( lp_pitch_buf, DECODE_BUFFER_SIZE>>1, opus_val16 );
450 pitch_downsample(decode_mem, lp_pitch_buf,
451 DECODE_BUFFER_SIZE, C, st->arch);
452 pitch_search(lp_pitch_buf+(PLC_PITCH_LAG_MAX>>1), lp_pitch_buf,
453 DECODE_BUFFER_SIZE-PLC_PITCH_LAG_MAX,
454 PLC_PITCH_LAG_MAX-PLC_PITCH_LAG_MIN, &pitch_index, st->arch);
455 pitch_index = PLC_PITCH_LAG_MAX-pitch_index;
456 st->last_pitch_index = pitch_index;
457 } else {
458 pitch_index = st->last_pitch_index;
459 fade = QCONST16(.8f,15);
460 }
461
462 ALLOC(etmp, overlap, opus_val32);
463 ALLOC(exc, MAX_PERIOD, opus_val16);
464 window = mode->window;
465 c=0; do {
466 opus_val16 decay;
467 opus_val16 attenuation;
468 opus_val32 S1=0;
469 celt_sig *buf;
470 int extrapolation_offset;
471 int extrapolation_len;
472 int exc_length;
473 int j;
474
475 buf = decode_mem[c];
476 for (i=0;i<MAX_PERIOD;i++) {
477 exc[i] = ROUND16(buf[DECODE_BUFFER_SIZE-MAX_PERIOD+i], SIG_SHIFT);
478 }
479
480 if (loss_count == 0)
481 {
482 opus_val32 ac[LPC_ORDER+1];
483 /* Compute LPC coefficients for the last MAX_PERIOD samples before
484 the first loss so we can work in the excitation-filter domain. */
485 _celt_autocorr(exc, ac, window, overlap,
486 LPC_ORDER, MAX_PERIOD, st->arch);
487 /* Add a noise floor of -40 dB. */
488 #ifdef FIXED_POINT
489 ac[0] += SHR32(ac[0],13);
490 #else
491 ac[0] *= 1.0001f;
492 #endif
493 /* Use lag windowing to stabilize the Levinson-Durbin recursion. */
494 for (i=1;i<=LPC_ORDER;i++)
495 {
496 /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
497 #ifdef FIXED_POINT
498 ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
499 #else
500 ac[i] -= ac[i]*(0.008f*0.008f)*i*i;
501 #endif
502 }
503 _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
504 }
505 /* We want the excitation for 2 pitch periods in order to look for a
506 decaying signal, but we can't get more than MAX_PERIOD. */
507 exc_length = IMIN(2*pitch_index, MAX_PERIOD);
508 /* Initialize the LPC history with the samples just before the start
509 of the region for which we're computing the excitation. */
510 {
511 opus_val16 lpc_mem[LPC_ORDER];
512 for (i=0;i<LPC_ORDER;i++)
513 {
514 lpc_mem[i] =
515 ROUND16(buf[DECODE_BUFFER_SIZE-exc_length-1-i], SIG_SHIFT);
516 }
517 /* Compute the excitation for exc_length samples before the loss. */
518 celt_fir(exc+MAX_PERIOD-exc_length, lpc+c*LPC_ORDER,
519 exc+MAX_PERIOD-exc_length, exc_length, LPC_ORDER, lpc_mem);
520 }
521
522 /* Check if the waveform is decaying, and if so how fast.
523 We do this to avoid adding energy when concealing in a segment
524 with decaying energy. */
525 {
526 opus_val32 E1=1, E2=1;
527 int decay_length;
528 #ifdef FIXED_POINT
529 int shift = IMAX(0,2*celt_zlog2(celt_maxabs16(&exc[MAX_PERIOD-exc_length], exc_length))-20);
530 #endif
531 decay_length = exc_length>>1;
532 for (i=0;i<decay_length;i++)
533 {
534 opus_val16 e;
535 e = exc[MAX_PERIOD-decay_length+i];
536 E1 += SHR32(MULT16_16(e, e), shift);
537 e = exc[MAX_PERIOD-2*decay_length+i];
538 E2 += SHR32(MULT16_16(e, e), shift);
539 }
540 E1 = MIN32(E1, E2);
541 decay = celt_sqrt(frac_div32(SHR32(E1, 1), E2));
542 }
543
544 /* Move the decoder memory one frame to the left to give us room to
545 add the data for the new frame. We ignore the overlap that extends
546 past the end of the buffer, because we aren't going to use it. */
547 OPUS_MOVE(buf, buf+N, DECODE_BUFFER_SIZE-N);
548
549 /* Extrapolate from the end of the excitation with a period of
550 "pitch_index", scaling down each period by an additional factor of
551 "decay". */
552 extrapolation_offset = MAX_PERIOD-pitch_index;
553 /* We need to extrapolate enough samples to cover a complete MDCT
554 window (including overlap/2 samples on both sides). */
555 extrapolation_len = N+overlap;
556 /* We also apply fading if this is not the first loss. */
557 attenuation = MULT16_16_Q15(fade, decay);
558 for (i=j=0;i<extrapolation_len;i++,j++)
559 {
560 opus_val16 tmp;
561 if (j >= pitch_index) {
562 j -= pitch_index;
563 attenuation = MULT16_16_Q15(attenuation, decay);
564 }
565 buf[DECODE_BUFFER_SIZE-N+i] =
566 SHL32(EXTEND32(MULT16_16_Q15(attenuation,
567 exc[extrapolation_offset+j])), SIG_SHIFT);
568 /* Compute the energy of the previously decoded signal whose
569 excitation we're copying. */
570 tmp = ROUND16(
571 buf[DECODE_BUFFER_SIZE-MAX_PERIOD-N+extrapolation_offset+j],
572 SIG_SHIFT);
573 S1 += SHR32(MULT16_16(tmp, tmp), 8);
574 }
575
576 {
577 opus_val16 lpc_mem[LPC_ORDER];
578 /* Copy the last decoded samples (prior to the overlap region) to
579 synthesis filter memory so we can have a continuous signal. */
580 for (i=0;i<LPC_ORDER;i++)
581 lpc_mem[i] = ROUND16(buf[DECODE_BUFFER_SIZE-N-1-i], SIG_SHIFT);
582 /* Apply the synthesis filter to convert the excitation back into
583 the signal domain. */
584 celt_iir(buf+DECODE_BUFFER_SIZE-N, lpc+c*LPC_ORDER,
585 buf+DECODE_BUFFER_SIZE-N, extrapolation_len, LPC_ORDER,
586 lpc_mem);
587 }
588
589 /* Check if the synthesis energy is higher than expected, which can
590 happen with the signal changes during our window. If so,
591 attenuate. */
592 {
593 opus_val32 S2=0;
594 for (i=0;i<extrapolation_len;i++)
595 {
596 opus_val16 tmp = ROUND16(buf[DECODE_BUFFER_SIZE-N+i], SIG_SHIFT);
597 S2 += SHR32(MULT16_16(tmp, tmp), 8);
598 }
599 /* This checks for an "explosion" in the synthesis. */
600 #ifdef FIXED_POINT
601 if (!(S1 > SHR32(S2,2)))
602 #else
603 /* The float test is written this way to catch NaNs in the output
604 of the IIR filter at the same time. */
605 if (!(S1 > 0.2f*S2))
606 #endif
607 {
608 for (i=0;i<extrapolation_len;i++)
609 buf[DECODE_BUFFER_SIZE-N+i] = 0;
610 } else if (S1 < S2)
611 {
612 opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
613 for (i=0;i<overlap;i++)
614 {
615 opus_val16 tmp_g = Q15ONE
616 - MULT16_16_Q15(window[i], Q15ONE-ratio);
617 buf[DECODE_BUFFER_SIZE-N+i] =
618 MULT16_32_Q15(tmp_g, buf[DECODE_BUFFER_SIZE-N+i]);
619 }
620 for (i=overlap;i<extrapolation_len;i++)
621 {
622 buf[DECODE_BUFFER_SIZE-N+i] =
623 MULT16_32_Q15(ratio, buf[DECODE_BUFFER_SIZE-N+i]);
624 }
625 }
626 }
627
628 /* Apply the pre-filter to the MDCT overlap for the next frame because
629 the post-filter will be re-applied in the decoder after the MDCT
630 overlap. */
631 comb_filter(etmp, buf+DECODE_BUFFER_SIZE,
632 st->postfilter_period, st->postfilter_period, overlap,
633 -st->postfilter_gain, -st->postfilter_gain,
634 st->postfilter_tapset, st->postfilter_tapset, NULL, 0);
635
636 /* Simulate TDAC on the concealed audio so that it blends with the
637 MDCT of the next frame. */
638 for (i=0;i<overlap/2;i++)
639 {
640 buf[DECODE_BUFFER_SIZE+i] =
641 MULT16_32_Q15(window[i], etmp[overlap-1-i])
642 + MULT16_32_Q15(window[overlap-i-1], etmp[i]);
643 }
644 } while (++c<C);
645 }
646
647 deemphasis(out_syn, pcm, N, C, downsample,
648 mode->preemph, st->preemph_memD, scratch);
649
650 st->loss_count = loss_count+1;
651
652 RESTORE_STACK;
653 }
654
655 int celt_decode_with_ec(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_val16 * OPUS_RESTRICT pcm, int frame_size, ec_dec *dec)
656 {
657 int c, i, N;
658 int spread_decision;
659 opus_int32 bits;
660 ec_dec _dec;
661 VARDECL(celt_sig, freq);
662 VARDECL(celt_norm, X);
663 VARDECL(int, fine_quant);
664 VARDECL(int, pulses);
665 VARDECL(int, cap);
666 VARDECL(int, offsets);
667 VARDECL(int, fine_priority);
668 VARDECL(int, tf_res);
669 VARDECL(unsigned char, collapse_masks);
670 celt_sig *decode_mem[2];
671 celt_sig *out_syn[2];
672 opus_val16 *lpc;
673 opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
674
675 int shortBlocks;
676 int isTransient;
677 int intra_ener;
678 const int CC = st->channels;
679 int LM, M;
680 int effEnd;
681 int codedBands;
682 int alloc_trim;
683 int postfilter_pitch;
684 opus_val16 postfilter_gain;
685 int intensity=0;
686 int dual_stereo=0;
687 opus_int32 total_bits;
688 opus_int32 balance;
689 opus_int32 tell;
690 int dynalloc_logp;
691 int postfilter_tapset;
692 int anti_collapse_rsv;
693 int anti_collapse_on=0;
694 int silence;
695 int C = st->stream_channels;
696 const OpusCustomMode *mode;
697 int nbEBands;
698 int overlap;
699 const opus_int16 *eBands;
700 ALLOC_STACK;
701
702 mode = st->mode;
703 nbEBands = mode->nbEBands;
704 overlap = mode->overlap;
705 eBands = mode->eBands;
706 frame_size *= st->downsample;
707
708 c=0; do {
709 decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap);
710 } while (++c<CC);
711 lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*CC);
712 oldBandE = lpc+CC*LPC_ORDER;
713 oldLogE = oldBandE + 2*nbEBands;
714 oldLogE2 = oldLogE + 2*nbEBands;
715 backgroundLogE = oldLogE2 + 2*nbEBands;
716
717 #ifdef CUSTOM_MODES
718 if (st->signalling && data!=NULL)
719 {
720 int data0=data[0];
721 /* Convert "standard mode" to Opus header */
722 if (mode->Fs==48000 && mode->shortMdctSize==120)
723 {
724 data0 = fromOpus(data0);
725 if (data0<0)
726 return OPUS_INVALID_PACKET;
727 }
728 st->end = IMAX(1, mode->effEBands-2*(data0>>5));
729 LM = (data0>>3)&0x3;
730 C = 1 + ((data0>>2)&0x1);
731 data++;
732 len--;
733 if (LM>mode->maxLM)
734 return OPUS_INVALID_PACKET;
735 if (frame_size < mode->shortMdctSize<<LM)
736 return OPUS_BUFFER_TOO_SMALL;
737 else
738 frame_size = mode->shortMdctSize<<LM;
739 } else {
740 #else
741 {
742 #endif
743 for (LM=0;LM<=mode->maxLM;LM++)
744 if (mode->shortMdctSize<<LM==frame_size)
745 break;
746 if (LM>mode->maxLM)
747 return OPUS_BAD_ARG;
748 }
749 M=1<<LM;
750
751 if (len<0 || len>1275 || pcm==NULL)
752 return OPUS_BAD_ARG;
753
754 N = M*mode->shortMdctSize;
755
756 effEnd = st->end;
757 if (effEnd > mode->effEBands)
758 effEnd = mode->effEBands;
759
760 if (data == NULL || len<=1)
761 {
762 celt_decode_lost(st, pcm, N, LM);
763 RESTORE_STACK;
764 return frame_size/st->downsample;
765 }
766
767 if (dec == NULL)
768 {
769 ec_dec_init(&_dec,(unsigned char*)data,len);
770 dec = &_dec;
771 }
772
773 if (C==1)
774 {
775 for (i=0;i<nbEBands;i++)
776 oldBandE[i]=MAX16(oldBandE[i],oldBandE[nbEBands+i]);
777 }
778
779 total_bits = len*8;
780 tell = ec_tell(dec);
781
782 if (tell >= total_bits)
783 silence = 1;
784 else if (tell==1)
785 silence = ec_dec_bit_logp(dec, 15);
786 else
787 silence = 0;
788 if (silence)
789 {
790 /* Pretend we've read all the remaining bits */
791 tell = len*8;
792 dec->nbits_total+=tell-ec_tell(dec);
793 }
794
795 postfilter_gain = 0;
796 postfilter_pitch = 0;
797 postfilter_tapset = 0;
798 if (st->start==0 && tell+16 <= total_bits)
799 {
800 if(ec_dec_bit_logp(dec, 1))
801 {
802 int qg, octave;
803 octave = ec_dec_uint(dec, 6);
804 postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
805 qg = ec_dec_bits(dec, 3);
806 if (ec_tell(dec)+2<=total_bits)
807 postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
808 postfilter_gain = QCONST16(.09375f,15)*(qg+1);
809 }
810 tell = ec_tell(dec);
811 }
812
813 if (LM > 0 && tell+3 <= total_bits)
814 {
815 isTransient = ec_dec_bit_logp(dec, 3);
816 tell = ec_tell(dec);
817 }
818 else
819 isTransient = 0;
820
821 if (isTransient)
822 shortBlocks = M;
823 else
824 shortBlocks = 0;
825
826 /* Decode the global flags (first symbols in the stream) */
827 intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
828 /* Get band energies */
829 unquant_coarse_energy(mode, st->start, st->end, oldBandE,
830 intra_ener, dec, C, LM);
831
832 ALLOC(tf_res, nbEBands, int);
833 tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
834
835 tell = ec_tell(dec);
836 spread_decision = SPREAD_NORMAL;
837 if (tell+4 <= total_bits)
838 spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
839
840 ALLOC(cap, nbEBands, int);
841
842 init_caps(mode,cap,LM,C);
843
844 ALLOC(offsets, nbEBands, int);
845
846 dynalloc_logp = 6;
847 total_bits<<=BITRES;
848 tell = ec_tell_frac(dec);
849 for (i=st->start;i<st->end;i++)
850 {
851 int width, quanta;
852 int dynalloc_loop_logp;
853 int boost;
854 width = C*(eBands[i+1]-eBands[i])<<LM;
855 /* quanta is 6 bits, but no more than 1 bit/sample
856 and no less than 1/8 bit/sample */
857 quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
858 dynalloc_loop_logp = dynalloc_logp;
859 boost = 0;
860 while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
861 {
862 int flag;
863 flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
864 tell = ec_tell_frac(dec);
865 if (!flag)
866 break;
867 boost += quanta;
868 total_bits -= quanta;
869 dynalloc_loop_logp = 1;
870 }
871 offsets[i] = boost;
872 /* Making dynalloc more likely */
873 if (boost>0)
874 dynalloc_logp = IMAX(2, dynalloc_logp-1);
875 }
876
877 ALLOC(fine_quant, nbEBands, int);
878 alloc_trim = tell+(6<<BITRES) <= total_bits ?
879 ec_dec_icdf(dec, trim_icdf, 7) : 5;
880
881 bits = (((opus_int32)len*8)<<BITRES) - ec_tell_frac(dec) - 1;
882 anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
883 bits -= anti_collapse_rsv;
884
885 ALLOC(pulses, nbEBands, int);
886 ALLOC(fine_priority, nbEBands, int);
887
888 codedBands = compute_allocation(mode, st->start, st->end, offsets, cap,
889 alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
890 fine_quant, fine_priority, C, LM, dec, 0, 0, 0);
891
892 unquant_fine_energy(mode, st->start, st->end, oldBandE, fine_quant, dec, C);
893
894 /* Decode fixed codebook */
895 ALLOC(collapse_masks, C*nbEBands, unsigned char);
896 ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */
897
898 quant_all_bands(0, mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
899 NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res,
900 len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng);
901
902 if (anti_collapse_rsv > 0)
903 {
904 anti_collapse_on = ec_dec_bits(dec, 1);
905 }
906
907 unquant_energy_finalise(mode, st->start, st->end, oldBandE,
908 fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
909
910 if (anti_collapse_on)
911 anti_collapse(mode, X, collapse_masks, LM, C, N,
912 st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
913
914 ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
915
916 if (silence)
917 {
918 for (i=0;i<C*nbEBands;i++)
919 oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
920 for (i=0;i<C*N;i++)
921 freq[i] = 0;
922 } else {
923 /* Synthesis */
924 denormalise_bands(mode, X, freq, oldBandE, st->start, effEnd, C, M);
925 }
926 c=0; do {
927 OPUS_MOVE(decode_mem[c], decode_mem[c]+N, DECODE_BUFFER_SIZE-N+overlap/2);
928 } while (++c<CC);
929
930 c=0; do {
931 int bound = M*eBands[effEnd];
932 if (st->downsample!=1)
933 bound = IMIN(bound, N/st->downsample);
934 for (i=bound;i<N;i++)
935 freq[c*N+i] = 0;
936 } while (++c<C);
937
938 c=0; do {
939 out_syn[c] = decode_mem[c]+DECODE_BUFFER_SIZE-N;
940 } while (++c<CC);
941
942 if (CC==2&&C==1)
943 {
944 for (i=0;i<N;i++)
945 freq[N+i] = freq[i];
946 }
947 if (CC==1&&C==2)
948 {
949 for (i=0;i<N;i++)
950 freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
951 }
952
953 /* Compute inverse MDCTs */
954 compute_inv_mdcts(mode, shortBlocks, freq, out_syn, CC, LM);
955
956 c=0; do {
957 st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
958 st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
959 comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, mode->shortMdctSize,
960 st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
961 mode->window, overlap);
962 if (LM!=0)
963 comb_filter(out_syn[c]+mode->shortMdctSize, out_syn[c]+mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-mode->shortMdctSize,
964 st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
965 mode->window, overlap);
966
967 } while (++c<CC);
968 st->postfilter_period_old = st->postfilter_period;
969 st->postfilter_gain_old = st->postfilter_gain;
970 st->postfilter_tapset_old = st->postfilter_tapset;
971 st->postfilter_period = postfilter_pitch;
972 st->postfilter_gain = postfilter_gain;
973 st->postfilter_tapset = postfilter_tapset;
974 if (LM!=0)
975 {
976 st->postfilter_period_old = st->postfilter_period;
977 st->postfilter_gain_old = st->postfilter_gain;
978 st->postfilter_tapset_old = st->postfilter_tapset;
979 }
980
981 if (C==1) {
982 for (i=0;i<nbEBands;i++)
983 oldBandE[nbEBands+i]=oldBandE[i];
984 }
985
986 /* In case start or end were to change */
987 if (!isTransient)
988 {
989 for (i=0;i<2*nbEBands;i++)
990 oldLogE2[i] = oldLogE[i];
991 for (i=0;i<2*nbEBands;i++)
992 oldLogE[i] = oldBandE[i];
993 for (i=0;i<2*nbEBands;i++)
994 backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
995 } else {
996 for (i=0;i<2*nbEBands;i++)
997 oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
998 }
999 c=0; do
1000 {
1001 for (i=0;i<st->start;i++)
1002 {
1003 oldBandE[c*nbEBands+i]=0;
1004 oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1005 }
1006 for (i=st->end;i<nbEBands;i++)
1007 {
1008 oldBandE[c*nbEBands+i]=0;
1009 oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1010 }
1011 } while (++c<2);
1012 st->rng = dec->rng;
1013
1014 /* We reuse freq[] as scratch space for the de-emphasis */
1015 deemphasis(out_syn, pcm, N, CC, st->downsample, mode->preemph, st->preemph_memD, freq);
1016 st->loss_count = 0;
1017 RESTORE_STACK;
1018 if (ec_tell(dec) > 8*len)
1019 return OPUS_INTERNAL_ERROR;
1020 if(ec_get_error(dec))
1021 st->error = 1;
1022 return frame_size/st->downsample;
1023 }
1024
1025
1026 #ifdef CUSTOM_MODES
1027
1028 #ifdef FIXED_POINT
1029 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
1030 {
1031 return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
1032 }
1033
1034 #ifndef DISABLE_FLOAT_API
1035 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
1036 {
1037 int j, ret, C, N;
1038 VARDECL(opus_int16, out);
1039 ALLOC_STACK;
1040
1041 if (pcm==NULL)
1042 return OPUS_BAD_ARG;
1043
1044 C = st->channels;
1045 N = frame_size;
1046
1047 ALLOC(out, C*N, opus_int16);
1048 ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
1049 if (ret>0)
1050 for (j=0;j<C*ret;j++)
1051 pcm[j]=out[j]*(1.f/32768.f);
1052
1053 RESTORE_STACK;
1054 return ret;
1055 }
1056 #endif /* DISABLE_FLOAT_API */
1057
1058 #else
1059
1060 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
1061 {
1062 return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
1063 }
1064
1065 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
1066 {
1067 int j, ret, C, N;
1068 VARDECL(celt_sig, out);
1069 ALLOC_STACK;
1070
1071 if (pcm==NULL)
1072 return OPUS_BAD_ARG;
1073
1074 C = st->channels;
1075 N = frame_size;
1076 ALLOC(out, C*N, celt_sig);
1077
1078 ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
1079
1080 if (ret>0)
1081 for (j=0;j<C*ret;j++)
1082 pcm[j] = FLOAT2INT16 (out[j]);
1083
1084 RESTORE_STACK;
1085 return ret;
1086 }
1087
1088 #endif
1089 #endif /* CUSTOM_MODES */
1090
1091 int opus_custom_decoder_ctl(CELTDecoder * OPUS_RESTRICT st, int request, ...)
1092 {
1093 va_list ap;
1094
1095 va_start(ap, request);
1096 switch (request)
1097 {
1098 case CELT_SET_START_BAND_REQUEST:
1099 {
1100 opus_int32 value = va_arg(ap, opus_int32);
1101 if (value<0 || value>=st->mode->nbEBands)
1102 goto bad_arg;
1103 st->start = value;
1104 }
1105 break;
1106 case CELT_SET_END_BAND_REQUEST:
1107 {
1108 opus_int32 value = va_arg(ap, opus_int32);
1109 if (value<1 || value>st->mode->nbEBands)
1110 goto bad_arg;
1111 st->end = value;
1112 }
1113 break;
1114 case CELT_SET_CHANNELS_REQUEST:
1115 {
1116 opus_int32 value = va_arg(ap, opus_int32);
1117 if (value<1 || value>2)
1118 goto bad_arg;
1119 st->stream_channels = value;
1120 }
1121 break;
1122 case CELT_GET_AND_CLEAR_ERROR_REQUEST:
1123 {
1124 opus_int32 *value = va_arg(ap, opus_int32*);
1125 if (value==NULL)
1126 goto bad_arg;
1127 *value=st->error;
1128 st->error = 0;
1129 }
1130 break;
1131 case OPUS_GET_LOOKAHEAD_REQUEST:
1132 {
1133 opus_int32 *value = va_arg(ap, opus_int32*);
1134 if (value==NULL)
1135 goto bad_arg;
1136 *value = st->overlap/st->downsample;
1137 }
1138 break;
1139 case OPUS_RESET_STATE:
1140 {
1141 int i;
1142 opus_val16 *lpc, *oldBandE, *oldLogE, *oldLogE2;
1143 lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*st->channels);
1144 oldBandE = lpc+st->channels*LPC_ORDER;
1145 oldLogE = oldBandE + 2*st->mode->nbEBands;
1146 oldLogE2 = oldLogE + 2*st->mode->nbEBands;
1147 OPUS_CLEAR((char*)&st->DECODER_RESET_START,
1148 opus_custom_decoder_get_size(st->mode, st->channels)-
1149 ((char*)&st->DECODER_RESET_START - (char*)st));
1150 for (i=0;i<2*st->mode->nbEBands;i++)
1151 oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
1152 }
1153 break;
1154 case OPUS_GET_PITCH_REQUEST:
1155 {
1156 opus_int32 *value = va_arg(ap, opus_int32*);
1157 if (value==NULL)
1158 goto bad_arg;
1159 *value = st->postfilter_period;
1160 }
1161 break;
1162 case CELT_GET_MODE_REQUEST:
1163 {
1164 const CELTMode ** value = va_arg(ap, const CELTMode**);
1165 if (value==0)
1166 goto bad_arg;
1167 *value=st->mode;
1168 }
1169 break;
1170 case CELT_SET_SIGNALLING_REQUEST:
1171 {
1172 opus_int32 value = va_arg(ap, opus_int32);
1173 st->signalling = value;
1174 }
1175 break;
1176 case OPUS_GET_FINAL_RANGE_REQUEST:
1177 {
1178 opus_uint32 * value = va_arg(ap, opus_uint32 *);
1179 if (value==0)
1180 goto bad_arg;
1181 *value=st->rng;
1182 }
1183 break;
1184 default:
1185 goto bad_request;
1186 }
1187 va_end(ap);
1188 return OPUS_OK;
1189 bad_arg:
1190 va_end(ap);
1191 return OPUS_BAD_ARG;
1192 bad_request:
1193 va_end(ap);
1194 return OPUS_UNIMPLEMENTED;
1195 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial