diff options
Diffstat (limited to 'lib/rbcodec/codecs/libopus/celt/celt.c')
-rw-r--r-- | lib/rbcodec/codecs/libopus/celt/celt.c | 2860 |
1 files changed, 77 insertions, 2783 deletions
diff --git a/lib/rbcodec/codecs/libopus/celt/celt.c b/lib/rbcodec/codecs/libopus/celt/celt.c index 52a66d1b68..3e0ce6e6a5 100644 --- a/lib/rbcodec/codecs/libopus/celt/celt.c +++ b/lib/rbcodec/codecs/libopus/celt/celt.c | |||
@@ -28,7 +28,7 @@ | |||
28 | */ | 28 | */ |
29 | 29 | ||
30 | #ifdef HAVE_CONFIG_H | 30 | #ifdef HAVE_CONFIG_H |
31 | #include "opus_config.h" | 31 | #include "config.h" |
32 | #endif | 32 | #endif |
33 | 33 | ||
34 | #define CELT_C | 34 | #define CELT_C |
@@ -50,62 +50,12 @@ | |||
50 | #include "celt_lpc.h" | 50 | #include "celt_lpc.h" |
51 | #include "vq.h" | 51 | #include "vq.h" |
52 | 52 | ||
53 | #ifndef OPUS_VERSION | 53 | #ifndef PACKAGE_VERSION |
54 | #define OPUS_VERSION "unknown" | 54 | #define PACKAGE_VERSION "unknown" |
55 | #endif | 55 | #endif |
56 | 56 | ||
57 | #ifdef CUSTOM_MODES | ||
58 | #define OPUS_CUSTOM_NOSTATIC | ||
59 | #else | ||
60 | #define OPUS_CUSTOM_NOSTATIC static inline | ||
61 | #endif | ||
62 | |||
63 | static const unsigned char trim_icdf[11] = {126, 124, 119, 109, 87, 41, 19, 9, 4, 2, 0}; | ||
64 | /* Probs: NONE: 21.875%, LIGHT: 6.25%, NORMAL: 65.625%, AGGRESSIVE: 6.25% */ | ||
65 | static const unsigned char spread_icdf[4] = {25, 23, 2, 0}; | ||
66 | |||
67 | static const unsigned char tapset_icdf[3]={2,1,0}; | ||
68 | |||
69 | #ifdef CUSTOM_MODES | ||
70 | static const unsigned char toOpusTable[20] = { | ||
71 | 0xE0, 0xE8, 0xF0, 0xF8, | ||
72 | 0xC0, 0xC8, 0xD0, 0xD8, | ||
73 | 0xA0, 0xA8, 0xB0, 0xB8, | ||
74 | 0x00, 0x00, 0x00, 0x00, | ||
75 | 0x80, 0x88, 0x90, 0x98, | ||
76 | }; | ||
77 | |||
78 | static const unsigned char fromOpusTable[16] = { | ||
79 | 0x80, 0x88, 0x90, 0x98, | ||
80 | 0x40, 0x48, 0x50, 0x58, | ||
81 | 0x20, 0x28, 0x30, 0x38, | ||
82 | 0x00, 0x08, 0x10, 0x18 | ||
83 | }; | ||
84 | |||
85 | static inline int toOpus(unsigned char c) | ||
86 | { | ||
87 | int ret=0; | ||
88 | if (c<0xA0) | ||
89 | ret = toOpusTable[c>>3]; | ||
90 | if (ret == 0) | ||
91 | return -1; | ||
92 | else | ||
93 | return ret|(c&0x7); | ||
94 | } | ||
95 | 57 | ||
96 | static inline int fromOpus(unsigned char c) | 58 | int resampling_factor(opus_int32 rate) |
97 | { | ||
98 | if (c<0x80) | ||
99 | return -1; | ||
100 | else | ||
101 | return fromOpusTable[(c>>3)-16] | (c&0x7); | ||
102 | } | ||
103 | #endif /* CUSTOM_MODES */ | ||
104 | |||
105 | #define COMBFILTER_MAXPERIOD 1024 | ||
106 | #define COMBFILTER_MINPERIOD 15 | ||
107 | |||
108 | static int resampling_factor(opus_int32 rate) | ||
109 | { | 59 | { |
110 | int ret; | 60 | int ret; |
111 | switch (rate) | 61 | switch (rate) |
@@ -135,693 +85,101 @@ static int resampling_factor(opus_int32 rate) | |||
135 | return ret; | 85 | return ret; |
136 | } | 86 | } |
137 | 87 | ||
138 | /** Encoder state | 88 | #ifndef OVERRIDE_COMB_FILTER_CONST |
139 | @brief Encoder state | 89 | static void comb_filter_const(opus_val32 *y, opus_val32 *x, int T, int N, |
140 | */ | 90 | opus_val16 g10, opus_val16 g11, opus_val16 g12) |
141 | struct OpusCustomEncoder { | ||
142 | const OpusCustomMode *mode; /**< Mode used by the encoder */ | ||
143 | int overlap; | ||
144 | int channels; | ||
145 | int stream_channels; | ||
146 | |||
147 | int force_intra; | ||
148 | int clip; | ||
149 | int disable_pf; | ||
150 | int complexity; | ||
151 | int upsample; | ||
152 | int start, end; | ||
153 | |||
154 | opus_int32 bitrate; | ||
155 | int vbr; | ||
156 | int signalling; | ||
157 | int constrained_vbr; /* If zero, VBR can do whatever it likes with the rate */ | ||
158 | int loss_rate; | ||
159 | int lsb_depth; | ||
160 | |||
161 | /* Everything beyond this point gets cleared on a reset */ | ||
162 | #define ENCODER_RESET_START rng | ||
163 | |||
164 | opus_uint32 rng; | ||
165 | int spread_decision; | ||
166 | opus_val32 delayedIntra; | ||
167 | int tonal_average; | ||
168 | int lastCodedBands; | ||
169 | int hf_average; | ||
170 | int tapset_decision; | ||
171 | |||
172 | int prefilter_period; | ||
173 | opus_val16 prefilter_gain; | ||
174 | int prefilter_tapset; | ||
175 | #ifdef RESYNTH | ||
176 | int prefilter_period_old; | ||
177 | opus_val16 prefilter_gain_old; | ||
178 | int prefilter_tapset_old; | ||
179 | #endif | ||
180 | int consec_transient; | ||
181 | |||
182 | opus_val32 preemph_memE[2]; | ||
183 | opus_val32 preemph_memD[2]; | ||
184 | |||
185 | /* VBR-related parameters */ | ||
186 | opus_int32 vbr_reservoir; | ||
187 | opus_int32 vbr_drift; | ||
188 | opus_int32 vbr_offset; | ||
189 | opus_int32 vbr_count; | ||
190 | |||
191 | #ifdef RESYNTH | ||
192 | celt_sig syn_mem[2][2*MAX_PERIOD]; | ||
193 | #endif | ||
194 | |||
195 | celt_sig in_mem[1]; /* Size = channels*mode->overlap */ | ||
196 | /* celt_sig prefilter_mem[], Size = channels*COMBFILTER_PERIOD */ | ||
197 | /* celt_sig overlap_mem[], Size = channels*mode->overlap */ | ||
198 | /* opus_val16 oldEBands[], Size = 2*channels*mode->nbEBands */ | ||
199 | }; | ||
200 | |||
201 | #if 0 | ||
202 | int celt_encoder_get_size(int channels) | ||
203 | { | ||
204 | CELTMode *mode = opus_custom_mode_create(48000, 960, NULL); | ||
205 | return opus_custom_encoder_get_size(mode, channels); | ||
206 | } | ||
207 | |||
208 | OPUS_CUSTOM_NOSTATIC int opus_custom_encoder_get_size(const CELTMode *mode, int channels) | ||
209 | { | ||
210 | int size = sizeof(struct CELTEncoder) | ||
211 | + (2*channels*mode->overlap-1)*sizeof(celt_sig) | ||
212 | + channels*COMBFILTER_MAXPERIOD*sizeof(celt_sig) | ||
213 | + 3*channels*mode->nbEBands*sizeof(opus_val16); | ||
214 | return size; | ||
215 | } | ||
216 | |||
217 | #ifdef CUSTOM_MODES | ||
218 | CELTEncoder *opus_custom_encoder_create(const CELTMode *mode, int channels, int *error) | ||
219 | { | ||
220 | int ret; | ||
221 | CELTEncoder *st = (CELTEncoder *)opus_alloc(opus_custom_encoder_get_size(mode, channels)); | ||
222 | /* init will handle the NULL case */ | ||
223 | ret = opus_custom_encoder_init(st, mode, channels); | ||
224 | if (ret != OPUS_OK) | ||
225 | { | ||
226 | opus_custom_encoder_destroy(st); | ||
227 | st = NULL; | ||
228 | } | ||
229 | if (error) | ||
230 | *error = ret; | ||
231 | return st; | ||
232 | } | ||
233 | #endif /* CUSTOM_MODES */ | ||
234 | |||
235 | int celt_encoder_init(CELTEncoder *st, opus_int32 sampling_rate, int channels) | ||
236 | { | ||
237 | int ret; | ||
238 | ret = opus_custom_encoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels); | ||
239 | if (ret != OPUS_OK) | ||
240 | return ret; | ||
241 | st->upsample = resampling_factor(sampling_rate); | ||
242 | return OPUS_OK; | ||
243 | } | ||
244 | |||
245 | OPUS_CUSTOM_NOSTATIC int opus_custom_encoder_init(CELTEncoder *st, const CELTMode *mode, int channels) | ||
246 | { | ||
247 | if (channels < 0 || channels > 2) | ||
248 | return OPUS_BAD_ARG; | ||
249 | |||
250 | if (st==NULL || mode==NULL) | ||
251 | return OPUS_ALLOC_FAIL; | ||
252 | |||
253 | OPUS_CLEAR((char*)st, opus_custom_encoder_get_size(mode, channels)); | ||
254 | |||
255 | st->mode = mode; | ||
256 | st->overlap = mode->overlap; | ||
257 | st->stream_channels = st->channels = channels; | ||
258 | |||
259 | st->upsample = 1; | ||
260 | st->start = 0; | ||
261 | st->end = st->mode->effEBands; | ||
262 | st->signalling = 1; | ||
263 | |||
264 | st->constrained_vbr = 1; | ||
265 | st->clip = 1; | ||
266 | |||
267 | st->bitrate = OPUS_BITRATE_MAX; | ||
268 | st->vbr = 0; | ||
269 | st->force_intra = 0; | ||
270 | st->complexity = 5; | ||
271 | st->lsb_depth=24; | ||
272 | |||
273 | opus_custom_encoder_ctl(st, OPUS_RESET_STATE); | ||
274 | |||
275 | return OPUS_OK; | ||
276 | } | ||
277 | |||
278 | #ifdef CUSTOM_MODES | ||
279 | void opus_custom_encoder_destroy(CELTEncoder *st) | ||
280 | { | ||
281 | opus_free(st); | ||
282 | } | ||
283 | #endif /* CUSTOM_MODES */ | ||
284 | #endif | ||
285 | |||
286 | static inline opus_val16 SIG2WORD16(celt_sig x) | ||
287 | { | ||
288 | #ifdef FIXED_POINT | ||
289 | x = PSHR32(x, SIG_SHIFT); | ||
290 | x = MAX32(x, -32768); | ||
291 | x = MIN32(x, 32767); | ||
292 | return EXTRACT16(x); | ||
293 | #else | ||
294 | return (opus_val16)x; | ||
295 | #endif | ||
296 | } | ||
297 | |||
298 | #if 0 | ||
299 | static int transient_analysis(const opus_val32 * OPUS_RESTRICT in, int len, int C, | ||
300 | int overlap) | ||
301 | { | 91 | { |
92 | opus_val32 x0, x1, x2, x3, x4; | ||
302 | int i; | 93 | int i; |
303 | VARDECL(opus_val16, tmp); | 94 | x4 = x[-T-2]; |
304 | opus_val32 mem0=0,mem1=0; | 95 | x3 = x[-T-1]; |
305 | int is_transient = 0; | 96 | x2 = x[-T]; |
306 | int block; | 97 | x1 = x[-T+1]; |
307 | int N; | ||
308 | VARDECL(opus_val16, bins); | ||
309 | SAVE_STACK; | ||
310 | ALLOC(tmp, len, opus_val16); | ||
311 | |||
312 | block = overlap/2; | ||
313 | N=len/block; | ||
314 | ALLOC(bins, N, opus_val16); | ||
315 | if (C==1) | ||
316 | { | ||
317 | for (i=0;i<len;i++) | ||
318 | tmp[i] = SHR32(in[i],SIG_SHIFT); | ||
319 | } else { | ||
320 | for (i=0;i<len;i++) | ||
321 | tmp[i] = SHR32(ADD32(in[i],in[i+len]), SIG_SHIFT+1); | ||
322 | } | ||
323 | |||
324 | /* High-pass filter: (1 - 2*z^-1 + z^-2) / (1 - z^-1 + .5*z^-2) */ | ||
325 | for (i=0;i<len;i++) | ||
326 | { | ||
327 | opus_val32 x,y; | ||
328 | x = tmp[i]; | ||
329 | y = ADD32(mem0, x); | ||
330 | #ifdef FIXED_POINT | ||
331 | mem0 = mem1 + y - SHL32(x,1); | ||
332 | mem1 = x - SHR32(y,1); | ||
333 | #else | ||
334 | mem0 = mem1 + y - 2*x; | ||
335 | mem1 = x - .5f*y; | ||
336 | #endif | ||
337 | tmp[i] = EXTRACT16(SHR32(y,2)); | ||
338 | } | ||
339 | /* First few samples are bad because we don't propagate the memory */ | ||
340 | for (i=0;i<12;i++) | ||
341 | tmp[i] = 0; | ||
342 | |||
343 | for (i=0;i<N;i++) | 98 | for (i=0;i<N;i++) |
344 | { | 99 | { |
345 | int j; | 100 | x0=x[i-T+2]; |
346 | opus_val16 max_abs=0; | 101 | y[i] = x[i] |
347 | for (j=0;j<block;j++) | 102 | + MULT16_32_Q15(g10,x2) |
348 | max_abs = MAX16(max_abs, ABS16(tmp[i*block+j])); | 103 | + MULT16_32_Q15(g11,ADD32(x1,x3)) |
349 | bins[i] = max_abs; | 104 | + MULT16_32_Q15(g12,ADD32(x0,x4)); |
350 | } | 105 | x4=x3; |
351 | for (i=0;i<N;i++) | 106 | x3=x2; |
352 | { | 107 | x2=x1; |
353 | int j; | 108 | x1=x0; |
354 | int conseq=0; | ||
355 | opus_val16 t1, t2, t3; | ||
356 | |||
357 | t1 = MULT16_16_Q15(QCONST16(.15f, 15), bins[i]); | ||
358 | t2 = MULT16_16_Q15(QCONST16(.4f, 15), bins[i]); | ||
359 | t3 = MULT16_16_Q15(QCONST16(.15f, 15), bins[i]); | ||
360 | for (j=0;j<i;j++) | ||
361 | { | ||
362 | if (bins[j] < t1) | ||
363 | conseq++; | ||
364 | if (bins[j] < t2) | ||
365 | conseq++; | ||
366 | else | ||
367 | conseq = 0; | ||
368 | } | ||
369 | if (conseq>=3) | ||
370 | is_transient=1; | ||
371 | conseq = 0; | ||
372 | for (j=i+1;j<N;j++) | ||
373 | { | ||
374 | if (bins[j] < t3) | ||
375 | conseq++; | ||
376 | else | ||
377 | conseq = 0; | ||
378 | } | ||
379 | if (conseq>=7) | ||
380 | is_transient=1; | ||
381 | } | ||
382 | RESTORE_STACK; | ||
383 | #ifdef FUZZING | ||
384 | is_transient = rand()&0x1; | ||
385 | #endif | ||
386 | return is_transient; | ||
387 | } | ||
388 | |||
389 | /** Apply window and compute the MDCT for all sub-frames and | ||
390 | all channels in a frame */ | ||
391 | static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig * OPUS_RESTRICT in, celt_sig * OPUS_RESTRICT out, int C, int LM) | ||
392 | { | ||
393 | if (C==1 && !shortBlocks) | ||
394 | { | ||
395 | const int overlap = OVERLAP(mode); | ||
396 | clt_mdct_forward(&mode->mdct, in, out, mode->window, overlap, mode->maxLM-LM, 1); | ||
397 | } else { | ||
398 | const int overlap = OVERLAP(mode); | ||
399 | int N = mode->shortMdctSize<<LM; | ||
400 | int B = 1; | ||
401 | int b, c; | ||
402 | if (shortBlocks) | ||
403 | { | ||
404 | N = mode->shortMdctSize; | ||
405 | B = shortBlocks; | ||
406 | } | ||
407 | c=0; do { | ||
408 | for (b=0;b<B;b++) | ||
409 | { | ||
410 | /* Interleaving the sub-frames while doing the MDCTs */ | ||
411 | clt_mdct_forward(&mode->mdct, in+c*(B*N+overlap)+b*N, &out[b+c*N*B], mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM, B); | ||
412 | } | ||
413 | } while (++c<C); | ||
414 | } | 109 | } |
415 | } | ||
416 | #endif | ||
417 | |||
418 | /** Compute the IMDCT and apply window for all sub-frames and | ||
419 | all channels in a frame */ | ||
420 | static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X, | ||
421 | celt_sig * OPUS_RESTRICT out_mem[], | ||
422 | celt_sig * OPUS_RESTRICT overlap_mem[], int C, int LM) | ||
423 | { | ||
424 | int c; | ||
425 | const int N = mode->shortMdctSize<<LM; | ||
426 | const int overlap = OVERLAP(mode); | ||
427 | VARDECL(opus_val32, x); | ||
428 | SAVE_STACK; | ||
429 | 110 | ||
430 | ALLOC(x, N+overlap, opus_val32); | ||
431 | c=0; do { | ||
432 | int j; | ||
433 | int b; | ||
434 | int N2 = N; | ||
435 | int B = 1; | ||
436 | |||
437 | if (shortBlocks) | ||
438 | { | ||
439 | N2 = mode->shortMdctSize; | ||
440 | B = shortBlocks; | ||
441 | } | ||
442 | /* Prevents problems from the imdct doing the overlap-add */ | ||
443 | OPUS_CLEAR(x, overlap); | ||
444 | |||
445 | for (b=0;b<B;b++) | ||
446 | { | ||
447 | /* IMDCT on the interleaved the sub-frames */ | ||
448 | clt_mdct_backward(&mode->mdct, &X[b+c*N2*B], x+N2*b, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM, B); | ||
449 | } | ||
450 | |||
451 | /* overlap can be divided by 4 */ | ||
452 | for (j=0;j<overlap;j+=4) | ||
453 | { | ||
454 | out_mem[c][j ] = x[j ] + overlap_mem[c][j ]; | ||
455 | out_mem[c][j+1] = x[j+1] + overlap_mem[c][j+1]; | ||
456 | out_mem[c][j+2] = x[j+2] + overlap_mem[c][j+2]; | ||
457 | out_mem[c][j+3] = x[j+3] + overlap_mem[c][j+3]; | ||
458 | } | ||
459 | OPUS_COPY(out_mem[c]+overlap, x+overlap, N-overlap); | ||
460 | OPUS_COPY(overlap_mem[c] , x+N , overlap); | ||
461 | } while (++c<C); | ||
462 | RESTORE_STACK; | ||
463 | } | 111 | } |
464 | |||
465 | static void deemphasis(celt_sig *in[], opus_val16 *pcm, int N, int C, /* int downsample,*/ const opus_val16 *coef, celt_sig *mem) | ||
466 | { | ||
467 | int c; | ||
468 | /* int count=0;*/ | ||
469 | c=0; do { | ||
470 | int j; | ||
471 | celt_sig * OPUS_RESTRICT x; | ||
472 | opus_val16 * OPUS_RESTRICT y; | ||
473 | opus_val16 coef0 = coef[0]; | ||
474 | #ifdef CUSTOM_MODES | ||
475 | opus_val16 coef1 = coef[1]; | ||
476 | opus_val16 coef3 = coef[3]; | ||
477 | #endif | 112 | #endif |
478 | celt_sig m = mem[c]; | ||
479 | x =in[c]; | ||
480 | y = pcm+c; | ||
481 | for (j=0;j<N;j++) | ||
482 | { | ||
483 | celt_sig tmp = *x + m; | ||
484 | m = MULT16_32_Q15(coef0, tmp); | ||
485 | #ifdef CUSTOM_MODES | ||
486 | m -= MULT16_32_Q15(coef1, *x); | ||
487 | tmp = SHL32(MULT16_32_Q15(coef3, tmp), 2); | ||
488 | #endif | ||
489 | x++; | ||
490 | /* Technically the store could be moved outside of the if because | ||
491 | the stores we don't want will just be overwritten */ | ||
492 | /* ROCKBOX: we don't downsample | ||
493 | if (count==0) */ | ||
494 | *y = SCALEOUT(SIG2WORD16(tmp)); | ||
495 | /* if (++count==downsample) */ | ||
496 | { | ||
497 | y+=C; | ||
498 | /* count=0; */ | ||
499 | } | ||
500 | } | ||
501 | mem[c] = m; | ||
502 | } while (++c<C); | ||
503 | } | ||
504 | 113 | ||
505 | static void comb_filter(opus_val32 *y, opus_val32 *x, int T0, int T1, int N, | 114 | void comb_filter(opus_val32 *y, opus_val32 *x, int T0, int T1, int N, |
506 | opus_val16 g0, opus_val16 g1, int tapset0, int tapset1, | 115 | opus_val16 g0, opus_val16 g1, int tapset0, int tapset1, |
507 | const opus_val16 *window, int overlap) | 116 | const opus_val16 *window, int overlap) |
508 | { | 117 | { |
509 | /* Multiply-adds are only needed if g0 or g1 are non-zero. In all other cases a simple | 118 | int i; |
510 | * copy of vector x to y is possible. */ | 119 | /* printf ("%d %d %f %f\n", T0, T1, g0, g1); */ |
511 | if (g0!=0 || g1!=0) | 120 | opus_val16 g00, g01, g02, g10, g11, g12; |
512 | { | 121 | opus_val32 x0, x1, x2, x3, x4; |
513 | int i; | 122 | static const opus_val16 gains[3][3] = { |
514 | opus_val16 g00, g01, g02, g10, g11, g12, idx0, idx1; | ||
515 | static const opus_val16 gains[3][3] = { | ||
516 | {QCONST16(0.3066406250f, 15), QCONST16(0.2170410156f, 15), QCONST16(0.1296386719f, 15)}, | 123 | {QCONST16(0.3066406250f, 15), QCONST16(0.2170410156f, 15), QCONST16(0.1296386719f, 15)}, |
517 | {QCONST16(0.4638671875f, 15), QCONST16(0.2680664062f, 15), QCONST16(0.f, 15)}, | 124 | {QCONST16(0.4638671875f, 15), QCONST16(0.2680664062f, 15), QCONST16(0.f, 15)}, |
518 | {QCONST16(0.7998046875f, 15), QCONST16(0.1000976562f, 15), QCONST16(0.f, 15)}}; | 125 | {QCONST16(0.7998046875f, 15), QCONST16(0.1000976562f, 15), QCONST16(0.f, 15)}}; |
519 | g00 = MULT16_16_Q15(g0, gains[tapset0][0]); | ||
520 | g01 = MULT16_16_Q15(g0, gains[tapset0][1]); | ||
521 | g02 = MULT16_16_Q15(g0, gains[tapset0][2]); | ||
522 | g10 = MULT16_16_Q15(g1, gains[tapset1][0]); | ||
523 | g11 = MULT16_16_Q15(g1, gains[tapset1][1]); | ||
524 | g12 = MULT16_16_Q15(g1, gains[tapset1][2]); | ||
525 | /* printf("g0 %d g1 %d\n", g0,g1); */ | ||
526 | idx0 = -T0; | ||
527 | idx1 = -T1; | ||
528 | for (i=0;i<overlap;i++,idx0++,idx1++) | ||
529 | { | ||
530 | opus_val16 f0, f1; | ||
531 | f1 = MULT16_16_Q15(window[i],window[i]); | ||
532 | f0 = Q15ONE - f1; | ||
533 | y[i] = x[i] | ||
534 | + MULT16_32_Q15(MULT16_16_Q15(f0,g02), x[idx0-2]) | ||
535 | + MULT16_32_Q15(MULT16_16_Q15(f0,g01), x[idx0-1]) | ||
536 | + MULT16_32_Q15(MULT16_16_Q15(f0,g00), x[idx0 ]) | ||
537 | + MULT16_32_Q15(MULT16_16_Q15(f0,g01), x[idx0+1]) | ||
538 | + MULT16_32_Q15(MULT16_16_Q15(f0,g02), x[idx0+2]) | ||
539 | + MULT16_32_Q15(MULT16_16_Q15(f1,g12), x[idx1-2]) | ||
540 | + MULT16_32_Q15(MULT16_16_Q15(f1,g11), x[idx1-1]) | ||
541 | + MULT16_32_Q15(MULT16_16_Q15(f1,g10), x[idx1 ]) | ||
542 | + MULT16_32_Q15(MULT16_16_Q15(f1,g11), x[idx1+1]) | ||
543 | + MULT16_32_Q15(MULT16_16_Q15(f1,g12), x[idx1+2]); | ||
544 | } | ||
545 | /* No multiply-add required if g1=0 as all multiplicants are =0. */ | ||
546 | if (g1!=0) | ||
547 | { | ||
548 | idx1 = overlap-T1; | ||
549 | for (i=overlap;i<N;i++,idx1++) | ||
550 | { | ||
551 | y[i] = x[i] | ||
552 | + MULT16_32_Q15(g12, x[idx1-2]) | ||
553 | + MULT16_32_Q15(g11, x[idx1-1]) | ||
554 | + MULT16_32_Q15(g10, x[idx1 ]) | ||
555 | + MULT16_32_Q15(g11, x[idx1+1]) | ||
556 | + MULT16_32_Q15(g12, x[idx1+2]); | ||
557 | } | ||
558 | } | ||
559 | /* Only perform vector copy if source and destination are not same. */ | ||
560 | else if (x != y) | ||
561 | { | ||
562 | /* Copy part of vector from x[overlap..N] to y[overlap..N] */ | ||
563 | OPUS_COPY(y+overlap, x+overlap, N-overlap); | ||
564 | } | ||
565 | } | ||
566 | /* Only perform vector copy if source and destination are not same. */ | ||
567 | else if (x != y) | ||
568 | { | ||
569 | /* Copy full vector from x[0..N] to y[0..N] */ | ||
570 | OPUS_COPY(y, x, N); | ||
571 | } | ||
572 | } | ||
573 | 126 | ||
574 | static const signed char tf_select_table[4][8] = { | 127 | if (g0==0 && g1==0) |
128 | { | ||
129 | /* OPT: Happens to work without the OPUS_MOVE(), but only because the current encoder already copies x to y */ | ||
130 | if (x!=y) | ||
131 | OPUS_MOVE(y, x, N); | ||
132 | return; | ||
133 | } | ||
134 | g00 = MULT16_16_Q15(g0, gains[tapset0][0]); | ||
135 | g01 = MULT16_16_Q15(g0, gains[tapset0][1]); | ||
136 | g02 = MULT16_16_Q15(g0, gains[tapset0][2]); | ||
137 | g10 = MULT16_16_Q15(g1, gains[tapset1][0]); | ||
138 | g11 = MULT16_16_Q15(g1, gains[tapset1][1]); | ||
139 | g12 = MULT16_16_Q15(g1, gains[tapset1][2]); | ||
140 | x1 = x[-T1+1]; | ||
141 | x2 = x[-T1 ]; | ||
142 | x3 = x[-T1-1]; | ||
143 | x4 = x[-T1-2]; | ||
144 | for (i=0;i<overlap;i++) | ||
145 | { | ||
146 | opus_val16 f; | ||
147 | x0=x[i-T1+2]; | ||
148 | f = MULT16_16_Q15(window[i],window[i]); | ||
149 | y[i] = x[i] | ||
150 | + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g00),x[i-T0]) | ||
151 | + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),ADD32(x[i-T0+1],x[i-T0-1])) | ||
152 | + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),ADD32(x[i-T0+2],x[i-T0-2])) | ||
153 | + MULT16_32_Q15(MULT16_16_Q15(f,g10),x2) | ||
154 | + MULT16_32_Q15(MULT16_16_Q15(f,g11),ADD32(x1,x3)) | ||
155 | + MULT16_32_Q15(MULT16_16_Q15(f,g12),ADD32(x0,x4)); | ||
156 | x4=x3; | ||
157 | x3=x2; | ||
158 | x2=x1; | ||
159 | x1=x0; | ||
160 | |||
161 | } | ||
162 | if (g1==0) | ||
163 | { | ||
164 | /* OPT: Happens to work without the OPUS_MOVE(), but only because the current encoder already copies x to y */ | ||
165 | if (x!=y) | ||
166 | OPUS_MOVE(y+overlap, x+overlap, N-overlap); | ||
167 | return; | ||
168 | } | ||
169 | |||
170 | /* Compute the part with the constant filter. */ | ||
171 | comb_filter_const(y+i, x+i, T1, N-i, g10, g11, g12); | ||
172 | } | ||
173 | |||
174 | const signed char tf_select_table[4][8] = { | ||
575 | {0, -1, 0, -1, 0,-1, 0,-1}, | 175 | {0, -1, 0, -1, 0,-1, 0,-1}, |
576 | {0, -1, 0, -2, 1, 0, 1,-1}, | 176 | {0, -1, 0, -2, 1, 0, 1,-1}, |
577 | {0, -2, 0, -3, 2, 0, 1,-1}, | 177 | {0, -2, 0, -3, 2, 0, 1,-1}, |
578 | {0, -2, 0, -3, 3, 0, 1,-1}, | 178 | {0, -2, 0, -3, 3, 0, 1,-1}, |
579 | }; | 179 | }; |
580 | 180 | ||
581 | #if 0 | ||
582 | static opus_val32 l1_metric(const celt_norm *tmp, int N, int LM, int width) | ||
583 | { | ||
584 | int i, j; | ||
585 | static const opus_val16 sqrtM_1[4] = {Q15ONE, QCONST16(.70710678f,15), QCONST16(0.5f,15), QCONST16(0.35355339f,15)}; | ||
586 | opus_val32 L1; | ||
587 | opus_val16 bias; | ||
588 | L1=0; | ||
589 | for (i=0;i<1<<LM;i++) | ||
590 | { | ||
591 | opus_val32 L2 = 0; | ||
592 | for (j=0;j<N>>LM;j++) | ||
593 | L2 = MAC16_16(L2, tmp[(j<<LM)+i], tmp[(j<<LM)+i]); | ||
594 | L1 += celt_sqrt(L2); | ||
595 | } | ||
596 | L1 = MULT16_32_Q15(sqrtM_1[LM], L1); | ||
597 | if (width==1) | ||
598 | bias = QCONST16(.12f,15)*LM; | ||
599 | else if (width==2) | ||
600 | bias = QCONST16(.05f,15)*LM; | ||
601 | else | ||
602 | bias = QCONST16(.02f,15)*LM; | ||
603 | L1 = MAC16_32_Q15(L1, bias, L1); | ||
604 | return L1; | ||
605 | } | ||
606 | 181 | ||
607 | static int tf_analysis(const CELTMode *m, int len, int C, int isTransient, | 182 | void init_caps(const CELTMode *m,int *cap,int LM,int C) |
608 | int *tf_res, int nbCompressedBytes, celt_norm *X, int N0, int LM, | ||
609 | int *tf_sum) | ||
610 | { | ||
611 | int i; | ||
612 | VARDECL(int, metric); | ||
613 | int cost0; | ||
614 | int cost1; | ||
615 | VARDECL(int, path0); | ||
616 | VARDECL(int, path1); | ||
617 | VARDECL(celt_norm, tmp); | ||
618 | int lambda; | ||
619 | int tf_select=0; | ||
620 | SAVE_STACK; | ||
621 | |||
622 | if (nbCompressedBytes<15*C) | ||
623 | { | ||
624 | *tf_sum = 0; | ||
625 | for (i=0;i<len;i++) | ||
626 | tf_res[i] = isTransient; | ||
627 | return 0; | ||
628 | } | ||
629 | if (nbCompressedBytes<40) | ||
630 | lambda = 12; | ||
631 | else if (nbCompressedBytes<60) | ||
632 | lambda = 6; | ||
633 | else if (nbCompressedBytes<100) | ||
634 | lambda = 4; | ||
635 | else | ||
636 | lambda = 3; | ||
637 | |||
638 | ALLOC(metric, len, int); | ||
639 | ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm); | ||
640 | ALLOC(path0, len, int); | ||
641 | ALLOC(path1, len, int); | ||
642 | |||
643 | *tf_sum = 0; | ||
644 | for (i=0;i<len;i++) | ||
645 | { | ||
646 | int j, k, N; | ||
647 | opus_val32 L1, best_L1; | ||
648 | int best_level=0; | ||
649 | N = (m->eBands[i+1]-m->eBands[i])<<LM; | ||
650 | for (j=0;j<N;j++) | ||
651 | tmp[j] = X[j+(m->eBands[i]<<LM)]; | ||
652 | /* Just add the right channel if we're in stereo */ | ||
653 | if (C==2) | ||
654 | for (j=0;j<N;j++) | ||
655 | tmp[j] = ADD16(SHR16(tmp[j], 1),SHR16(X[N0+j+(m->eBands[i]<<LM)], 1)); | ||
656 | L1 = l1_metric(tmp, N, isTransient ? LM : 0, N>>LM); | ||
657 | best_L1 = L1; | ||
658 | /*printf ("%f ", L1);*/ | ||
659 | for (k=0;k<LM;k++) | ||
660 | { | ||
661 | int B; | ||
662 | |||
663 | if (isTransient) | ||
664 | B = (LM-k-1); | ||
665 | else | ||
666 | B = k+1; | ||
667 | |||
668 | if (isTransient) | ||
669 | haar1(tmp, N>>(LM-k), 1<<(LM-k)); | ||
670 | else | ||
671 | haar1(tmp, N>>k, 1<<k); | ||
672 | |||
673 | L1 = l1_metric(tmp, N, B, N>>LM); | ||
674 | |||
675 | if (L1 < best_L1) | ||
676 | { | ||
677 | best_L1 = L1; | ||
678 | best_level = k+1; | ||
679 | } | ||
680 | } | ||
681 | /*printf ("%d ", isTransient ? LM-best_level : best_level);*/ | ||
682 | if (isTransient) | ||
683 | metric[i] = best_level; | ||
684 | else | ||
685 | metric[i] = -best_level; | ||
686 | *tf_sum += metric[i]; | ||
687 | } | ||
688 | /*printf("\n");*/ | ||
689 | /* NOTE: Future optimized implementations could detect extreme transients and set | ||
690 | tf_select = 1 but so far we have not found a reliable way of making this useful */ | ||
691 | tf_select = 0; | ||
692 | |||
693 | cost0 = 0; | ||
694 | cost1 = 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 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+0]); | ||
723 | cost1 = curr1 + abs(metric[i]-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 | RESTORE_STACK; | ||
735 | #ifdef FUZZING | ||
736 | tf_select = rand()&0x1; | ||
737 | tf_res[0] = rand()&0x1; | ||
738 | for (i=1;i<len;i++) | ||
739 | tf_res[i] = tf_res[i-1] ^ ((rand()&0xF) == 0); | ||
740 | #endif | ||
741 | return tf_select; | ||
742 | } | ||
743 | |||
744 | static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM, int tf_select, ec_enc *enc) | ||
745 | { | ||
746 | int curr, i; | ||
747 | int tf_select_rsv; | ||
748 | int tf_changed; | ||
749 | int logp; | ||
750 | opus_uint32 budget; | ||
751 | opus_uint32 tell; | ||
752 | budget = enc->storage*8; | ||
753 | tell = ec_tell(enc); | ||
754 | logp = isTransient ? 2 : 4; | ||
755 | /* Reserve space to code the tf_select decision. */ | ||
756 | tf_select_rsv = LM>0 && tell+logp+1 <= budget; | ||
757 | budget -= tf_select_rsv; | ||
758 | curr = tf_changed = 0; | ||
759 | for (i=start;i<end;i++) | ||
760 | { | ||
761 | if (tell+logp<=budget) | ||
762 | { | ||
763 | ec_enc_bit_logp(enc, tf_res[i] ^ curr, logp); | ||
764 | tell = ec_tell(enc); | ||
765 | curr = tf_res[i]; | ||
766 | tf_changed |= curr; | ||
767 | } | ||
768 | else | ||
769 | tf_res[i] = curr; | ||
770 | logp = isTransient ? 4 : 5; | ||
771 | } | ||
772 | /* Only code tf_select if it would actually make a difference. */ | ||
773 | if (tf_select_rsv && | ||
774 | tf_select_table[LM][4*isTransient+0+tf_changed]!= | ||
775 | tf_select_table[LM][4*isTransient+2+tf_changed]) | ||
776 | ec_enc_bit_logp(enc, tf_select, 1); | ||
777 | else | ||
778 | tf_select = 0; | ||
779 | for (i=start;i<end;i++) | ||
780 | tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]]; | ||
781 | /*printf("%d %d ", isTransient, tf_select); for(i=0;i<end;i++)printf("%d ", tf_res[i]);printf("\n");*/ | ||
782 | } | ||
783 | #endif | ||
784 | |||
785 | static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec) | ||
786 | { | ||
787 | int i, curr, tf_select; | ||
788 | int tf_select_rsv; | ||
789 | int tf_changed; | ||
790 | int logp; | ||
791 | opus_uint32 budget; | ||
792 | opus_uint32 tell; | ||
793 | |||
794 | budget = dec->storage*8; | ||
795 | tell = ec_tell(dec); | ||
796 | logp = isTransient ? 2 : 4; | ||
797 | tf_select_rsv = LM>0 && tell+logp+1<=budget; | ||
798 | budget -= tf_select_rsv; | ||
799 | tf_changed = curr = 0; | ||
800 | for (i=start;i<end;i++) | ||
801 | { | ||
802 | if (tell+logp<=budget) | ||
803 | { | ||
804 | curr ^= ec_dec_bit_logp(dec, logp); | ||
805 | tell = ec_tell(dec); | ||
806 | tf_changed |= curr; | ||
807 | } | ||
808 | tf_res[i] = curr; | ||
809 | logp = isTransient ? 4 : 5; | ||
810 | } | ||
811 | tf_select = 0; | ||
812 | if (tf_select_rsv && | ||
813 | tf_select_table[LM][4*isTransient+0+tf_changed] != | ||
814 | tf_select_table[LM][4*isTransient+2+tf_changed]) | ||
815 | { | ||
816 | tf_select = ec_dec_bit_logp(dec, 1); | ||
817 | } | ||
818 | for (i=start;i<end;i++) | ||
819 | { | ||
820 | tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]]; | ||
821 | } | ||
822 | } | ||
823 | |||
824 | static void init_caps(const CELTMode *m,int *cap,int LM,int C) | ||
825 | { | 183 | { |
826 | int i; | 184 | int i; |
827 | for (i=0;i<m->nbEBands;i++) | 185 | for (i=0;i<m->nbEBands;i++) |
@@ -832,2070 +190,6 @@ static void init_caps(const CELTMode *m,int *cap,int LM,int C) | |||
832 | } | 190 | } |
833 | } | 191 | } |
834 | 192 | ||
835 | #if 0 | ||
836 | static int alloc_trim_analysis(const CELTMode *m, const celt_norm *X, | ||
837 | const opus_val16 *bandLogE, int end, int LM, int C, int N0) | ||
838 | { | ||
839 | int i; | ||
840 | opus_val32 diff=0; | ||
841 | int c; | ||
842 | int trim_index = 5; | ||
843 | if (C==2) | ||
844 | { | ||
845 | opus_val16 sum = 0; /* Q10 */ | ||
846 | /* Compute inter-channel correlation for low frequencies */ | ||
847 | for (i=0;i<8;i++) | ||
848 | { | ||
849 | int j; | ||
850 | opus_val32 partial = 0; | ||
851 | for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++) | ||
852 | partial = MAC16_16(partial, X[j], X[N0+j]); | ||
853 | sum = ADD16(sum, EXTRACT16(SHR32(partial, 18))); | ||
854 | } | ||
855 | sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum); | ||
856 | /*printf ("%f\n", sum);*/ | ||
857 | if (sum > QCONST16(.995f,10)) | ||
858 | trim_index-=4; | ||
859 | else if (sum > QCONST16(.92f,10)) | ||
860 | trim_index-=3; | ||
861 | else if (sum > QCONST16(.85f,10)) | ||
862 | trim_index-=2; | ||
863 | else if (sum > QCONST16(.8f,10)) | ||
864 | trim_index-=1; | ||
865 | } | ||
866 | |||
867 | /* Estimate spectral tilt */ | ||
868 | c=0; do { | ||
869 | for (i=0;i<end-1;i++) | ||
870 | { | ||
871 | diff += bandLogE[i+c*m->nbEBands]*(opus_int32)(2+2*i-m->nbEBands); | ||
872 | } | ||
873 | } while (++c<C); | ||
874 | /* We divide by two here to avoid making the tilt larger for stereo as a | ||
875 | result of a bug in the loop above */ | ||
876 | diff /= 2*C*(end-1); | ||
877 | /*printf("%f\n", diff);*/ | ||
878 | if (diff > QCONST16(2.f, DB_SHIFT)) | ||
879 | trim_index--; | ||
880 | if (diff > QCONST16(8.f, DB_SHIFT)) | ||
881 | trim_index--; | ||
882 | if (diff < -QCONST16(4.f, DB_SHIFT)) | ||
883 | trim_index++; | ||
884 | if (diff < -QCONST16(10.f, DB_SHIFT)) | ||
885 | trim_index++; | ||
886 | |||
887 | if (trim_index<0) | ||
888 | trim_index = 0; | ||
889 | if (trim_index>10) | ||
890 | trim_index = 10; | ||
891 | #ifdef FUZZING | ||
892 | trim_index = rand()%11; | ||
893 | #endif | ||
894 | return trim_index; | ||
895 | } | ||
896 | |||
897 | static int stereo_analysis(const CELTMode *m, const celt_norm *X, | ||
898 | int LM, int N0) | ||
899 | { | ||
900 | int i; | ||
901 | int thetas; | ||
902 | opus_val32 sumLR = EPSILON, sumMS = EPSILON; | ||
903 | |||
904 | /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */ | ||
905 | for (i=0;i<13;i++) | ||
906 | { | ||
907 | int j; | ||
908 | for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++) | ||
909 | { | ||
910 | opus_val32 L, R, M, S; | ||
911 | /* We cast to 32-bit first because of the -32768 case */ | ||
912 | L = EXTEND32(X[j]); | ||
913 | R = EXTEND32(X[N0+j]); | ||
914 | M = ADD32(L, R); | ||
915 | S = SUB32(L, R); | ||
916 | sumLR = ADD32(sumLR, ADD32(ABS32(L), ABS32(R))); | ||
917 | sumMS = ADD32(sumMS, ADD32(ABS32(M), ABS32(S))); | ||
918 | } | ||
919 | } | ||
920 | sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS); | ||
921 | thetas = 13; | ||
922 | /* We don't need thetas for lower bands with LM<=1 */ | ||
923 | if (LM<=1) | ||
924 | thetas -= 8; | ||
925 | return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS) | ||
926 | > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR); | ||
927 | } | ||
928 | |||
929 | int celt_encode_with_ec(CELTEncoder * OPUS_RESTRICT st, const opus_val16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc) | ||
930 | { | ||
931 | int i, c, N; | ||
932 | opus_int32 bits; | ||
933 | ec_enc _enc; | ||
934 | VARDECL(celt_sig, in); | ||
935 | VARDECL(celt_sig, freq); | ||
936 | VARDECL(celt_norm, X); | ||
937 | VARDECL(celt_ener, bandE); | ||
938 | VARDECL(opus_val16, bandLogE); | ||
939 | VARDECL(int, fine_quant); | ||
940 | VARDECL(opus_val16, error); | ||
941 | VARDECL(int, pulses); | ||
942 | VARDECL(int, cap); | ||
943 | VARDECL(int, offsets); | ||
944 | VARDECL(int, fine_priority); | ||
945 | VARDECL(int, tf_res); | ||
946 | VARDECL(unsigned char, collapse_masks); | ||
947 | celt_sig *prefilter_mem; | ||
948 | opus_val16 *oldBandE, *oldLogE, *oldLogE2; | ||
949 | int shortBlocks=0; | ||
950 | int isTransient=0; | ||
951 | const int CC = st->channels; | ||
952 | const int C = st->stream_channels; | ||
953 | int LM, M; | ||
954 | int tf_select; | ||
955 | int nbFilledBytes, nbAvailableBytes; | ||
956 | int effEnd; | ||
957 | int codedBands; | ||
958 | int tf_sum; | ||
959 | int alloc_trim; | ||
960 | int pitch_index=COMBFILTER_MINPERIOD; | ||
961 | opus_val16 gain1 = 0; | ||
962 | int intensity=0; | ||
963 | int dual_stereo=0; | ||
964 | int effectiveBytes; | ||
965 | opus_val16 pf_threshold; | ||
966 | int dynalloc_logp; | ||
967 | opus_int32 vbr_rate; | ||
968 | opus_int32 total_bits; | ||
969 | opus_int32 total_boost; | ||
970 | opus_int32 balance; | ||
971 | opus_int32 tell; | ||
972 | int prefilter_tapset=0; | ||
973 | int pf_on; | ||
974 | int anti_collapse_rsv; | ||
975 | int anti_collapse_on=0; | ||
976 | int silence=0; | ||
977 | ALLOC_STACK; | ||
978 | |||
979 | if (nbCompressedBytes<2 || pcm==NULL) | ||
980 | return OPUS_BAD_ARG; | ||
981 | |||
982 | frame_size *= st->upsample; | ||
983 | for (LM=0;LM<=st->mode->maxLM;LM++) | ||
984 | if (st->mode->shortMdctSize<<LM==frame_size) | ||
985 | break; | ||
986 | if (LM>st->mode->maxLM) | ||
987 | return OPUS_BAD_ARG; | ||
988 | M=1<<LM; | ||
989 | N = M*st->mode->shortMdctSize; | ||
990 | |||
991 | prefilter_mem = st->in_mem+CC*(st->overlap); | ||
992 | oldBandE = (opus_val16*)(st->in_mem+CC*(2*st->overlap+COMBFILTER_MAXPERIOD)); | ||
993 | oldLogE = oldBandE + CC*st->mode->nbEBands; | ||
994 | oldLogE2 = oldLogE + CC*st->mode->nbEBands; | ||
995 | |||
996 | if (enc==NULL) | ||
997 | { | ||
998 | tell=1; | ||
999 | nbFilledBytes=0; | ||
1000 | } else { | ||
1001 | tell=ec_tell(enc); | ||
1002 | nbFilledBytes=(tell+4)>>3; | ||
1003 | } | ||
1004 | |||
1005 | #ifdef CUSTOM_MODES | ||
1006 | if (st->signalling && enc==NULL) | ||
1007 | { | ||
1008 | int tmp = (st->mode->effEBands-st->end)>>1; | ||
1009 | st->end = IMAX(1, st->mode->effEBands-tmp); | ||
1010 | compressed[0] = tmp<<5; | ||
1011 | compressed[0] |= LM<<3; | ||
1012 | compressed[0] |= (C==2)<<2; | ||
1013 | /* Convert "standard mode" to Opus header */ | ||
1014 | if (st->mode->Fs==48000 && st->mode->shortMdctSize==120) | ||
1015 | { | ||
1016 | int c0 = toOpus(compressed[0]); | ||
1017 | if (c0<0) | ||
1018 | return OPUS_BAD_ARG; | ||
1019 | compressed[0] = c0; | ||
1020 | } | ||
1021 | compressed++; | ||
1022 | nbCompressedBytes--; | ||
1023 | } | ||
1024 | #else | ||
1025 | celt_assert(st->signalling==0); | ||
1026 | #endif | ||
1027 | |||
1028 | /* Can't produce more than 1275 output bytes */ | ||
1029 | nbCompressedBytes = IMIN(nbCompressedBytes,1275); | ||
1030 | nbAvailableBytes = nbCompressedBytes - nbFilledBytes; | ||
1031 | |||
1032 | if (st->vbr && st->bitrate!=OPUS_BITRATE_MAX) | ||
1033 | { | ||
1034 | opus_int32 den=st->mode->Fs>>BITRES; | ||
1035 | vbr_rate=(st->bitrate*frame_size+(den>>1))/den; | ||
1036 | #ifdef CUSTOM_MODES | ||
1037 | if (st->signalling) | ||
1038 | vbr_rate -= 8<<BITRES; | ||
1039 | #endif | ||
1040 | effectiveBytes = vbr_rate>>(3+BITRES); | ||
1041 | } else { | ||
1042 | opus_int32 tmp; | ||
1043 | vbr_rate = 0; | ||
1044 | tmp = st->bitrate*frame_size; | ||
1045 | if (tell>1) | ||
1046 | tmp += tell; | ||
1047 | if (st->bitrate!=OPUS_BITRATE_MAX) | ||
1048 | nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes, | ||
1049 | (tmp+4*st->mode->Fs)/(8*st->mode->Fs)-!!st->signalling)); | ||
1050 | effectiveBytes = nbCompressedBytes; | ||
1051 | } | ||
1052 | |||
1053 | if (enc==NULL) | ||
1054 | { | ||
1055 | ec_enc_init(&_enc, compressed, nbCompressedBytes); | ||
1056 | enc = &_enc; | ||
1057 | } | ||
1058 | |||
1059 | if (vbr_rate>0) | ||
1060 | { | ||
1061 | /* Computes the max bit-rate allowed in VBR mode to avoid violating the | ||
1062 | target rate and buffering. | ||
1063 | We must do this up front so that bust-prevention logic triggers | ||
1064 | correctly if we don't have enough bits. */ | ||
1065 | if (st->constrained_vbr) | ||
1066 | { | ||
1067 | opus_int32 vbr_bound; | ||
1068 | opus_int32 max_allowed; | ||
1069 | /* We could use any multiple of vbr_rate as bound (depending on the | ||
1070 | delay). | ||
1071 | This is clamped to ensure we use at least two bytes if the encoder | ||
1072 | was entirely empty, but to allow 0 in hybrid mode. */ | ||
1073 | vbr_bound = vbr_rate; | ||
1074 | max_allowed = IMIN(IMAX(tell==1?2:0, | ||
1075 | (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)), | ||
1076 | nbAvailableBytes); | ||
1077 | if(max_allowed < nbAvailableBytes) | ||
1078 | { | ||
1079 | nbCompressedBytes = nbFilledBytes+max_allowed; | ||
1080 | nbAvailableBytes = max_allowed; | ||
1081 | ec_enc_shrink(enc, nbCompressedBytes); | ||
1082 | } | ||
1083 | } | ||
1084 | } | ||
1085 | total_bits = nbCompressedBytes*8; | ||
1086 | |||
1087 | effEnd = st->end; | ||
1088 | if (effEnd > st->mode->effEBands) | ||
1089 | effEnd = st->mode->effEBands; | ||
1090 | |||
1091 | ALLOC(in, CC*(N+st->overlap), celt_sig); | ||
1092 | |||
1093 | /* Find pitch period and gain */ | ||
1094 | { | ||
1095 | VARDECL(celt_sig, _pre); | ||
1096 | celt_sig *pre[2]; | ||
1097 | SAVE_STACK; | ||
1098 | ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig); | ||
1099 | |||
1100 | pre[0] = _pre; | ||
1101 | pre[1] = _pre + (N+COMBFILTER_MAXPERIOD); | ||
1102 | |||
1103 | silence = 1; | ||
1104 | c=0; do { | ||
1105 | int count = 0; | ||
1106 | const opus_val16 * OPUS_RESTRICT pcmp = pcm+c; | ||
1107 | celt_sig * OPUS_RESTRICT inp = in+c*(N+st->overlap)+st->overlap; | ||
1108 | |||
1109 | for (i=0;i<N;i++) | ||
1110 | { | ||
1111 | celt_sig x, tmp; | ||
1112 | |||
1113 | x = SCALEIN(*pcmp); | ||
1114 | #ifndef FIXED_POINT | ||
1115 | if (!(x==x)) | ||
1116 | x = 0; | ||
1117 | if (st->clip) | ||
1118 | x = MAX32(-65536.f, MIN32(65536.f,x)); | ||
1119 | #endif | ||
1120 | if (++count==st->upsample) | ||
1121 | { | ||
1122 | count=0; | ||
1123 | pcmp+=CC; | ||
1124 | } else { | ||
1125 | x = 0; | ||
1126 | } | ||
1127 | /* Apply pre-emphasis */ | ||
1128 | tmp = MULT16_16(st->mode->preemph[2], x); | ||
1129 | *inp = tmp + st->preemph_memE[c]; | ||
1130 | st->preemph_memE[c] = MULT16_32_Q15(st->mode->preemph[1], *inp) | ||
1131 | - MULT16_32_Q15(st->mode->preemph[0], tmp); | ||
1132 | silence = silence && *inp == 0; | ||
1133 | inp++; | ||
1134 | } | ||
1135 | OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD); | ||
1136 | OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N); | ||
1137 | } while (++c<CC); | ||
1138 | |||
1139 | #ifdef FUZZING | ||
1140 | if ((rand()&0x3F)==0) | ||
1141 | silence = 1; | ||
1142 | #endif | ||
1143 | if (tell==1) | ||
1144 | ec_enc_bit_logp(enc, silence, 15); | ||
1145 | else | ||
1146 | silence=0; | ||
1147 | if (silence) | ||
1148 | { | ||
1149 | /*In VBR mode there is no need to send more than the minimum. */ | ||
1150 | if (vbr_rate>0) | ||
1151 | { | ||
1152 | effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2); | ||
1153 | total_bits=nbCompressedBytes*8; | ||
1154 | nbAvailableBytes=2; | ||
1155 | ec_enc_shrink(enc, nbCompressedBytes); | ||
1156 | } | ||
1157 | /* Pretend we've filled all the remaining bits with zeros | ||
1158 | (that's what the initialiser did anyway) */ | ||
1159 | tell = nbCompressedBytes*8; | ||
1160 | enc->nbits_total+=tell-ec_tell(enc); | ||
1161 | } | ||
1162 | if (nbAvailableBytes>12*C && st->start==0 && !silence && !st->disable_pf && st->complexity >= 5) | ||
1163 | { | ||
1164 | VARDECL(opus_val16, pitch_buf); | ||
1165 | ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16); | ||
1166 | |||
1167 | pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC); | ||
1168 | pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N, | ||
1169 | COMBFILTER_MAXPERIOD-COMBFILTER_MINPERIOD, &pitch_index); | ||
1170 | pitch_index = COMBFILTER_MAXPERIOD-pitch_index; | ||
1171 | |||
1172 | gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD, | ||
1173 | N, &pitch_index, st->prefilter_period, st->prefilter_gain); | ||
1174 | if (pitch_index > COMBFILTER_MAXPERIOD-2) | ||
1175 | pitch_index = COMBFILTER_MAXPERIOD-2; | ||
1176 | gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1); | ||
1177 | if (st->loss_rate>2) | ||
1178 | gain1 = HALF32(gain1); | ||
1179 | if (st->loss_rate>4) | ||
1180 | gain1 = HALF32(gain1); | ||
1181 | if (st->loss_rate>8) | ||
1182 | gain1 = 0; | ||
1183 | prefilter_tapset = st->tapset_decision; | ||
1184 | } else { | ||
1185 | gain1 = 0; | ||
1186 | } | ||
1187 | |||
1188 | /* Gain threshold for enabling the prefilter/postfilter */ | ||
1189 | pf_threshold = QCONST16(.2f,15); | ||
1190 | |||
1191 | /* Adjusting the threshold based on rate and continuity */ | ||
1192 | if (abs(pitch_index-st->prefilter_period)*10>pitch_index) | ||
1193 | pf_threshold += QCONST16(.2f,15); | ||
1194 | if (nbAvailableBytes<25) | ||
1195 | pf_threshold += QCONST16(.1f,15); | ||
1196 | if (nbAvailableBytes<35) | ||
1197 | pf_threshold += QCONST16(.1f,15); | ||
1198 | if (st->prefilter_gain > QCONST16(.4f,15)) | ||
1199 | pf_threshold -= QCONST16(.1f,15); | ||
1200 | if (st->prefilter_gain > QCONST16(.55f,15)) | ||
1201 | pf_threshold -= QCONST16(.1f,15); | ||
1202 | |||
1203 | /* Hard threshold at 0.2 */ | ||
1204 | pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15)); | ||
1205 | if (gain1<pf_threshold) | ||
1206 | { | ||
1207 | if(st->start==0 && tell+16<=total_bits) | ||
1208 | ec_enc_bit_logp(enc, 0, 1); | ||
1209 | gain1 = 0; | ||
1210 | pf_on = 0; | ||
1211 | } else { | ||
1212 | /*This block is not gated by a total bits check only because | ||
1213 | of the nbAvailableBytes check above.*/ | ||
1214 | int qg; | ||
1215 | int octave; | ||
1216 | |||
1217 | if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15)) | ||
1218 | gain1=st->prefilter_gain; | ||
1219 | |||
1220 | #ifdef FIXED_POINT | ||
1221 | qg = ((gain1+1536)>>10)/3-1; | ||
1222 | #else | ||
1223 | qg = (int)floor(.5f+gain1*32/3)-1; | ||
1224 | #endif | ||
1225 | qg = IMAX(0, IMIN(7, qg)); | ||
1226 | ec_enc_bit_logp(enc, 1, 1); | ||
1227 | pitch_index += 1; | ||
1228 | octave = EC_ILOG(pitch_index)-5; | ||
1229 | ec_enc_uint(enc, octave, 6); | ||
1230 | ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave); | ||
1231 | pitch_index -= 1; | ||
1232 | ec_enc_bits(enc, qg, 3); | ||
1233 | if (ec_tell(enc)+2<=total_bits) | ||
1234 | ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2); | ||
1235 | else | ||
1236 | prefilter_tapset = 0; | ||
1237 | gain1 = QCONST16(0.09375f,15)*(qg+1); | ||
1238 | pf_on = 1; | ||
1239 | } | ||
1240 | /*printf("%d %f\n", pitch_index, gain1);*/ | ||
1241 | |||
1242 | c=0; do { | ||
1243 | int offset = st->mode->shortMdctSize-st->mode->overlap; | ||
1244 | st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD); | ||
1245 | OPUS_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap); | ||
1246 | if (offset) | ||
1247 | comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD, | ||
1248 | st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain, | ||
1249 | st->prefilter_tapset, st->prefilter_tapset, NULL, 0); | ||
1250 | |||
1251 | comb_filter(in+c*(N+st->overlap)+st->overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset, | ||
1252 | st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1, | ||
1253 | st->prefilter_tapset, prefilter_tapset, st->mode->window, st->mode->overlap); | ||
1254 | OPUS_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap); | ||
1255 | |||
1256 | if (N>COMBFILTER_MAXPERIOD) | ||
1257 | { | ||
1258 | OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD); | ||
1259 | } else { | ||
1260 | OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N); | ||
1261 | OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N); | ||
1262 | } | ||
1263 | } while (++c<CC); | ||
1264 | |||
1265 | RESTORE_STACK; | ||
1266 | } | ||
1267 | |||
1268 | isTransient = 0; | ||
1269 | shortBlocks = 0; | ||
1270 | if (LM>0 && ec_tell(enc)+3<=total_bits) | ||
1271 | { | ||
1272 | if (st->complexity > 1) | ||
1273 | { | ||
1274 | isTransient = transient_analysis(in, N+st->overlap, CC, | ||
1275 | st->overlap); | ||
1276 | if (isTransient) | ||
1277 | shortBlocks = M; | ||
1278 | } | ||
1279 | ec_enc_bit_logp(enc, isTransient, 3); | ||
1280 | } | ||
1281 | |||
1282 | ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */ | ||
1283 | ALLOC(bandE,st->mode->nbEBands*CC, celt_ener); | ||
1284 | ALLOC(bandLogE,st->mode->nbEBands*CC, opus_val16); | ||
1285 | /* Compute MDCTs */ | ||
1286 | compute_mdcts(st->mode, shortBlocks, in, freq, CC, LM); | ||
1287 | |||
1288 | if (CC==2&&C==1) | ||
1289 | { | ||
1290 | for (i=0;i<N;i++) | ||
1291 | freq[i] = ADD32(HALF32(freq[i]), HALF32(freq[N+i])); | ||
1292 | } | ||
1293 | if (st->upsample != 1) | ||
1294 | { | ||
1295 | c=0; do | ||
1296 | { | ||
1297 | int bound = N/st->upsample; | ||
1298 | for (i=0;i<bound;i++) | ||
1299 | freq[c*N+i] *= st->upsample; | ||
1300 | for (;i<N;i++) | ||
1301 | freq[c*N+i] = 0; | ||
1302 | } while (++c<C); | ||
1303 | } | ||
1304 | ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */ | ||
1305 | |||
1306 | compute_band_energies(st->mode, freq, bandE, effEnd, C, M); | ||
1307 | |||
1308 | amp2Log2(st->mode, effEnd, st->end, bandE, bandLogE, C); | ||
1309 | |||
1310 | /* Band normalisation */ | ||
1311 | normalise_bands(st->mode, freq, X, bandE, effEnd, C, M); | ||
1312 | |||
1313 | ALLOC(tf_res, st->mode->nbEBands, int); | ||
1314 | tf_select = tf_analysis(st->mode, effEnd, C, isTransient, tf_res, effectiveBytes, X, N, LM, &tf_sum); | ||
1315 | for (i=effEnd;i<st->end;i++) | ||
1316 | tf_res[i] = tf_res[effEnd-1]; | ||
1317 | |||
1318 | ALLOC(error, C*st->mode->nbEBands, opus_val16); | ||
1319 | quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE, | ||
1320 | oldBandE, total_bits, error, enc, | ||
1321 | C, LM, nbAvailableBytes, st->force_intra, | ||
1322 | &st->delayedIntra, st->complexity >= 4, st->loss_rate); | ||
1323 | |||
1324 | tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc); | ||
1325 | |||
1326 | st->spread_decision = SPREAD_NORMAL; | ||
1327 | if (ec_tell(enc)+4<=total_bits) | ||
1328 | { | ||
1329 | if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C) | ||
1330 | { | ||
1331 | if (st->complexity == 0) | ||
1332 | st->spread_decision = SPREAD_NONE; | ||
1333 | } else { | ||
1334 | st->spread_decision = spreading_decision(st->mode, X, | ||
1335 | &st->tonal_average, st->spread_decision, &st->hf_average, | ||
1336 | &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M); | ||
1337 | } | ||
1338 | ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5); | ||
1339 | } | ||
1340 | |||
1341 | ALLOC(cap, st->mode->nbEBands, int); | ||
1342 | ALLOC(offsets, st->mode->nbEBands, int); | ||
1343 | |||
1344 | init_caps(st->mode,cap,LM,C); | ||
1345 | for (i=0;i<st->mode->nbEBands;i++) | ||
1346 | offsets[i] = 0; | ||
1347 | /* Dynamic allocation code */ | ||
1348 | /* Make sure that dynamic allocation can't make us bust the budget */ | ||
1349 | if (effectiveBytes > 50 && LM>=1) | ||
1350 | { | ||
1351 | int t1, t2; | ||
1352 | if (LM <= 1) | ||
1353 | { | ||
1354 | t1 = 3; | ||
1355 | t2 = 5; | ||
1356 | } else { | ||
1357 | t1 = 2; | ||
1358 | t2 = 4; | ||
1359 | } | ||
1360 | for (i=st->start+1;i<st->end-1;i++) | ||
1361 | { | ||
1362 | opus_val32 d2; | ||
1363 | d2 = 2*bandLogE[i]-bandLogE[i-1]-bandLogE[i+1]; | ||
1364 | if (C==2) | ||
1365 | d2 = HALF32(d2 + 2*bandLogE[i+st->mode->nbEBands]- | ||
1366 | bandLogE[i-1+st->mode->nbEBands]-bandLogE[i+1+st->mode->nbEBands]); | ||
1367 | #ifdef FUZZING | ||
1368 | if((rand()&0xF)==0) | ||
1369 | { | ||
1370 | offsets[i] += 1; | ||
1371 | if((rand()&0x3)==0) | ||
1372 | offsets[i] += 1+(rand()&0x3); | ||
1373 | } | ||
1374 | #else | ||
1375 | if (d2 > SHL16(t1,DB_SHIFT)) | ||
1376 | offsets[i] += 1; | ||
1377 | if (d2 > SHL16(t2,DB_SHIFT)) | ||
1378 | offsets[i] += 1; | ||
1379 | #endif | ||
1380 | } | ||
1381 | } | ||
1382 | dynalloc_logp = 6; | ||
1383 | total_bits<<=BITRES; | ||
1384 | total_boost = 0; | ||
1385 | tell = ec_tell_frac(enc); | ||
1386 | for (i=st->start;i<st->end;i++) | ||
1387 | { | ||
1388 | int width, quanta; | ||
1389 | int dynalloc_loop_logp; | ||
1390 | int boost; | ||
1391 | int j; | ||
1392 | width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM; | ||
1393 | /* quanta is 6 bits, but no more than 1 bit/sample | ||
1394 | and no less than 1/8 bit/sample */ | ||
1395 | quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width)); | ||
1396 | dynalloc_loop_logp = dynalloc_logp; | ||
1397 | boost = 0; | ||
1398 | for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost | ||
1399 | && boost < cap[i]; j++) | ||
1400 | { | ||
1401 | int flag; | ||
1402 | flag = j<offsets[i]; | ||
1403 | ec_enc_bit_logp(enc, flag, dynalloc_loop_logp); | ||
1404 | tell = ec_tell_frac(enc); | ||
1405 | if (!flag) | ||
1406 | break; | ||
1407 | boost += quanta; | ||
1408 | total_boost += quanta; | ||
1409 | dynalloc_loop_logp = 1; | ||
1410 | } | ||
1411 | /* Making dynalloc more likely */ | ||
1412 | if (j) | ||
1413 | dynalloc_logp = IMAX(2, dynalloc_logp-1); | ||
1414 | offsets[i] = boost; | ||
1415 | } | ||
1416 | alloc_trim = 5; | ||
1417 | if (tell+(6<<BITRES) <= total_bits - total_boost) | ||
1418 | { | ||
1419 | alloc_trim = alloc_trim_analysis(st->mode, X, bandLogE, | ||
1420 | st->end, LM, C, N); | ||
1421 | ec_enc_icdf(enc, alloc_trim, trim_icdf, 7); | ||
1422 | tell = ec_tell_frac(enc); | ||
1423 | } | ||
1424 | |||
1425 | /* Variable bitrate */ | ||
1426 | if (vbr_rate>0) | ||
1427 | { | ||
1428 | opus_val16 alpha; | ||
1429 | opus_int32 delta; | ||
1430 | /* The target rate in 8th bits per frame */ | ||
1431 | opus_int32 target; | ||
1432 | opus_int32 min_allowed; | ||
1433 | int lm_diff = st->mode->maxLM - LM; | ||
1434 | |||
1435 | /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms. | ||
1436 | The CELT allocator will just not be able to use more than that anyway. */ | ||
1437 | nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM)); | ||
1438 | target = vbr_rate + (st->vbr_offset>>lm_diff) - ((40*C+20)<<BITRES); | ||
1439 | |||
1440 | /* Shortblocks get a large boost in bitrate, but since they | ||
1441 | are uncommon long blocks are not greatly affected */ | ||
1442 | if (shortBlocks || tf_sum < -2*(st->end-st->start)) | ||
1443 | target = 7*target/4; | ||
1444 | else if (tf_sum < -(st->end-st->start)) | ||
1445 | target = 3*target/2; | ||
1446 | else if (M > 1) | ||
1447 | target-=(target+14)/28; | ||
1448 | |||
1449 | /* The current offset is removed from the target and the space used | ||
1450 | so far is added*/ | ||
1451 | target=target+tell; | ||
1452 | |||
1453 | /* In VBR mode the frame size must not be reduced so much that it would | ||
1454 | result in the encoder running out of bits. | ||
1455 | The margin of 2 bytes ensures that none of the bust-prevention logic | ||
1456 | in the decoder will have triggered so far. */ | ||
1457 | min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2 - nbFilledBytes; | ||
1458 | |||
1459 | nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3); | ||
1460 | nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes); | ||
1461 | nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes; | ||
1462 | |||
1463 | /* By how much did we "miss" the target on that frame */ | ||
1464 | delta = target - vbr_rate; | ||
1465 | |||
1466 | target=nbAvailableBytes<<(BITRES+3); | ||
1467 | |||
1468 | /*If the frame is silent we don't adjust our drift, otherwise | ||
1469 | the encoder will shoot to very high rates after hitting a | ||
1470 | span of silence, but we do allow the bitres to refill. | ||
1471 | This means that we'll undershoot our target in CVBR/VBR modes | ||
1472 | on files with lots of silence. */ | ||
1473 | if(silence) | ||
1474 | { | ||
1475 | nbAvailableBytes = 2; | ||
1476 | target = 2*8<<BITRES; | ||
1477 | delta = 0; | ||
1478 | } | ||
1479 | |||
1480 | if (st->vbr_count < 970) | ||
1481 | { | ||
1482 | st->vbr_count++; | ||
1483 | alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16)); | ||
1484 | } else | ||
1485 | alpha = QCONST16(.001f,15); | ||
1486 | /* How many bits have we used in excess of what we're allowed */ | ||
1487 | if (st->constrained_vbr) | ||
1488 | st->vbr_reservoir += target - vbr_rate; | ||
1489 | /*printf ("%d\n", st->vbr_reservoir);*/ | ||
1490 | |||
1491 | /* Compute the offset we need to apply in order to reach the target */ | ||
1492 | st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift); | ||
1493 | st->vbr_offset = -st->vbr_drift; | ||
1494 | /*printf ("%d\n", st->vbr_drift);*/ | ||
1495 | |||
1496 | if (st->constrained_vbr && st->vbr_reservoir < 0) | ||
1497 | { | ||
1498 | /* We're under the min value -- increase rate */ | ||
1499 | int adjust = (-st->vbr_reservoir)/(8<<BITRES); | ||
1500 | /* Unless we're just coding silence */ | ||
1501 | nbAvailableBytes += silence?0:adjust; | ||
1502 | st->vbr_reservoir = 0; | ||
1503 | /*printf ("+%d\n", adjust);*/ | ||
1504 | } | ||
1505 | nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes); | ||
1506 | /* This moves the raw bits to take into account the new compressed size */ | ||
1507 | ec_enc_shrink(enc, nbCompressedBytes); | ||
1508 | } | ||
1509 | if (C==2) | ||
1510 | { | ||
1511 | int effectiveRate; | ||
1512 | |||
1513 | /* Always use MS for 2.5 ms frames until we can do a better analysis */ | ||
1514 | if (LM!=0) | ||
1515 | dual_stereo = stereo_analysis(st->mode, X, LM, N); | ||
1516 | |||
1517 | /* Account for coarse energy */ | ||
1518 | effectiveRate = (8*effectiveBytes - 80)>>LM; | ||
1519 | |||
1520 | /* effectiveRate in kb/s */ | ||
1521 | effectiveRate = 2*effectiveRate/5; | ||
1522 | if (effectiveRate<35) | ||
1523 | intensity = 8; | ||
1524 | else if (effectiveRate<50) | ||
1525 | intensity = 12; | ||
1526 | else if (effectiveRate<68) | ||
1527 | intensity = 16; | ||
1528 | else if (effectiveRate<84) | ||
1529 | intensity = 18; | ||
1530 | else if (effectiveRate<102) | ||
1531 | intensity = 19; | ||
1532 | else if (effectiveRate<130) | ||
1533 | intensity = 20; | ||
1534 | else | ||
1535 | intensity = 100; | ||
1536 | intensity = IMIN(st->end,IMAX(st->start, intensity)); | ||
1537 | } | ||
1538 | |||
1539 | /* Bit allocation */ | ||
1540 | ALLOC(fine_quant, st->mode->nbEBands, int); | ||
1541 | ALLOC(pulses, st->mode->nbEBands, int); | ||
1542 | ALLOC(fine_priority, st->mode->nbEBands, int); | ||
1543 | |||
1544 | /* bits = packet size - where we are - safety*/ | ||
1545 | bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1; | ||
1546 | anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0; | ||
1547 | bits -= anti_collapse_rsv; | ||
1548 | codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap, | ||
1549 | alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses, | ||
1550 | fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands); | ||
1551 | st->lastCodedBands = codedBands; | ||
1552 | |||
1553 | quant_fine_energy(st->mode, st->start, st->end, oldBandE, error, fine_quant, enc, C); | ||
1554 | |||
1555 | #ifdef MEASURE_NORM_MSE | ||
1556 | float X0[3000]; | ||
1557 | float bandE0[60]; | ||
1558 | c=0; do | ||
1559 | for (i=0;i<N;i++) | ||
1560 | X0[i+c*N] = X[i+c*N]; | ||
1561 | while (++c<C); | ||
1562 | for (i=0;i<C*st->mode->nbEBands;i++) | ||
1563 | bandE0[i] = bandE[i]; | ||
1564 | #endif | ||
1565 | |||
1566 | /* Residual quantisation */ | ||
1567 | ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char); | ||
1568 | quant_all_bands(1, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks, | ||
1569 | bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, intensity, tf_res, | ||
1570 | nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng); | ||
1571 | |||
1572 | if (anti_collapse_rsv > 0) | ||
1573 | { | ||
1574 | anti_collapse_on = st->consec_transient<2; | ||
1575 | #ifdef FUZZING | ||
1576 | anti_collapse_on = rand()&0x1; | ||
1577 | #endif | ||
1578 | ec_enc_bits(enc, anti_collapse_on, 1); | ||
1579 | } | ||
1580 | quant_energy_finalise(st->mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C); | ||
1581 | |||
1582 | if (silence) | ||
1583 | { | ||
1584 | for (i=0;i<C*st->mode->nbEBands;i++) | ||
1585 | oldBandE[i] = -QCONST16(28.f,DB_SHIFT); | ||
1586 | } | ||
1587 | |||
1588 | #ifdef RESYNTH | ||
1589 | /* Re-synthesis of the coded audio if required */ | ||
1590 | { | ||
1591 | celt_sig *out_mem[2]; | ||
1592 | celt_sig *overlap_mem[2]; | ||
1593 | |||
1594 | log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C); | ||
1595 | if (silence) | ||
1596 | { | ||
1597 | for (i=0;i<C*st->mode->nbEBands;i++) | ||
1598 | bandE[i] = 0; | ||
1599 | } | ||
1600 | |||
1601 | #ifdef MEASURE_NORM_MSE | ||
1602 | measure_norm_mse(st->mode, X, X0, bandE, bandE0, M, N, C); | ||
1603 | #endif | ||
1604 | if (anti_collapse_on) | ||
1605 | { | ||
1606 | anti_collapse(st->mode, X, collapse_masks, LM, C, N, | ||
1607 | st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng); | ||
1608 | } | ||
1609 | |||
1610 | /* Synthesis */ | ||
1611 | denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M); | ||
1612 | |||
1613 | OPUS_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD); | ||
1614 | if (CC==2) | ||
1615 | OPUS_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD); | ||
1616 | |||
1617 | c=0; do | ||
1618 | for (i=0;i<M*st->mode->eBands[st->start];i++) | ||
1619 | freq[c*N+i] = 0; | ||
1620 | while (++c<C); | ||
1621 | c=0; do | ||
1622 | for (i=M*st->mode->eBands[st->end];i<N;i++) | ||
1623 | freq[c*N+i] = 0; | ||
1624 | while (++c<C); | ||
1625 | |||
1626 | if (CC==2&&C==1) | ||
1627 | { | ||
1628 | for (i=0;i<N;i++) | ||
1629 | freq[N+i] = freq[i]; | ||
1630 | } | ||
1631 | |||
1632 | out_mem[0] = st->syn_mem[0]+MAX_PERIOD; | ||
1633 | if (CC==2) | ||
1634 | out_mem[1] = st->syn_mem[1]+MAX_PERIOD; | ||
1635 | |||
1636 | overlap_mem[0] = prefilter_mem+CC*COMBFILTER_MAXPERIOD; | ||
1637 | if (CC==2) | ||
1638 | overlap_mem[1] = overlap_mem[0] + st->overlap; | ||
1639 | |||
1640 | compute_inv_mdcts(st->mode, shortBlocks, freq, out_mem, overlap_mem, CC, LM); | ||
1641 | |||
1642 | c=0; do { | ||
1643 | st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD); | ||
1644 | st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD); | ||
1645 | comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, st->mode->shortMdctSize, | ||
1646 | st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset, | ||
1647 | st->mode->window, st->overlap); | ||
1648 | if (LM!=0) | ||
1649 | comb_filter(out_mem[c]+st->mode->shortMdctSize, out_mem[c]+st->mode->shortMdctSize, st->prefilter_period, pitch_index, N-st->mode->shortMdctSize, | ||
1650 | st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset, | ||
1651 | st->mode->window, st->mode->overlap); | ||
1652 | } while (++c<CC); | ||
1653 | |||
1654 | deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, st->mode->preemph, st->preemph_memD); | ||
1655 | st->prefilter_period_old = st->prefilter_period; | ||
1656 | st->prefilter_gain_old = st->prefilter_gain; | ||
1657 | st->prefilter_tapset_old = st->prefilter_tapset; | ||
1658 | } | ||
1659 | #endif | ||
1660 | |||
1661 | st->prefilter_period = pitch_index; | ||
1662 | st->prefilter_gain = gain1; | ||
1663 | st->prefilter_tapset = prefilter_tapset; | ||
1664 | #ifdef RESYNTH | ||
1665 | if (LM!=0) | ||
1666 | { | ||
1667 | st->prefilter_period_old = st->prefilter_period; | ||
1668 | st->prefilter_gain_old = st->prefilter_gain; | ||
1669 | st->prefilter_tapset_old = st->prefilter_tapset; | ||
1670 | } | ||
1671 | #endif | ||
1672 | |||
1673 | if (CC==2&&C==1) { | ||
1674 | for (i=0;i<st->mode->nbEBands;i++) | ||
1675 | oldBandE[st->mode->nbEBands+i]=oldBandE[i]; | ||
1676 | } | ||
1677 | |||
1678 | if (!isTransient) | ||
1679 | { | ||
1680 | for (i=0;i<CC*st->mode->nbEBands;i++) | ||
1681 | oldLogE2[i] = oldLogE[i]; | ||
1682 | for (i=0;i<CC*st->mode->nbEBands;i++) | ||
1683 | oldLogE[i] = oldBandE[i]; | ||
1684 | } else { | ||
1685 | for (i=0;i<CC*st->mode->nbEBands;i++) | ||
1686 | oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]); | ||
1687 | } | ||
1688 | /* In case start or end were to change */ | ||
1689 | c=0; do | ||
1690 | { | ||
1691 | for (i=0;i<st->start;i++) | ||
1692 | { | ||
1693 | oldBandE[c*st->mode->nbEBands+i]=0; | ||
1694 | oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT); | ||
1695 | } | ||
1696 | for (i=st->end;i<st->mode->nbEBands;i++) | ||
1697 | { | ||
1698 | oldBandE[c*st->mode->nbEBands+i]=0; | ||
1699 | oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT); | ||
1700 | } | ||
1701 | } while (++c<CC); | ||
1702 | |||
1703 | if (isTransient) | ||
1704 | st->consec_transient++; | ||
1705 | else | ||
1706 | st->consec_transient=0; | ||
1707 | st->rng = enc->rng; | ||
1708 | |||
1709 | /* If there's any room left (can only happen for very high rates), | ||
1710 | it's already filled with zeros */ | ||
1711 | ec_enc_done(enc); | ||
1712 | |||
1713 | #ifdef CUSTOM_MODES | ||
1714 | if (st->signalling) | ||
1715 | nbCompressedBytes++; | ||
1716 | #endif | ||
1717 | |||
1718 | RESTORE_STACK; | ||
1719 | if (ec_get_error(enc)) | ||
1720 | return OPUS_INTERNAL_ERROR; | ||
1721 | else | ||
1722 | return nbCompressedBytes; | ||
1723 | } | ||
1724 | |||
1725 | |||
1726 | #ifdef CUSTOM_MODES | ||
1727 | |||
1728 | #ifdef FIXED_POINT | ||
1729 | int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) | ||
1730 | { | ||
1731 | return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL); | ||
1732 | } | ||
1733 | |||
1734 | #ifndef DISABLE_FLOAT_API | ||
1735 | int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) | ||
1736 | { | ||
1737 | int j, ret, C, N; | ||
1738 | VARDECL(opus_int16, in); | ||
1739 | ALLOC_STACK; | ||
1740 | |||
1741 | if (pcm==NULL) | ||
1742 | return OPUS_BAD_ARG; | ||
1743 | |||
1744 | C = st->channels; | ||
1745 | N = frame_size; | ||
1746 | ALLOC(in, C*N, opus_int16); | ||
1747 | |||
1748 | for (j=0;j<C*N;j++) | ||
1749 | in[j] = FLOAT2INT16(pcm[j]); | ||
1750 | |||
1751 | ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL); | ||
1752 | #ifdef RESYNTH | ||
1753 | for (j=0;j<C*N;j++) | ||
1754 | ((float*)pcm)[j]=in[j]*(1.f/32768.f); | ||
1755 | #endif | ||
1756 | RESTORE_STACK; | ||
1757 | return ret; | ||
1758 | } | ||
1759 | #endif /* DISABLE_FLOAT_API */ | ||
1760 | #else | ||
1761 | |||
1762 | int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) | ||
1763 | { | ||
1764 | int j, ret, C, N; | ||
1765 | VARDECL(celt_sig, in); | ||
1766 | ALLOC_STACK; | ||
1767 | |||
1768 | if (pcm==NULL) | ||
1769 | return OPUS_BAD_ARG; | ||
1770 | |||
1771 | C=st->channels; | ||
1772 | N=frame_size; | ||
1773 | ALLOC(in, C*N, celt_sig); | ||
1774 | for (j=0;j<C*N;j++) { | ||
1775 | in[j] = SCALEOUT(pcm[j]); | ||
1776 | } | ||
1777 | |||
1778 | ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL); | ||
1779 | #ifdef RESYNTH | ||
1780 | for (j=0;j<C*N;j++) | ||
1781 | ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]); | ||
1782 | #endif | ||
1783 | RESTORE_STACK; | ||
1784 | return ret; | ||
1785 | } | ||
1786 | |||
1787 | int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes) | ||
1788 | { | ||
1789 | return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL); | ||
1790 | } | ||
1791 | |||
1792 | #endif | ||
1793 | |||
1794 | #endif /* CUSTOM_MODES */ | ||
1795 | |||
1796 | int opus_custom_encoder_ctl(CELTEncoder * OPUS_RESTRICT st, int request, ...) | ||
1797 | { | ||
1798 | va_list ap; | ||
1799 | |||
1800 | va_start(ap, request); | ||
1801 | switch (request) | ||
1802 | { | ||
1803 | case OPUS_SET_COMPLEXITY_REQUEST: | ||
1804 | { | ||
1805 | int value = va_arg(ap, opus_int32); | ||
1806 | if (value<0 || value>10) | ||
1807 | goto bad_arg; | ||
1808 | st->complexity = value; | ||
1809 | } | ||
1810 | break; | ||
1811 | case CELT_SET_START_BAND_REQUEST: | ||
1812 | { | ||
1813 | opus_int32 value = va_arg(ap, opus_int32); | ||
1814 | if (value<0 || value>=st->mode->nbEBands) | ||
1815 | goto bad_arg; | ||
1816 | st->start = value; | ||
1817 | } | ||
1818 | break; | ||
1819 | case CELT_SET_END_BAND_REQUEST: | ||
1820 | { | ||
1821 | opus_int32 value = va_arg(ap, opus_int32); | ||
1822 | if (value<1 || value>st->mode->nbEBands) | ||
1823 | goto bad_arg; | ||
1824 | st->end = value; | ||
1825 | } | ||
1826 | break; | ||
1827 | case CELT_SET_PREDICTION_REQUEST: | ||
1828 | { | ||
1829 | int value = va_arg(ap, opus_int32); | ||
1830 | if (value<0 || value>2) | ||
1831 | goto bad_arg; | ||
1832 | st->disable_pf = value<=1; | ||
1833 | st->force_intra = value==0; | ||
1834 | } | ||
1835 | break; | ||
1836 | case OPUS_SET_PACKET_LOSS_PERC_REQUEST: | ||
1837 | { | ||
1838 | int value = va_arg(ap, opus_int32); | ||
1839 | if (value<0 || value>100) | ||
1840 | goto bad_arg; | ||
1841 | st->loss_rate = value; | ||
1842 | } | ||
1843 | break; | ||
1844 | case OPUS_SET_VBR_CONSTRAINT_REQUEST: | ||
1845 | { | ||
1846 | opus_int32 value = va_arg(ap, opus_int32); | ||
1847 | st->constrained_vbr = value; | ||
1848 | } | ||
1849 | break; | ||
1850 | case OPUS_SET_VBR_REQUEST: | ||
1851 | { | ||
1852 | opus_int32 value = va_arg(ap, opus_int32); | ||
1853 | st->vbr = value; | ||
1854 | } | ||
1855 | break; | ||
1856 | case OPUS_SET_BITRATE_REQUEST: | ||
1857 | { | ||
1858 | opus_int32 value = va_arg(ap, opus_int32); | ||
1859 | if (value<=500 && value!=OPUS_BITRATE_MAX) | ||
1860 | goto bad_arg; | ||
1861 | value = IMIN(value, 260000*st->channels); | ||
1862 | st->bitrate = value; | ||
1863 | } | ||
1864 | break; | ||
1865 | case CELT_SET_CHANNELS_REQUEST: | ||
1866 | { | ||
1867 | opus_int32 value = va_arg(ap, opus_int32); | ||
1868 | if (value<1 || value>2) | ||
1869 | goto bad_arg; | ||
1870 | st->stream_channels = value; | ||
1871 | } | ||
1872 | break; | ||
1873 | case OPUS_SET_LSB_DEPTH_REQUEST: | ||
1874 | { | ||
1875 | opus_int32 value = va_arg(ap, opus_int32); | ||
1876 | if (value<8 || value>24) | ||
1877 | goto bad_arg; | ||
1878 | st->lsb_depth=value; | ||
1879 | } | ||
1880 | break; | ||
1881 | case OPUS_GET_LSB_DEPTH_REQUEST: | ||
1882 | { | ||
1883 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
1884 | *value=st->lsb_depth; | ||
1885 | } | ||
1886 | break; | ||
1887 | case OPUS_RESET_STATE: | ||
1888 | { | ||
1889 | int i; | ||
1890 | opus_val16 *oldBandE, *oldLogE, *oldLogE2; | ||
1891 | oldBandE = (opus_val16*)(st->in_mem+st->channels*(2*st->overlap+COMBFILTER_MAXPERIOD)); | ||
1892 | oldLogE = oldBandE + st->channels*st->mode->nbEBands; | ||
1893 | oldLogE2 = oldLogE + st->channels*st->mode->nbEBands; | ||
1894 | OPUS_CLEAR((char*)&st->ENCODER_RESET_START, | ||
1895 | opus_custom_encoder_get_size(st->mode, st->channels)- | ||
1896 | ((char*)&st->ENCODER_RESET_START - (char*)st)); | ||
1897 | for (i=0;i<st->channels*st->mode->nbEBands;i++) | ||
1898 | oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT); | ||
1899 | st->vbr_offset = 0; | ||
1900 | st->delayedIntra = 1; | ||
1901 | st->spread_decision = SPREAD_NORMAL; | ||
1902 | st->tonal_average = 256; | ||
1903 | st->hf_average = 0; | ||
1904 | st->tapset_decision = 0; | ||
1905 | } | ||
1906 | break; | ||
1907 | #ifdef CUSTOM_MODES | ||
1908 | case CELT_SET_INPUT_CLIPPING_REQUEST: | ||
1909 | { | ||
1910 | opus_int32 value = va_arg(ap, opus_int32); | ||
1911 | st->clip = value; | ||
1912 | } | ||
1913 | break; | ||
1914 | #endif | ||
1915 | case CELT_SET_SIGNALLING_REQUEST: | ||
1916 | { | ||
1917 | opus_int32 value = va_arg(ap, opus_int32); | ||
1918 | st->signalling = value; | ||
1919 | } | ||
1920 | break; | ||
1921 | case CELT_GET_MODE_REQUEST: | ||
1922 | { | ||
1923 | const CELTMode ** value = va_arg(ap, const CELTMode**); | ||
1924 | if (value==0) | ||
1925 | goto bad_arg; | ||
1926 | *value=st->mode; | ||
1927 | } | ||
1928 | break; | ||
1929 | case OPUS_GET_FINAL_RANGE_REQUEST: | ||
1930 | { | ||
1931 | opus_uint32 * value = va_arg(ap, opus_uint32 *); | ||
1932 | if (value==0) | ||
1933 | goto bad_arg; | ||
1934 | *value=st->rng; | ||
1935 | } | ||
1936 | break; | ||
1937 | default: | ||
1938 | goto bad_request; | ||
1939 | } | ||
1940 | va_end(ap); | ||
1941 | return OPUS_OK; | ||
1942 | bad_arg: | ||
1943 | va_end(ap); | ||
1944 | return OPUS_BAD_ARG; | ||
1945 | bad_request: | ||
1946 | va_end(ap); | ||
1947 | return OPUS_UNIMPLEMENTED; | ||
1948 | } | ||
1949 | #endif | ||
1950 | |||
1951 | /**********************************************************************/ | ||
1952 | /* */ | ||
1953 | /* DECODER */ | ||
1954 | /* */ | ||
1955 | /**********************************************************************/ | ||
1956 | #define DECODE_BUFFER_SIZE 2048 | ||
1957 | |||
1958 | /** Decoder state | ||
1959 | @brief Decoder state | ||
1960 | */ | ||
1961 | struct OpusCustomDecoder { | ||
1962 | const OpusCustomMode *mode; | ||
1963 | int overlap; | ||
1964 | int channels; | ||
1965 | int stream_channels; | ||
1966 | |||
1967 | int downsample; | ||
1968 | int start, end; | ||
1969 | int signalling; | ||
1970 | |||
1971 | /* Everything beyond this point gets cleared on a reset */ | ||
1972 | #define DECODER_RESET_START rng | ||
1973 | |||
1974 | opus_uint32 rng; | ||
1975 | int error; | ||
1976 | int last_pitch_index; | ||
1977 | int loss_count; | ||
1978 | int postfilter_period; | ||
1979 | int postfilter_period_old; | ||
1980 | opus_val16 postfilter_gain; | ||
1981 | opus_val16 postfilter_gain_old; | ||
1982 | int postfilter_tapset; | ||
1983 | int postfilter_tapset_old; | ||
1984 | |||
1985 | celt_sig preemph_memD[2]; | ||
1986 | |||
1987 | celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */ | ||
1988 | /* opus_val16 lpc[], Size = channels*LPC_ORDER */ | ||
1989 | /* opus_val16 oldEBands[], Size = 2*mode->nbEBands */ | ||
1990 | /* opus_val16 oldLogE[], Size = 2*mode->nbEBands */ | ||
1991 | /* opus_val16 oldLogE2[], Size = 2*mode->nbEBands */ | ||
1992 | /* opus_val16 backgroundLogE[], Size = 2*mode->nbEBands */ | ||
1993 | }; | ||
1994 | |||
1995 | int celt_decoder_get_size(int channels) | ||
1996 | { | ||
1997 | const CELTMode *mode = opus_custom_mode_create(48000, 960, NULL); | ||
1998 | return opus_custom_decoder_get_size(mode, channels); | ||
1999 | } | ||
2000 | |||
2001 | OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_get_size(const CELTMode *mode, int channels) | ||
2002 | { | ||
2003 | int size = sizeof(struct CELTDecoder) | ||
2004 | + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig) | ||
2005 | + channels*LPC_ORDER*sizeof(opus_val16) | ||
2006 | + 4*2*mode->nbEBands*sizeof(opus_val16); | ||
2007 | return size; | ||
2008 | } | ||
2009 | |||
2010 | #ifdef CUSTOM_MODES | ||
2011 | CELTDecoder *opus_custom_decoder_create(const CELTMode *mode, int channels, int *error) | ||
2012 | { | ||
2013 | int ret; | ||
2014 | CELTDecoder *st = (CELTDecoder *)opus_alloc(opus_custom_decoder_get_size(mode, channels)); | ||
2015 | ret = opus_custom_decoder_init(st, mode, channels); | ||
2016 | if (ret != OPUS_OK) | ||
2017 | { | ||
2018 | opus_custom_decoder_destroy(st); | ||
2019 | st = NULL; | ||
2020 | } | ||
2021 | if (error) | ||
2022 | *error = ret; | ||
2023 | return st; | ||
2024 | } | ||
2025 | #endif /* CUSTOM_MODES */ | ||
2026 | |||
2027 | int celt_decoder_init(CELTDecoder *st, opus_int32 sampling_rate, int channels) | ||
2028 | { | ||
2029 | int ret; | ||
2030 | ret = opus_custom_decoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels); | ||
2031 | if (ret != OPUS_OK) | ||
2032 | return ret; | ||
2033 | st->downsample = resampling_factor(sampling_rate); | ||
2034 | if (st->downsample==0) | ||
2035 | return OPUS_BAD_ARG; | ||
2036 | else | ||
2037 | return OPUS_OK; | ||
2038 | } | ||
2039 | |||
2040 | OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels) | ||
2041 | { | ||
2042 | if (channels < 0 || channels > 2) | ||
2043 | return OPUS_BAD_ARG; | ||
2044 | |||
2045 | if (st==NULL) | ||
2046 | return OPUS_ALLOC_FAIL; | ||
2047 | |||
2048 | OPUS_CLEAR((char*)st, opus_custom_decoder_get_size(mode, channels)); | ||
2049 | |||
2050 | st->mode = mode; | ||
2051 | st->overlap = mode->overlap; | ||
2052 | st->stream_channels = st->channels = channels; | ||
2053 | |||
2054 | st->downsample = 1; | ||
2055 | st->start = 0; | ||
2056 | st->end = st->mode->effEBands; | ||
2057 | st->signalling = 1; | ||
2058 | |||
2059 | st->loss_count = 0; | ||
2060 | |||
2061 | opus_custom_decoder_ctl(st, OPUS_RESET_STATE); | ||
2062 | |||
2063 | return OPUS_OK; | ||
2064 | } | ||
2065 | |||
2066 | #ifdef CUSTOM_MODES | ||
2067 | void opus_custom_decoder_destroy(CELTDecoder *st) | ||
2068 | { | ||
2069 | opus_free(st); | ||
2070 | } | ||
2071 | #endif /* CUSTOM_MODES */ | ||
2072 | |||
2073 | static void celt_decode_lost(CELTDecoder * OPUS_RESTRICT st, opus_val16 * OPUS_RESTRICT pcm, int N, int LM) | ||
2074 | { | ||
2075 | int c; | ||
2076 | int pitch_index; | ||
2077 | int overlap = st->mode->overlap; | ||
2078 | opus_val16 fade = Q15ONE; | ||
2079 | int i, len; | ||
2080 | const int C = st->channels; | ||
2081 | int offset; | ||
2082 | celt_sig *out_mem[2]; | ||
2083 | celt_sig *decode_mem[2]; | ||
2084 | celt_sig *overlap_mem[2]; | ||
2085 | opus_val16 *lpc; | ||
2086 | opus_val32 *out_syn[2]; | ||
2087 | opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE; | ||
2088 | SAVE_STACK; | ||
2089 | |||
2090 | c=0; do { | ||
2091 | decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap); | ||
2092 | out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD; | ||
2093 | overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE; | ||
2094 | } while (++c<C); | ||
2095 | lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C); | ||
2096 | oldBandE = lpc+C*LPC_ORDER; | ||
2097 | oldLogE = oldBandE + 2*st->mode->nbEBands; | ||
2098 | oldLogE2 = oldLogE + 2*st->mode->nbEBands; | ||
2099 | backgroundLogE = oldLogE2 + 2*st->mode->nbEBands; | ||
2100 | |||
2101 | out_syn[0] = out_mem[0]+MAX_PERIOD-N; | ||
2102 | if (C==2) | ||
2103 | out_syn[1] = out_mem[1]+MAX_PERIOD-N; | ||
2104 | |||
2105 | len = N+st->mode->overlap; | ||
2106 | |||
2107 | if (st->loss_count >= 5 || st->start!=0) | ||
2108 | { | ||
2109 | /* Noise-based PLC/CNG */ | ||
2110 | VARDECL(celt_sig, freq); | ||
2111 | VARDECL(celt_norm, X); | ||
2112 | VARDECL(celt_ener, bandE); | ||
2113 | opus_uint32 seed; | ||
2114 | int effEnd; | ||
2115 | |||
2116 | effEnd = st->end; | ||
2117 | if (effEnd > st->mode->effEBands) | ||
2118 | effEnd = st->mode->effEBands; | ||
2119 | |||
2120 | ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */ | ||
2121 | ALLOC(X, C*N, celt_norm); /**< Interleaved normalised MDCTs */ | ||
2122 | ALLOC(bandE, st->mode->nbEBands*C, celt_ener); | ||
2123 | |||
2124 | if (st->loss_count >= 5) | ||
2125 | log2Amp(st->mode, st->start, st->end, bandE, backgroundLogE, C); | ||
2126 | else { | ||
2127 | /* Energy decay */ | ||
2128 | opus_val16 decay = st->loss_count==0 ? QCONST16(1.5f, DB_SHIFT) : QCONST16(.5f, DB_SHIFT); | ||
2129 | c=0; do | ||
2130 | { | ||
2131 | for (i=st->start;i<st->end;i++) | ||
2132 | oldBandE[c*st->mode->nbEBands+i] -= decay; | ||
2133 | } while (++c<C); | ||
2134 | log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C); | ||
2135 | } | ||
2136 | seed = st->rng; | ||
2137 | for (c=0;c<C;c++) | ||
2138 | { | ||
2139 | for (i=0;i<(st->mode->eBands[st->start]<<LM);i++) | ||
2140 | X[c*N+i] = 0; | ||
2141 | for (i=st->start;i<st->mode->effEBands;i++) | ||
2142 | { | ||
2143 | int j; | ||
2144 | int boffs; | ||
2145 | int blen; | ||
2146 | boffs = N*c+(st->mode->eBands[i]<<LM); | ||
2147 | blen = (st->mode->eBands[i+1]-st->mode->eBands[i])<<LM; | ||
2148 | for (j=0;j<blen;j++) | ||
2149 | { | ||
2150 | seed = celt_lcg_rand(seed); | ||
2151 | X[boffs+j] = (celt_norm)((opus_int32)seed>>20); | ||
2152 | } | ||
2153 | renormalise_vector(X+boffs, blen, Q15ONE); | ||
2154 | } | ||
2155 | for (i=(st->mode->eBands[st->end]<<LM);i<N;i++) | ||
2156 | X[c*N+i] = 0; | ||
2157 | } | ||
2158 | st->rng = seed; | ||
2159 | |||
2160 | denormalise_bands(st->mode, X, freq, bandE, st->mode->effEBands, C, 1<<LM); | ||
2161 | |||
2162 | c=0; do | ||
2163 | for (i=0;i<st->mode->eBands[st->start]<<LM;i++) | ||
2164 | freq[c*N+i] = 0; | ||
2165 | while (++c<C); | ||
2166 | c=0; do { | ||
2167 | int bound = st->mode->eBands[effEnd]<<LM; | ||
2168 | if (st->downsample!=1) | ||
2169 | bound = IMIN(bound, N/st->downsample); | ||
2170 | for (i=bound;i<N;i++) | ||
2171 | freq[c*N+i] = 0; | ||
2172 | } while (++c<C); | ||
2173 | compute_inv_mdcts(st->mode, 0, freq, out_syn, overlap_mem, C, LM); | ||
2174 | } else { | ||
2175 | /* Pitch-based PLC */ | ||
2176 | if (st->loss_count == 0) | ||
2177 | { | ||
2178 | opus_val16 pitch_buf[DECODE_BUFFER_SIZE>>1]; | ||
2179 | /* Corresponds to a min pitch of 67 Hz. It's possible to save CPU in this | ||
2180 | search by using only part of the decode buffer */ | ||
2181 | int poffset = 720; | ||
2182 | pitch_downsample(decode_mem, pitch_buf, DECODE_BUFFER_SIZE, C); | ||
2183 | /* Max pitch is 100 samples (480 Hz) */ | ||
2184 | pitch_search(pitch_buf+((poffset)>>1), pitch_buf, DECODE_BUFFER_SIZE-poffset, | ||
2185 | poffset-100, &pitch_index); | ||
2186 | pitch_index = poffset-pitch_index; | ||
2187 | st->last_pitch_index = pitch_index; | ||
2188 | } else { | ||
2189 | pitch_index = st->last_pitch_index; | ||
2190 | fade = QCONST16(.8f,15); | ||
2191 | } | ||
2192 | |||
2193 | c=0; do { | ||
2194 | VARDECL(opus_val32, e); | ||
2195 | opus_val16 exc[MAX_PERIOD]; | ||
2196 | opus_val32 ac[LPC_ORDER+1]; | ||
2197 | opus_val16 decay = 1; | ||
2198 | opus_val32 S1=0; | ||
2199 | opus_val16 mem[LPC_ORDER]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; | ||
2200 | |||
2201 | ALLOC(e, MAX_PERIOD+2*st->mode->overlap, opus_val32); | ||
2202 | |||
2203 | offset = MAX_PERIOD-pitch_index; | ||
2204 | for (i=0;i<MAX_PERIOD;i++) | ||
2205 | exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT); | ||
2206 | |||
2207 | if (st->loss_count == 0) | ||
2208 | { | ||
2209 | _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap, | ||
2210 | LPC_ORDER, MAX_PERIOD); | ||
2211 | |||
2212 | /* Noise floor -40 dB */ | ||
2213 | #ifdef FIXED_POINT | ||
2214 | ac[0] += SHR32(ac[0],13); | ||
2215 | #else | ||
2216 | ac[0] *= 1.0001f; | ||
2217 | #endif | ||
2218 | /* Lag windowing */ | ||
2219 | for (i=1;i<=LPC_ORDER;i++) | ||
2220 | { | ||
2221 | /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/ | ||
2222 | #ifdef FIXED_POINT | ||
2223 | ac[i] -= MULT16_32_Q15(2*i*i, ac[i]); | ||
2224 | #else | ||
2225 | ac[i] -= ac[i]*(.008f*i)*(.008f*i); | ||
2226 | #endif | ||
2227 | } | ||
2228 | |||
2229 | _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER); | ||
2230 | } | ||
2231 | for (i=0;i<LPC_ORDER;i++) | ||
2232 | mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT); | ||
2233 | celt_fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem); | ||
2234 | /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/ | ||
2235 | /* Check if the waveform is decaying (and if so how fast) */ | ||
2236 | { | ||
2237 | opus_val32 E1=1, E2=1; | ||
2238 | int period; | ||
2239 | if (pitch_index <= MAX_PERIOD/2) | ||
2240 | period = pitch_index; | ||
2241 | else | ||
2242 | period = MAX_PERIOD/2; | ||
2243 | for (i=0;i<period;i++) | ||
2244 | { | ||
2245 | E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8); | ||
2246 | E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8); | ||
2247 | } | ||
2248 | if (E1 > E2) | ||
2249 | E1 = E2; | ||
2250 | decay = celt_sqrt(frac_div32(SHR32(E1,1),E2)); | ||
2251 | } | ||
2252 | |||
2253 | /* Copy excitation, taking decay into account */ | ||
2254 | for (i=0;i<len+st->mode->overlap;i++) | ||
2255 | { | ||
2256 | opus_val16 tmp; | ||
2257 | if (offset+i >= MAX_PERIOD) | ||
2258 | { | ||
2259 | offset -= pitch_index; | ||
2260 | decay = MULT16_16_Q15(decay, decay); | ||
2261 | } | ||
2262 | e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT); | ||
2263 | tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT); | ||
2264 | S1 += SHR32(MULT16_16(tmp,tmp),8); | ||
2265 | } | ||
2266 | for (i=0;i<LPC_ORDER;i++) | ||
2267 | mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT); | ||
2268 | for (i=0;i<len+st->mode->overlap;i++) | ||
2269 | e[i] = MULT16_32_Q15(fade, e[i]); | ||
2270 | celt_iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem); | ||
2271 | |||
2272 | { | ||
2273 | opus_val32 S2=0; | ||
2274 | for (i=0;i<len+overlap;i++) | ||
2275 | { | ||
2276 | opus_val16 tmp = ROUND16(e[i],SIG_SHIFT); | ||
2277 | S2 += SHR32(MULT16_16(tmp,tmp),8); | ||
2278 | } | ||
2279 | /* This checks for an "explosion" in the synthesis */ | ||
2280 | #ifdef FIXED_POINT | ||
2281 | if (!(S1 > SHR32(S2,2))) | ||
2282 | #else | ||
2283 | /* Float test is written this way to catch NaNs at the same time */ | ||
2284 | if (!(S1 > 0.2f*S2)) | ||
2285 | #endif | ||
2286 | { | ||
2287 | for (i=0;i<len+overlap;i++) | ||
2288 | e[i] = 0; | ||
2289 | } else if (S1 < S2) | ||
2290 | { | ||
2291 | opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1)); | ||
2292 | for (i=0;i<len+overlap;i++) | ||
2293 | e[i] = MULT16_32_Q15(ratio, e[i]); | ||
2294 | } | ||
2295 | } | ||
2296 | |||
2297 | /* Apply post-filter to the MDCT overlap of the previous frame */ | ||
2298 | comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap, | ||
2299 | st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset, | ||
2300 | NULL, 0); | ||
2301 | |||
2302 | for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++) | ||
2303 | out_mem[c][i] = out_mem[c][N+i]; | ||
2304 | |||
2305 | /* Apply TDAC to the concealed audio so that it blends with the | ||
2306 | previous and next frames */ | ||
2307 | for (i=0;i<overlap/2;i++) | ||
2308 | { | ||
2309 | opus_val32 tmp; | ||
2310 | tmp = MULT16_32_Q15(st->mode->window[i], e[N+overlap-1-i]) + | ||
2311 | MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i ]); | ||
2312 | out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp); | ||
2313 | out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp); | ||
2314 | } | ||
2315 | for (i=0;i<N;i++) | ||
2316 | out_mem[c][MAX_PERIOD-N+i] = e[i]; | ||
2317 | |||
2318 | /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */ | ||
2319 | comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap, | ||
2320 | -st->postfilter_gain, -st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset, | ||
2321 | NULL, 0); | ||
2322 | for (i=0;i<overlap;i++) | ||
2323 | out_mem[c][MAX_PERIOD+i] = e[i]; | ||
2324 | } while (++c<C); | ||
2325 | } | ||
2326 | |||
2327 | deemphasis(out_syn, pcm, N, C, /*st->downsample,*/ st->mode->preemph, st->preemph_memD); | ||
2328 | |||
2329 | st->loss_count++; | ||
2330 | |||
2331 | RESTORE_STACK; | ||
2332 | } | ||
2333 | |||
2334 | #define FREQ_X_BUF_SIZE (2*8*120) /* stereo * nbShortMdcts * shortMdctSize */ | ||
2335 | static celt_sig s_freq[FREQ_X_BUF_SIZE] IBSS_ATTR MEM_ALIGN_ATTR; /* 7680 byte */ | ||
2336 | static celt_norm s_X[FREQ_X_BUF_SIZE] IBSS_ATTR MEM_ALIGN_ATTR; /* 3840 byte */ | ||
2337 | 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) | ||
2338 | { | ||
2339 | int c, i, N; | ||
2340 | int spread_decision; | ||
2341 | opus_int32 bits; | ||
2342 | ec_dec _dec; | ||
2343 | VARDECL(celt_sig, freq); | ||
2344 | VARDECL(celt_norm, X); | ||
2345 | VARDECL(celt_ener, bandE); | ||
2346 | VARDECL(int, fine_quant); | ||
2347 | VARDECL(int, pulses); | ||
2348 | VARDECL(int, cap); | ||
2349 | VARDECL(int, offsets); | ||
2350 | VARDECL(int, fine_priority); | ||
2351 | VARDECL(int, tf_res); | ||
2352 | VARDECL(unsigned char, collapse_masks); | ||
2353 | celt_sig *out_mem[2]; | ||
2354 | celt_sig *decode_mem[2]; | ||
2355 | celt_sig *overlap_mem[2]; | ||
2356 | celt_sig *out_syn[2]; | ||
2357 | opus_val16 *lpc; | ||
2358 | opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE; | ||
2359 | |||
2360 | int shortBlocks; | ||
2361 | int isTransient; | ||
2362 | int intra_ener; | ||
2363 | const int CC = st->channels; | ||
2364 | int LM, M; | ||
2365 | int effEnd; | ||
2366 | int codedBands; | ||
2367 | int alloc_trim; | ||
2368 | int postfilter_pitch; | ||
2369 | opus_val16 postfilter_gain; | ||
2370 | int intensity=0; | ||
2371 | int dual_stereo=0; | ||
2372 | opus_int32 total_bits; | ||
2373 | opus_int32 balance; | ||
2374 | opus_int32 tell; | ||
2375 | int dynalloc_logp; | ||
2376 | int postfilter_tapset; | ||
2377 | int anti_collapse_rsv; | ||
2378 | int anti_collapse_on=0; | ||
2379 | int silence; | ||
2380 | int C = st->stream_channels; | ||
2381 | ALLOC_STACK; | ||
2382 | |||
2383 | frame_size *= st->downsample; | ||
2384 | |||
2385 | c=0; do { | ||
2386 | decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap); | ||
2387 | out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD; | ||
2388 | overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE; | ||
2389 | } while (++c<CC); | ||
2390 | lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*CC); | ||
2391 | oldBandE = lpc+CC*LPC_ORDER; | ||
2392 | oldLogE = oldBandE + 2*st->mode->nbEBands; | ||
2393 | oldLogE2 = oldLogE + 2*st->mode->nbEBands; | ||
2394 | backgroundLogE = oldLogE2 + 2*st->mode->nbEBands; | ||
2395 | |||
2396 | #ifdef CUSTOM_MODES | ||
2397 | if (st->signalling && data!=NULL) | ||
2398 | { | ||
2399 | int data0=data[0]; | ||
2400 | /* Convert "standard mode" to Opus header */ | ||
2401 | if (st->mode->Fs==48000 && st->mode->shortMdctSize==120) | ||
2402 | { | ||
2403 | data0 = fromOpus(data0); | ||
2404 | if (data0<0) | ||
2405 | return OPUS_INVALID_PACKET; | ||
2406 | } | ||
2407 | st->end = IMAX(1, st->mode->effEBands-2*(data0>>5)); | ||
2408 | LM = (data0>>3)&0x3; | ||
2409 | C = 1 + ((data0>>2)&0x1); | ||
2410 | data++; | ||
2411 | len--; | ||
2412 | if (LM>st->mode->maxLM) | ||
2413 | return OPUS_INVALID_PACKET; | ||
2414 | if (frame_size < st->mode->shortMdctSize<<LM) | ||
2415 | return OPUS_BUFFER_TOO_SMALL; | ||
2416 | else | ||
2417 | frame_size = st->mode->shortMdctSize<<LM; | ||
2418 | } else { | ||
2419 | #else | ||
2420 | { | ||
2421 | #endif | ||
2422 | for (LM=0;LM<=st->mode->maxLM;LM++) | ||
2423 | if (st->mode->shortMdctSize<<LM==frame_size) | ||
2424 | break; | ||
2425 | if (LM>st->mode->maxLM) | ||
2426 | return OPUS_BAD_ARG; | ||
2427 | } | ||
2428 | M=1<<LM; | ||
2429 | |||
2430 | if (len<0 || len>1275 || pcm==NULL) | ||
2431 | return OPUS_BAD_ARG; | ||
2432 | |||
2433 | N = M*st->mode->shortMdctSize; | ||
2434 | |||
2435 | effEnd = st->end; | ||
2436 | if (effEnd > st->mode->effEBands) | ||
2437 | effEnd = st->mode->effEBands; | ||
2438 | |||
2439 | /**< Interleaved signal MDCTs */ | ||
2440 | if (FREQ_X_BUF_SIZE >= IMAX(CC,C)*N) | ||
2441 | freq = s_freq; | ||
2442 | else | ||
2443 | ALLOC(freq, IMAX(CC,C)*N, celt_sig); | ||
2444 | |||
2445 | /**< Interleaved normalised MDCTs */ | ||
2446 | if (FREQ_X_BUF_SIZE >= C*N) | ||
2447 | X = s_X; | ||
2448 | else | ||
2449 | ALLOC(X, C*N, celt_norm); | ||
2450 | |||
2451 | ALLOC(bandE, st->mode->nbEBands*C, celt_ener); | ||
2452 | c=0; do | ||
2453 | for (i=0;i<M*st->mode->eBands[st->start];i++) | ||
2454 | X[c*N+i] = 0; | ||
2455 | while (++c<C); | ||
2456 | c=0; do | ||
2457 | for (i=M*st->mode->eBands[effEnd];i<N;i++) | ||
2458 | X[c*N+i] = 0; | ||
2459 | while (++c<C); | ||
2460 | |||
2461 | if (data == NULL || len<=1) | ||
2462 | { | ||
2463 | celt_decode_lost(st, pcm, N, LM); | ||
2464 | RESTORE_STACK; | ||
2465 | return frame_size/st->downsample; | ||
2466 | } | ||
2467 | |||
2468 | if (dec == NULL) | ||
2469 | { | ||
2470 | ec_dec_init(&_dec,(unsigned char*)data,len); | ||
2471 | dec = &_dec; | ||
2472 | } | ||
2473 | |||
2474 | if (C==1) | ||
2475 | { | ||
2476 | for (i=0;i<st->mode->nbEBands;i++) | ||
2477 | oldBandE[i]=MAX16(oldBandE[i],oldBandE[st->mode->nbEBands+i]); | ||
2478 | } | ||
2479 | |||
2480 | total_bits = len*8; | ||
2481 | tell = ec_tell(dec); | ||
2482 | |||
2483 | if (tell >= total_bits) | ||
2484 | silence = 1; | ||
2485 | else if (tell==1) | ||
2486 | silence = ec_dec_bit_logp(dec, 15); | ||
2487 | else | ||
2488 | silence = 0; | ||
2489 | if (silence) | ||
2490 | { | ||
2491 | /* Pretend we've read all the remaining bits */ | ||
2492 | tell = len*8; | ||
2493 | dec->nbits_total+=tell-ec_tell(dec); | ||
2494 | } | ||
2495 | |||
2496 | postfilter_gain = 0; | ||
2497 | postfilter_pitch = 0; | ||
2498 | postfilter_tapset = 0; | ||
2499 | if (st->start==0 && tell+16 <= total_bits) | ||
2500 | { | ||
2501 | if(ec_dec_bit_logp(dec, 1)) | ||
2502 | { | ||
2503 | int qg, octave; | ||
2504 | octave = ec_dec_uint(dec, 6); | ||
2505 | postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1; | ||
2506 | qg = ec_dec_bits(dec, 3); | ||
2507 | if (ec_tell(dec)+2<=total_bits) | ||
2508 | postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2); | ||
2509 | postfilter_gain = QCONST16(.09375f,15)*(qg+1); | ||
2510 | } | ||
2511 | tell = ec_tell(dec); | ||
2512 | } | ||
2513 | |||
2514 | if (LM > 0 && tell+3 <= total_bits) | ||
2515 | { | ||
2516 | isTransient = ec_dec_bit_logp(dec, 3); | ||
2517 | tell = ec_tell(dec); | ||
2518 | } | ||
2519 | else | ||
2520 | isTransient = 0; | ||
2521 | |||
2522 | if (isTransient) | ||
2523 | shortBlocks = M; | ||
2524 | else | ||
2525 | shortBlocks = 0; | ||
2526 | |||
2527 | /* Decode the global flags (first symbols in the stream) */ | ||
2528 | intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0; | ||
2529 | /* Get band energies */ | ||
2530 | unquant_coarse_energy(st->mode, st->start, st->end, oldBandE, | ||
2531 | intra_ener, dec, C, LM); | ||
2532 | |||
2533 | ALLOC(tf_res, st->mode->nbEBands, int); | ||
2534 | tf_decode(st->start, st->end, isTransient, tf_res, LM, dec); | ||
2535 | |||
2536 | tell = ec_tell(dec); | ||
2537 | spread_decision = SPREAD_NORMAL; | ||
2538 | if (tell+4 <= total_bits) | ||
2539 | spread_decision = ec_dec_icdf(dec, spread_icdf, 5); | ||
2540 | |||
2541 | ALLOC(pulses, st->mode->nbEBands, int); | ||
2542 | ALLOC(cap, st->mode->nbEBands, int); | ||
2543 | ALLOC(offsets, st->mode->nbEBands, int); | ||
2544 | ALLOC(fine_priority, st->mode->nbEBands, int); | ||
2545 | |||
2546 | init_caps(st->mode,cap,LM,C); | ||
2547 | |||
2548 | dynalloc_logp = 6; | ||
2549 | total_bits<<=BITRES; | ||
2550 | tell = ec_tell_frac(dec); | ||
2551 | for (i=st->start;i<st->end;i++) | ||
2552 | { | ||
2553 | int width, quanta; | ||
2554 | int dynalloc_loop_logp; | ||
2555 | int boost; | ||
2556 | width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM; | ||
2557 | /* quanta is 6 bits, but no more than 1 bit/sample | ||
2558 | and no less than 1/8 bit/sample */ | ||
2559 | quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width)); | ||
2560 | dynalloc_loop_logp = dynalloc_logp; | ||
2561 | boost = 0; | ||
2562 | while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i]) | ||
2563 | { | ||
2564 | int flag; | ||
2565 | flag = ec_dec_bit_logp(dec, dynalloc_loop_logp); | ||
2566 | tell = ec_tell_frac(dec); | ||
2567 | if (!flag) | ||
2568 | break; | ||
2569 | boost += quanta; | ||
2570 | total_bits -= quanta; | ||
2571 | dynalloc_loop_logp = 1; | ||
2572 | } | ||
2573 | offsets[i] = boost; | ||
2574 | /* Making dynalloc more likely */ | ||
2575 | if (boost>0) | ||
2576 | dynalloc_logp = IMAX(2, dynalloc_logp-1); | ||
2577 | } | ||
2578 | |||
2579 | ALLOC(fine_quant, st->mode->nbEBands, int); | ||
2580 | alloc_trim = tell+(6<<BITRES) <= total_bits ? | ||
2581 | ec_dec_icdf(dec, trim_icdf, 7) : 5; | ||
2582 | |||
2583 | bits = (((opus_int32)len*8)<<BITRES) - ec_tell_frac(dec) - 1; | ||
2584 | anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0; | ||
2585 | bits -= anti_collapse_rsv; | ||
2586 | codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap, | ||
2587 | alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses, | ||
2588 | fine_quant, fine_priority, C, LM, dec, 0, 0); | ||
2589 | |||
2590 | unquant_fine_energy(st->mode, st->start, st->end, oldBandE, fine_quant, dec, C); | ||
2591 | |||
2592 | /* Decode fixed codebook */ | ||
2593 | ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char); | ||
2594 | quant_all_bands(0, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks, | ||
2595 | NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res, | ||
2596 | len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng); | ||
2597 | |||
2598 | if (anti_collapse_rsv > 0) | ||
2599 | { | ||
2600 | anti_collapse_on = ec_dec_bits(dec, 1); | ||
2601 | } | ||
2602 | |||
2603 | unquant_energy_finalise(st->mode, st->start, st->end, oldBandE, | ||
2604 | fine_quant, fine_priority, len*8-ec_tell(dec), dec, C); | ||
2605 | |||
2606 | if (anti_collapse_on) | ||
2607 | anti_collapse(st->mode, X, collapse_masks, LM, C, N, | ||
2608 | st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng); | ||
2609 | |||
2610 | log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C); | ||
2611 | |||
2612 | if (silence) | ||
2613 | { | ||
2614 | for (i=0;i<C*st->mode->nbEBands;i++) | ||
2615 | { | ||
2616 | bandE[i] = 0; | ||
2617 | oldBandE[i] = -QCONST16(28.f,DB_SHIFT); | ||
2618 | } | ||
2619 | } | ||
2620 | /* Synthesis */ | ||
2621 | denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M); | ||
2622 | |||
2623 | OPUS_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N); | ||
2624 | if (CC==2) | ||
2625 | OPUS_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N); | ||
2626 | |||
2627 | c=0; do | ||
2628 | for (i=0;i<M*st->mode->eBands[st->start];i++) | ||
2629 | freq[c*N+i] = 0; | ||
2630 | while (++c<C); | ||
2631 | c=0; do { | ||
2632 | int bound = M*st->mode->eBands[effEnd]; | ||
2633 | if (st->downsample!=1) | ||
2634 | bound = IMIN(bound, N/st->downsample); | ||
2635 | for (i=bound;i<N;i++) | ||
2636 | freq[c*N+i] = 0; | ||
2637 | } while (++c<C); | ||
2638 | |||
2639 | out_syn[0] = out_mem[0]+MAX_PERIOD-N; | ||
2640 | if (CC==2) | ||
2641 | out_syn[1] = out_mem[1]+MAX_PERIOD-N; | ||
2642 | |||
2643 | if (CC==2&&C==1) | ||
2644 | { | ||
2645 | for (i=0;i<N;i++) | ||
2646 | freq[N+i] = freq[i]; | ||
2647 | } | ||
2648 | if (CC==1&&C==2) | ||
2649 | { | ||
2650 | for (i=0;i<N;i++) | ||
2651 | freq[i] = HALF32(ADD32(freq[i],freq[N+i])); | ||
2652 | } | ||
2653 | |||
2654 | /* Compute inverse MDCTs */ | ||
2655 | compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, CC, LM); | ||
2656 | |||
2657 | c=0; do { | ||
2658 | st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD); | ||
2659 | st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD); | ||
2660 | comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, st->mode->shortMdctSize, | ||
2661 | st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset, | ||
2662 | st->mode->window, st->overlap); | ||
2663 | if (LM!=0) | ||
2664 | comb_filter(out_syn[c]+st->mode->shortMdctSize, out_syn[c]+st->mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-st->mode->shortMdctSize, | ||
2665 | st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset, | ||
2666 | st->mode->window, st->mode->overlap); | ||
2667 | |||
2668 | } while (++c<CC); | ||
2669 | st->postfilter_period_old = st->postfilter_period; | ||
2670 | st->postfilter_gain_old = st->postfilter_gain; | ||
2671 | st->postfilter_tapset_old = st->postfilter_tapset; | ||
2672 | st->postfilter_period = postfilter_pitch; | ||
2673 | st->postfilter_gain = postfilter_gain; | ||
2674 | st->postfilter_tapset = postfilter_tapset; | ||
2675 | if (LM!=0) | ||
2676 | { | ||
2677 | st->postfilter_period_old = st->postfilter_period; | ||
2678 | st->postfilter_gain_old = st->postfilter_gain; | ||
2679 | st->postfilter_tapset_old = st->postfilter_tapset; | ||
2680 | } | ||
2681 | |||
2682 | if (C==1) { | ||
2683 | for (i=0;i<st->mode->nbEBands;i++) | ||
2684 | oldBandE[st->mode->nbEBands+i]=oldBandE[i]; | ||
2685 | } | ||
2686 | |||
2687 | /* In case start or end were to change */ | ||
2688 | if (!isTransient) | ||
2689 | { | ||
2690 | for (i=0;i<2*st->mode->nbEBands;i++) | ||
2691 | oldLogE2[i] = oldLogE[i]; | ||
2692 | for (i=0;i<2*st->mode->nbEBands;i++) | ||
2693 | oldLogE[i] = oldBandE[i]; | ||
2694 | for (i=0;i<2*st->mode->nbEBands;i++) | ||
2695 | backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]); | ||
2696 | } else { | ||
2697 | for (i=0;i<2*st->mode->nbEBands;i++) | ||
2698 | oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]); | ||
2699 | } | ||
2700 | c=0; do | ||
2701 | { | ||
2702 | for (i=0;i<st->start;i++) | ||
2703 | { | ||
2704 | oldBandE[c*st->mode->nbEBands+i]=0; | ||
2705 | oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT); | ||
2706 | } | ||
2707 | for (i=st->end;i<st->mode->nbEBands;i++) | ||
2708 | { | ||
2709 | oldBandE[c*st->mode->nbEBands+i]=0; | ||
2710 | oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT); | ||
2711 | } | ||
2712 | } while (++c<2); | ||
2713 | st->rng = dec->rng; | ||
2714 | |||
2715 | deemphasis(out_syn, pcm, N, CC, /*st->downsample,*/ st->mode->preemph, st->preemph_memD); | ||
2716 | st->loss_count = 0; | ||
2717 | RESTORE_STACK; | ||
2718 | if (ec_tell(dec) > 8*len) | ||
2719 | return OPUS_INTERNAL_ERROR; | ||
2720 | if(ec_get_error(dec)) | ||
2721 | st->error = 1; | ||
2722 | return frame_size/st->downsample; | ||
2723 | } | ||
2724 | |||
2725 | |||
2726 | #ifdef CUSTOM_MODES | ||
2727 | |||
2728 | #ifdef FIXED_POINT | ||
2729 | int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size) | ||
2730 | { | ||
2731 | return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL); | ||
2732 | } | ||
2733 | |||
2734 | #ifndef DISABLE_FLOAT_API | ||
2735 | int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size) | ||
2736 | { | ||
2737 | int j, ret, C, N; | ||
2738 | VARDECL(opus_int16, out); | ||
2739 | ALLOC_STACK; | ||
2740 | |||
2741 | if (pcm==NULL) | ||
2742 | return OPUS_BAD_ARG; | ||
2743 | |||
2744 | C = st->channels; | ||
2745 | N = frame_size; | ||
2746 | |||
2747 | ALLOC(out, C*N, opus_int16); | ||
2748 | ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL); | ||
2749 | if (ret>0) | ||
2750 | for (j=0;j<C*ret;j++) | ||
2751 | pcm[j]=out[j]*(1.f/32768.f); | ||
2752 | |||
2753 | RESTORE_STACK; | ||
2754 | return ret; | ||
2755 | } | ||
2756 | #endif /* DISABLE_FLOAT_API */ | ||
2757 | |||
2758 | #else | ||
2759 | |||
2760 | int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size) | ||
2761 | { | ||
2762 | return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL); | ||
2763 | } | ||
2764 | |||
2765 | int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size) | ||
2766 | { | ||
2767 | int j, ret, C, N; | ||
2768 | VARDECL(celt_sig, out); | ||
2769 | ALLOC_STACK; | ||
2770 | |||
2771 | if (pcm==NULL) | ||
2772 | return OPUS_BAD_ARG; | ||
2773 | |||
2774 | C = st->channels; | ||
2775 | N = frame_size; | ||
2776 | ALLOC(out, C*N, celt_sig); | ||
2777 | |||
2778 | ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL); | ||
2779 | |||
2780 | if (ret>0) | ||
2781 | for (j=0;j<C*ret;j++) | ||
2782 | pcm[j] = FLOAT2INT16 (out[j]); | ||
2783 | |||
2784 | RESTORE_STACK; | ||
2785 | return ret; | ||
2786 | } | ||
2787 | |||
2788 | #endif | ||
2789 | #endif /* CUSTOM_MODES */ | ||
2790 | |||
2791 | int opus_custom_decoder_ctl(CELTDecoder * OPUS_RESTRICT st, int request, ...) | ||
2792 | { | ||
2793 | va_list ap; | ||
2794 | |||
2795 | va_start(ap, request); | ||
2796 | switch (request) | ||
2797 | { | ||
2798 | case CELT_SET_START_BAND_REQUEST: | ||
2799 | { | ||
2800 | opus_int32 value = va_arg(ap, opus_int32); | ||
2801 | if (value<0 || value>=st->mode->nbEBands) | ||
2802 | goto bad_arg; | ||
2803 | st->start = value; | ||
2804 | } | ||
2805 | break; | ||
2806 | case CELT_SET_END_BAND_REQUEST: | ||
2807 | { | ||
2808 | opus_int32 value = va_arg(ap, opus_int32); | ||
2809 | if (value<1 || value>st->mode->nbEBands) | ||
2810 | goto bad_arg; | ||
2811 | st->end = value; | ||
2812 | } | ||
2813 | break; | ||
2814 | case CELT_SET_CHANNELS_REQUEST: | ||
2815 | { | ||
2816 | opus_int32 value = va_arg(ap, opus_int32); | ||
2817 | if (value<1 || value>2) | ||
2818 | goto bad_arg; | ||
2819 | st->stream_channels = value; | ||
2820 | } | ||
2821 | break; | ||
2822 | case CELT_GET_AND_CLEAR_ERROR_REQUEST: | ||
2823 | { | ||
2824 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2825 | if (value==NULL) | ||
2826 | goto bad_arg; | ||
2827 | *value=st->error; | ||
2828 | st->error = 0; | ||
2829 | } | ||
2830 | break; | ||
2831 | case OPUS_GET_LOOKAHEAD_REQUEST: | ||
2832 | { | ||
2833 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2834 | if (value==NULL) | ||
2835 | goto bad_arg; | ||
2836 | *value = st->overlap/st->downsample; | ||
2837 | } | ||
2838 | break; | ||
2839 | case OPUS_RESET_STATE: | ||
2840 | { | ||
2841 | int i; | ||
2842 | opus_val16 *lpc, *oldBandE, *oldLogE, *oldLogE2; | ||
2843 | lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*st->channels); | ||
2844 | oldBandE = lpc+st->channels*LPC_ORDER; | ||
2845 | oldLogE = oldBandE + 2*st->mode->nbEBands; | ||
2846 | oldLogE2 = oldLogE + 2*st->mode->nbEBands; | ||
2847 | OPUS_CLEAR((char*)&st->DECODER_RESET_START, | ||
2848 | opus_custom_decoder_get_size(st->mode, st->channels)- | ||
2849 | ((char*)&st->DECODER_RESET_START - (char*)st)); | ||
2850 | for (i=0;i<2*st->mode->nbEBands;i++) | ||
2851 | oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT); | ||
2852 | } | ||
2853 | break; | ||
2854 | case OPUS_GET_PITCH_REQUEST: | ||
2855 | { | ||
2856 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2857 | if (value==NULL) | ||
2858 | goto bad_arg; | ||
2859 | *value = st->postfilter_period; | ||
2860 | } | ||
2861 | break; | ||
2862 | #ifdef OPUS_BUILD | ||
2863 | case CELT_GET_MODE_REQUEST: | ||
2864 | { | ||
2865 | const CELTMode ** value = va_arg(ap, const CELTMode**); | ||
2866 | if (value==0) | ||
2867 | goto bad_arg; | ||
2868 | *value=st->mode; | ||
2869 | } | ||
2870 | break; | ||
2871 | case CELT_SET_SIGNALLING_REQUEST: | ||
2872 | { | ||
2873 | opus_int32 value = va_arg(ap, opus_int32); | ||
2874 | st->signalling = value; | ||
2875 | } | ||
2876 | break; | ||
2877 | case OPUS_GET_FINAL_RANGE_REQUEST: | ||
2878 | { | ||
2879 | opus_uint32 * value = va_arg(ap, opus_uint32 *); | ||
2880 | if (value==0) | ||
2881 | goto bad_arg; | ||
2882 | *value=st->rng; | ||
2883 | } | ||
2884 | break; | ||
2885 | #endif | ||
2886 | default: | ||
2887 | goto bad_request; | ||
2888 | } | ||
2889 | va_end(ap); | ||
2890 | return OPUS_OK; | ||
2891 | bad_arg: | ||
2892 | va_end(ap); | ||
2893 | return OPUS_BAD_ARG; | ||
2894 | bad_request: | ||
2895 | va_end(ap); | ||
2896 | return OPUS_UNIMPLEMENTED; | ||
2897 | } | ||
2898 | |||
2899 | 193 | ||
2900 | 194 | ||
2901 | const char *opus_strerror(int error) | 195 | const char *opus_strerror(int error) |
@@ -2918,7 +212,7 @@ const char *opus_strerror(int error) | |||
2918 | 212 | ||
2919 | const char *opus_get_version_string(void) | 213 | const char *opus_get_version_string(void) |
2920 | { | 214 | { |
2921 | return "libopus " OPUS_VERSION | 215 | return "libopus " PACKAGE_VERSION |
2922 | #ifdef FIXED_POINT | 216 | #ifdef FIXED_POINT |
2923 | "-fixed" | 217 | "-fixed" |
2924 | #endif | 218 | #endif |