The Tor Browser / file comparison

comparison: media/libopus/src/opus_decoder.c

media/libopus/src/opus_decoder.c

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:a94e01526e25
1 /* Copyright (c) 2010 Xiph.Org Foundation, Skype Limited
2 Written by Jean-Marc Valin and Koen Vos */
3 /*
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions
6 are met:
7
8 - Redistributions of source code must retain the above copyright
9 notice, this list of conditions and the following disclaimer.
10
11 - Redistributions in binary form must reproduce the above copyright
12 notice, this list of conditions and the following disclaimer in the
13 documentation and/or other materials provided with the distribution.
14
15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
19 OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #ifndef OPUS_BUILD
33 # error "OPUS_BUILD _MUST_ be defined to build Opus. This probably means you need other defines as well, as in a config.h. See the included build files for details."
34 #endif
35
36 #if defined(__GNUC__) && (__GNUC__ >= 2) && !defined(__OPTIMIZE__)
37 # pragma message "You appear to be compiling without optimization, if so opus will be very slow."
38 #endif
39
40 #include <stdarg.h>
41 #include "celt.h"
42 #include "opus.h"
43 #include "entdec.h"
44 #include "modes.h"
45 #include "API.h"
46 #include "stack_alloc.h"
47 #include "float_cast.h"
48 #include "opus_private.h"
49 #include "os_support.h"
50 #include "structs.h"
51 #include "define.h"
52 #include "mathops.h"
53 #include "cpu_support.h"
54
55 struct OpusDecoder {
56 int celt_dec_offset;
57 int silk_dec_offset;
58 int channels;
59 opus_int32 Fs; /** Sampling rate (at the API level) */
60 silk_DecControlStruct DecControl;
61 int decode_gain;
62
63 /* Everything beyond this point gets cleared on a reset */
64 #define OPUS_DECODER_RESET_START stream_channels
65 int stream_channels;
66
67 int bandwidth;
68 int mode;
69 int prev_mode;
70 int frame_size;
71 int prev_redundancy;
72 int last_packet_duration;
73 #ifndef FIXED_POINT
74 opus_val16 softclip_mem[2];
75 #endif
76
77 opus_uint32 rangeFinal;
78 };
79
80 #ifdef FIXED_POINT
81 static OPUS_INLINE opus_int16 SAT16(opus_int32 x) {
82 return x > 32767 ? 32767 : x < -32768 ? -32768 : (opus_int16)x;
83 }
84 #endif
85
86
87 int opus_decoder_get_size(int channels)
88 {
89 int silkDecSizeBytes, celtDecSizeBytes;
90 int ret;
91 if (channels<1 || channels > 2)
92 return 0;
93 ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
94 if(ret)
95 return 0;
96 silkDecSizeBytes = align(silkDecSizeBytes);
97 celtDecSizeBytes = celt_decoder_get_size(channels);
98 return align(sizeof(OpusDecoder))+silkDecSizeBytes+celtDecSizeBytes;
99 }
100
101 int opus_decoder_init(OpusDecoder *st, opus_int32 Fs, int channels)
102 {
103 void *silk_dec;
104 CELTDecoder *celt_dec;
105 int ret, silkDecSizeBytes;
106
107 if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)
108 || (channels!=1&&channels!=2))
109 return OPUS_BAD_ARG;
110
111 OPUS_CLEAR((char*)st, opus_decoder_get_size(channels));
112 /* Initialize SILK encoder */
113 ret = silk_Get_Decoder_Size(&silkDecSizeBytes);
114 if (ret)
115 return OPUS_INTERNAL_ERROR;
116
117 silkDecSizeBytes = align(silkDecSizeBytes);
118 st->silk_dec_offset = align(sizeof(OpusDecoder));
119 st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes;
120 silk_dec = (char*)st+st->silk_dec_offset;
121 celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
122 st->stream_channels = st->channels = channels;
123
124 st->Fs = Fs;
125 st->DecControl.API_sampleRate = st->Fs;
126 st->DecControl.nChannelsAPI = st->channels;
127
128 /* Reset decoder */
129 ret = silk_InitDecoder( silk_dec );
130 if(ret)return OPUS_INTERNAL_ERROR;
131
132 /* Initialize CELT decoder */
133 ret = celt_decoder_init(celt_dec, Fs, channels);
134 if(ret!=OPUS_OK)return OPUS_INTERNAL_ERROR;
135
136 celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));
137
138 st->prev_mode = 0;
139 st->frame_size = Fs/400;
140 return OPUS_OK;
141 }
142
143 OpusDecoder *opus_decoder_create(opus_int32 Fs, int channels, int *error)
144 {
145 int ret;
146 OpusDecoder *st;
147 if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)
148 || (channels!=1&&channels!=2))
149 {
150 if (error)
151 *error = OPUS_BAD_ARG;
152 return NULL;
153 }
154 st = (OpusDecoder *)opus_alloc(opus_decoder_get_size(channels));
155 if (st == NULL)
156 {
157 if (error)
158 *error = OPUS_ALLOC_FAIL;
159 return NULL;
160 }
161 ret = opus_decoder_init(st, Fs, channels);
162 if (error)
163 *error = ret;
164 if (ret != OPUS_OK)
165 {
166 opus_free(st);
167 st = NULL;
168 }
169 return st;
170 }
171
172 static void smooth_fade(const opus_val16 *in1, const opus_val16 *in2,
173 opus_val16 *out, int overlap, int channels,
174 const opus_val16 *window, opus_int32 Fs)
175 {
176 int i, c;
177 int inc = 48000/Fs;
178 for (c=0;c<channels;c++)
179 {
180 for (i=0;i<overlap;i++)
181 {
182 opus_val16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);
183 out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),
184 Q15ONE-w, in1[i*channels+c]), 15);
185 }
186 }
187 }
188
189 static int opus_packet_get_mode(const unsigned char *data)
190 {
191 int mode;
192 if (data[0]&0x80)
193 {
194 mode = MODE_CELT_ONLY;
195 } else if ((data[0]&0x60) == 0x60)
196 {
197 mode = MODE_HYBRID;
198 } else {
199 mode = MODE_SILK_ONLY;
200 }
201 return mode;
202 }
203
204 static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
205 opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
206 {
207 void *silk_dec;
208 CELTDecoder *celt_dec;
209 int i, silk_ret=0, celt_ret=0;
210 ec_dec dec;
211 opus_int32 silk_frame_size;
212 int pcm_silk_size;
213 VARDECL(opus_int16, pcm_silk);
214 int pcm_transition_silk_size;
215 VARDECL(opus_val16, pcm_transition_silk);
216 int pcm_transition_celt_size;
217 VARDECL(opus_val16, pcm_transition_celt);
218 opus_val16 *pcm_transition;
219 int redundant_audio_size;
220 VARDECL(opus_val16, redundant_audio);
221
222 int audiosize;
223 int mode;
224 int transition=0;
225 int start_band;
226 int redundancy=0;
227 int redundancy_bytes = 0;
228 int celt_to_silk=0;
229 int c;
230 int F2_5, F5, F10, F20;
231 const opus_val16 *window;
232 opus_uint32 redundant_rng = 0;
233 ALLOC_STACK;
234
235 silk_dec = (char*)st+st->silk_dec_offset;
236 celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
237 F20 = st->Fs/50;
238 F10 = F20>>1;
239 F5 = F10>>1;
240 F2_5 = F5>>1;
241 if (frame_size < F2_5)
242 {
243 RESTORE_STACK;
244 return OPUS_BUFFER_TOO_SMALL;
245 }
246 /* Limit frame_size to avoid excessive stack allocations. */
247 frame_size = IMIN(frame_size, st->Fs/25*3);
248 /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */
249 if (len<=1)
250 {
251 data = NULL;
252 /* In that case, don't conceal more than what the ToC says */
253 frame_size = IMIN(frame_size, st->frame_size);
254 }
255 if (data != NULL)
256 {
257 audiosize = st->frame_size;
258 mode = st->mode;
259 ec_dec_init(&dec,(unsigned char*)data,len);
260 } else {
261 audiosize = frame_size;
262 mode = st->prev_mode;
263
264 if (mode == 0)
265 {
266 /* If we haven't got any packet yet, all we can do is return zeros */
267 for (i=0;i<audiosize*st->channels;i++)
268 pcm[i] = 0;
269 RESTORE_STACK;
270 return audiosize;
271 }
272
273 /* Avoids trying to run the PLC on sizes other than 2.5 (CELT), 5 (CELT),
274 10, or 20 (e.g. 12.5 or 30 ms). */
275 if (audiosize > F20)
276 {
277 do {
278 int ret = opus_decode_frame(st, NULL, 0, pcm, IMIN(audiosize, F20), 0);
279 if (ret<0)
280 {
281 RESTORE_STACK;
282 return ret;
283 }
284 pcm += ret*st->channels;
285 audiosize -= ret;
286 } while (audiosize > 0);
287 RESTORE_STACK;
288 return frame_size;
289 } else if (audiosize < F20)
290 {
291 if (audiosize > F10)
292 audiosize = F10;
293 else if (mode != MODE_SILK_ONLY && audiosize > F5 && audiosize < F10)
294 audiosize = F5;
295 }
296 }
297
298 pcm_transition_silk_size = ALLOC_NONE;
299 pcm_transition_celt_size = ALLOC_NONE;
300 if (data!=NULL && st->prev_mode > 0 && (
301 (mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY && !st->prev_redundancy)
302 || (mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) )
303 )
304 {
305 transition = 1;
306 /* Decide where to allocate the stack memory for pcm_transition */
307 if (mode == MODE_CELT_ONLY)
308 pcm_transition_celt_size = F5*st->channels;
309 else
310 pcm_transition_silk_size = F5*st->channels;
311 }
312 ALLOC(pcm_transition_celt, pcm_transition_celt_size, opus_val16);
313 if (transition && mode == MODE_CELT_ONLY)
314 {
315 pcm_transition = pcm_transition_celt;
316 opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
317 }
318 if (audiosize > frame_size)
319 {
320 /*fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);*/
321 RESTORE_STACK;
322 return OPUS_BAD_ARG;
323 } else {
324 frame_size = audiosize;
325 }
326
327 /* Don't allocate any memory when in CELT-only mode */
328 pcm_silk_size = (mode != MODE_CELT_ONLY) ? IMAX(F10, frame_size)*st->channels : ALLOC_NONE;
329 ALLOC(pcm_silk, pcm_silk_size, opus_int16);
330
331 /* SILK processing */
332 if (mode != MODE_CELT_ONLY)
333 {
334 int lost_flag, decoded_samples;
335 opus_int16 *pcm_ptr = pcm_silk;
336
337 if (st->prev_mode==MODE_CELT_ONLY)
338 silk_InitDecoder( silk_dec );
339
340 /* The SILK PLC cannot produce frames of less than 10 ms */
341 st->DecControl.payloadSize_ms = IMAX(10, 1000 * audiosize / st->Fs);
342
343 if (data != NULL)
344 {
345 st->DecControl.nChannelsInternal = st->stream_channels;
346 if( mode == MODE_SILK_ONLY ) {
347 if( st->bandwidth == OPUS_BANDWIDTH_NARROWBAND ) {
348 st->DecControl.internalSampleRate = 8000;
349 } else if( st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND ) {
350 st->DecControl.internalSampleRate = 12000;
351 } else if( st->bandwidth == OPUS_BANDWIDTH_WIDEBAND ) {
352 st->DecControl.internalSampleRate = 16000;
353 } else {
354 st->DecControl.internalSampleRate = 16000;
355 silk_assert( 0 );
356 }
357 } else {
358 /* Hybrid mode */
359 st->DecControl.internalSampleRate = 16000;
360 }
361 }
362
363 lost_flag = data == NULL ? 1 : 2 * decode_fec;
364 decoded_samples = 0;
365 do {
366 /* Call SILK decoder */
367 int first_frame = decoded_samples == 0;
368 silk_ret = silk_Decode( silk_dec, &st->DecControl,
369 lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size );
370 if( silk_ret ) {
371 if (lost_flag) {
372 /* PLC failure should not be fatal */
373 silk_frame_size = frame_size;
374 for (i=0;i<frame_size*st->channels;i++)
375 pcm_ptr[i] = 0;
376 } else {
377 RESTORE_STACK;
378 return OPUS_INTERNAL_ERROR;
379 }
380 }
381 pcm_ptr += silk_frame_size * st->channels;
382 decoded_samples += silk_frame_size;
383 } while( decoded_samples < frame_size );
384 }
385
386 start_band = 0;
387 if (!decode_fec && mode != MODE_CELT_ONLY && data != NULL
388 && ec_tell(&dec)+17+20*(st->mode == MODE_HYBRID) <= 8*len)
389 {
390 /* Check if we have a redundant 0-8 kHz band */
391 if (mode == MODE_HYBRID)
392 redundancy = ec_dec_bit_logp(&dec, 12);
393 else
394 redundancy = 1;
395 if (redundancy)
396 {
397 celt_to_silk = ec_dec_bit_logp(&dec, 1);
398 /* redundancy_bytes will be at least two, in the non-hybrid
399 case due to the ec_tell() check above */
400 redundancy_bytes = mode==MODE_HYBRID ?
401 (opus_int32)ec_dec_uint(&dec, 256)+2 :
402 len-((ec_tell(&dec)+7)>>3);
403 len -= redundancy_bytes;
404 /* This is a sanity check. It should never happen for a valid
405 packet, so the exact behaviour is not normative. */
406 if (len*8 < ec_tell(&dec))
407 {
408 len = 0;
409 redundancy_bytes = 0;
410 redundancy = 0;
411 }
412 /* Shrink decoder because of raw bits */
413 dec.storage -= redundancy_bytes;
414 }
415 }
416 if (mode != MODE_CELT_ONLY)
417 start_band = 17;
418
419 {
420 int endband=21;
421
422 switch(st->bandwidth)
423 {
424 case OPUS_BANDWIDTH_NARROWBAND:
425 endband = 13;
426 break;
427 case OPUS_BANDWIDTH_MEDIUMBAND:
428 case OPUS_BANDWIDTH_WIDEBAND:
429 endband = 17;
430 break;
431 case OPUS_BANDWIDTH_SUPERWIDEBAND:
432 endband = 19;
433 break;
434 case OPUS_BANDWIDTH_FULLBAND:
435 endband = 21;
436 break;
437 }
438 celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband));
439 celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels));
440 }
441
442 if (redundancy)
443 {
444 transition = 0;
445 pcm_transition_silk_size=ALLOC_NONE;
446 }
447
448 ALLOC(pcm_transition_silk, pcm_transition_silk_size, opus_val16);
449
450 if (transition && mode != MODE_CELT_ONLY)
451 {
452 pcm_transition = pcm_transition_silk;
453 opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);
454 }
455
456 /* Only allocation memory for redundancy if/when needed */
457 redundant_audio_size = redundancy ? F5*st->channels : ALLOC_NONE;
458 ALLOC(redundant_audio, redundant_audio_size, opus_val16);
459
460 /* 5 ms redundant frame for CELT->SILK*/
461 if (redundancy && celt_to_silk)
462 {
463 celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
464 celt_decode_with_ec(celt_dec, data+len, redundancy_bytes,
465 redundant_audio, F5, NULL);
466 celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
467 }
468
469 /* MUST be after PLC */
470 celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
471
472 if (mode != MODE_SILK_ONLY)
473 {
474 int celt_frame_size = IMIN(F20, frame_size);
475 /* Make sure to discard any previous CELT state */
476 if (mode != st->prev_mode && st->prev_mode > 0 && !st->prev_redundancy)
477 celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
478 /* Decode CELT */
479 celt_ret = celt_decode_with_ec(celt_dec, decode_fec ? NULL : data,
480 len, pcm, celt_frame_size, &dec);
481 } else {
482 unsigned char silence[2] = {0xFF, 0xFF};
483 for (i=0;i<frame_size*st->channels;i++)
484 pcm[i] = 0;
485 /* For hybrid -> SILK transitions, we let the CELT MDCT
486 do a fade-out by decoding a silence frame */
487 if (st->prev_mode == MODE_HYBRID && !(redundancy && celt_to_silk && st->prev_redundancy) )
488 {
489 celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
490 celt_decode_with_ec(celt_dec, silence, 2, pcm, F2_5, NULL);
491 }
492 }
493
494 if (mode != MODE_CELT_ONLY)
495 {
496 #ifdef FIXED_POINT
497 for (i=0;i<frame_size*st->channels;i++)
498 pcm[i] = SAT16(pcm[i] + pcm_silk[i]);
499 #else
500 for (i=0;i<frame_size*st->channels;i++)
501 pcm[i] = pcm[i] + (opus_val16)((1.f/32768.f)*pcm_silk[i]);
502 #endif
503 }
504
505 {
506 const CELTMode *celt_mode;
507 celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode));
508 window = celt_mode->window;
509 }
510
511 /* 5 ms redundant frame for SILK->CELT */
512 if (redundancy && !celt_to_silk)
513 {
514 celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
515 celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
516
517 celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
518 celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
519 smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
520 pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
521 }
522 if (redundancy && celt_to_silk)
523 {
524 for (c=0;c<st->channels;c++)
525 {
526 for (i=0;i<F2_5;i++)
527 pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];
528 }
529 smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,
530 pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);
531 }
532 if (transition)
533 {
534 if (audiosize >= F5)
535 {
536 for (i=0;i<st->channels*F2_5;i++)
537 pcm[i] = pcm_transition[i];
538 smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,
539 pcm+st->channels*F2_5, F2_5,
540 st->channels, window, st->Fs);
541 } else {
542 /* Not enough time to do a clean transition, but we do it anyway
543 This will not preserve amplitude perfectly and may introduce
544 a bit of temporal aliasing, but it shouldn't be too bad and
545 that's pretty much the best we can do. In any case, generating this
546 transition it pretty silly in the first place */
547 smooth_fade(pcm_transition, pcm,
548 pcm, F2_5,
549 st->channels, window, st->Fs);
550 }
551 }
552
553 if(st->decode_gain)
554 {
555 opus_val32 gain;
556 gain = celt_exp2(MULT16_16_P15(QCONST16(6.48814081e-4f, 25), st->decode_gain));
557 for (i=0;i<frame_size*st->channels;i++)
558 {
559 opus_val32 x;
560 x = MULT16_32_P16(pcm[i],gain);
561 pcm[i] = SATURATE(x, 32767);
562 }
563 }
564
565 if (len <= 1)
566 st->rangeFinal = 0;
567 else
568 st->rangeFinal = dec.rng ^ redundant_rng;
569
570 st->prev_mode = mode;
571 st->prev_redundancy = redundancy && !celt_to_silk;
572
573 if (celt_ret>=0)
574 {
575 if (OPUS_CHECK_ARRAY(pcm, audiosize*st->channels))
576 OPUS_PRINT_INT(audiosize);
577 }
578
579 RESTORE_STACK;
580 return celt_ret < 0 ? celt_ret : audiosize;
581
582 }
583
584 int opus_decode_native(OpusDecoder *st, const unsigned char *data,
585 opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec,
586 int self_delimited, opus_int32 *packet_offset, int soft_clip)
587 {
588 int i, nb_samples;
589 int count, offset;
590 unsigned char toc;
591 int packet_frame_size, packet_bandwidth, packet_mode, packet_stream_channels;
592 /* 48 x 2.5 ms = 120 ms */
593 opus_int16 size[48];
594 if (decode_fec<0 || decode_fec>1)
595 return OPUS_BAD_ARG;
596 /* For FEC/PLC, frame_size has to be to have a multiple of 2.5 ms */
597 if ((decode_fec || len==0 || data==NULL) && frame_size%(st->Fs/400)!=0)
598 return OPUS_BAD_ARG;
599 if (len==0 || data==NULL)
600 {
601 int pcm_count=0;
602 do {
603 int ret;
604 ret = opus_decode_frame(st, NULL, 0, pcm+pcm_count*st->channels, frame_size-pcm_count, 0);
605 if (ret<0)
606 return ret;
607 pcm_count += ret;
608 } while (pcm_count < frame_size);
609 celt_assert(pcm_count == frame_size);
610 if (OPUS_CHECK_ARRAY(pcm, pcm_count*st->channels))
611 OPUS_PRINT_INT(pcm_count);
612 st->last_packet_duration = pcm_count;
613 return pcm_count;
614 } else if (len<0)
615 return OPUS_BAD_ARG;
616
617 packet_mode = opus_packet_get_mode(data);
618 packet_bandwidth = opus_packet_get_bandwidth(data);
619 packet_frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
620 packet_stream_channels = opus_packet_get_nb_channels(data);
621
622 count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL,
623 size, &offset, packet_offset);
624 if (count<0)
625 return count;
626
627 data += offset;
628
629 if (decode_fec)
630 {
631 int duration_copy;
632 int ret;
633 /* If no FEC can be present, run the PLC (recursive call) */
634 if (frame_size < packet_frame_size || packet_mode == MODE_CELT_ONLY || st->mode == MODE_CELT_ONLY)
635 return opus_decode_native(st, NULL, 0, pcm, frame_size, 0, 0, NULL, soft_clip);
636 /* Otherwise, run the PLC on everything except the size for which we might have FEC */
637 duration_copy = st->last_packet_duration;
638 if (frame_size-packet_frame_size!=0)
639 {
640 ret = opus_decode_native(st, NULL, 0, pcm, frame_size-packet_frame_size, 0, 0, NULL, soft_clip);
641 if (ret<0)
642 {
643 st->last_packet_duration = duration_copy;
644 return ret;
645 }
646 celt_assert(ret==frame_size-packet_frame_size);
647 }
648 /* Complete with FEC */
649 st->mode = packet_mode;
650 st->bandwidth = packet_bandwidth;
651 st->frame_size = packet_frame_size;
652 st->stream_channels = packet_stream_channels;
653 ret = opus_decode_frame(st, data, size[0], pcm+st->channels*(frame_size-packet_frame_size),
654 packet_frame_size, 1);
655 if (ret<0)
656 return ret;
657 else {
658 if (OPUS_CHECK_ARRAY(pcm, frame_size*st->channels))
659 OPUS_PRINT_INT(frame_size);
660 st->last_packet_duration = frame_size;
661 return frame_size;
662 }
663 }
664
665 if (count*packet_frame_size > frame_size)
666 return OPUS_BUFFER_TOO_SMALL;
667
668 /* Update the state as the last step to avoid updating it on an invalid packet */
669 st->mode = packet_mode;
670 st->bandwidth = packet_bandwidth;
671 st->frame_size = packet_frame_size;
672 st->stream_channels = packet_stream_channels;
673
674 nb_samples=0;
675 for (i=0;i<count;i++)
676 {
677 int ret;
678 ret = opus_decode_frame(st, data, size[i], pcm+nb_samples*st->channels, frame_size-nb_samples, 0);
679 if (ret<0)
680 return ret;
681 celt_assert(ret==packet_frame_size);
682 data += size[i];
683 nb_samples += ret;
684 }
685 st->last_packet_duration = nb_samples;
686 if (OPUS_CHECK_ARRAY(pcm, nb_samples*st->channels))
687 OPUS_PRINT_INT(nb_samples);
688 #ifndef FIXED_POINT
689 if (soft_clip)
690 opus_pcm_soft_clip(pcm, nb_samples, st->channels, st->softclip_mem);
691 else
692 st->softclip_mem[0]=st->softclip_mem[1]=0;
693 #endif
694 return nb_samples;
695 }
696
697 #ifdef FIXED_POINT
698
699 int opus_decode(OpusDecoder *st, const unsigned char *data,
700 opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
701 {
702 if(frame_size<=0)
703 return OPUS_BAD_ARG;
704 return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);
705 }
706
707 #ifndef DISABLE_FLOAT_API
708 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
709 opus_int32 len, float *pcm, int frame_size, int decode_fec)
710 {
711 VARDECL(opus_int16, out);
712 int ret, i;
713 ALLOC_STACK;
714
715 if(frame_size<=0)
716 {
717 RESTORE_STACK;
718 return OPUS_BAD_ARG;
719 }
720 ALLOC(out, frame_size*st->channels, opus_int16);
721
722 ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 0);
723 if (ret > 0)
724 {
725 for (i=0;i<ret*st->channels;i++)
726 pcm[i] = (1.f/32768.f)*(out[i]);
727 }
728 RESTORE_STACK;
729 return ret;
730 }
731 #endif
732
733
734 #else
735 int opus_decode(OpusDecoder *st, const unsigned char *data,
736 opus_int32 len, opus_int16 *pcm, int frame_size, int decode_fec)
737 {
738 VARDECL(float, out);
739 int ret, i;
740 ALLOC_STACK;
741
742 if(frame_size<=0)
743 {
744 RESTORE_STACK;
745 return OPUS_BAD_ARG;
746 }
747
748 ALLOC(out, frame_size*st->channels, float);
749
750 ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 1);
751 if (ret > 0)
752 {
753 for (i=0;i<ret*st->channels;i++)
754 pcm[i] = FLOAT2INT16(out[i]);
755 }
756 RESTORE_STACK;
757 return ret;
758 }
759
760 int opus_decode_float(OpusDecoder *st, const unsigned char *data,
761 opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)
762 {
763 if(frame_size<=0)
764 return OPUS_BAD_ARG;
765 return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);
766 }
767
768 #endif
769
770 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
771 {
772 int ret = OPUS_OK;
773 va_list ap;
774 void *silk_dec;
775 CELTDecoder *celt_dec;
776
777 silk_dec = (char*)st+st->silk_dec_offset;
778 celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);
779
780
781 va_start(ap, request);
782
783 switch (request)
784 {
785 case OPUS_GET_BANDWIDTH_REQUEST:
786 {
787 opus_int32 *value = va_arg(ap, opus_int32*);
788 if (!value)
789 {
790 goto bad_arg;
791 }
792 *value = st->bandwidth;
793 }
794 break;
795 case OPUS_GET_FINAL_RANGE_REQUEST:
796 {
797 opus_uint32 *value = va_arg(ap, opus_uint32*);
798 if (!value)
799 {
800 goto bad_arg;
801 }
802 *value = st->rangeFinal;
803 }
804 break;
805 case OPUS_RESET_STATE:
806 {
807 OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,
808 sizeof(OpusDecoder)-
809 ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
810
811 celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
812 silk_InitDecoder( silk_dec );
813 st->stream_channels = st->channels;
814 st->frame_size = st->Fs/400;
815 }
816 break;
817 case OPUS_GET_SAMPLE_RATE_REQUEST:
818 {
819 opus_int32 *value = va_arg(ap, opus_int32*);
820 if (!value)
821 {
822 goto bad_arg;
823 }
824 *value = st->Fs;
825 }
826 break;
827 case OPUS_GET_PITCH_REQUEST:
828 {
829 opus_int32 *value = va_arg(ap, opus_int32*);
830 if (!value)
831 {
832 goto bad_arg;
833 }
834 if (st->prev_mode == MODE_CELT_ONLY)
835 celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
836 else
837 *value = st->DecControl.prevPitchLag;
838 }
839 break;
840 case OPUS_GET_GAIN_REQUEST:
841 {
842 opus_int32 *value = va_arg(ap, opus_int32*);
843 if (!value)
844 {
845 goto bad_arg;
846 }
847 *value = st->decode_gain;
848 }
849 break;
850 case OPUS_SET_GAIN_REQUEST:
851 {
852 opus_int32 value = va_arg(ap, opus_int32);
853 if (value<-32768 || value>32767)
854 {
855 goto bad_arg;
856 }
857 st->decode_gain = value;
858 }
859 break;
860 case OPUS_GET_LAST_PACKET_DURATION_REQUEST:
861 {
862 opus_uint32 *value = va_arg(ap, opus_uint32*);
863 if (!value)
864 {
865 goto bad_arg;
866 }
867 *value = st->last_packet_duration;
868 }
869 break;
870 default:
871 /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
872 ret = OPUS_UNIMPLEMENTED;
873 break;
874 }
875
876 va_end(ap);
877 return ret;
878 bad_arg:
879 va_end(ap);
880 return OPUS_BAD_ARG;
881 }
882
883 void opus_decoder_destroy(OpusDecoder *st)
884 {
885 opus_free(st);
886 }
887
888
889 int opus_packet_get_bandwidth(const unsigned char *data)
890 {
891 int bandwidth;
892 if (data[0]&0x80)
893 {
894 bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);
895 if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
896 bandwidth = OPUS_BANDWIDTH_NARROWBAND;
897 } else if ((data[0]&0x60) == 0x60)
898 {
899 bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND :
900 OPUS_BANDWIDTH_SUPERWIDEBAND;
901 } else {
902 bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);
903 }
904 return bandwidth;
905 }
906
907 int opus_packet_get_samples_per_frame(const unsigned char *data,
908 opus_int32 Fs)
909 {
910 int audiosize;
911 if (data[0]&0x80)
912 {
913 audiosize = ((data[0]>>3)&0x3);
914 audiosize = (Fs<<audiosize)/400;
915 } else if ((data[0]&0x60) == 0x60)
916 {
917 audiosize = (data[0]&0x08) ? Fs/50 : Fs/100;
918 } else {
919 audiosize = ((data[0]>>3)&0x3);
920 if (audiosize == 3)
921 audiosize = Fs*60/1000;
922 else
923 audiosize = (Fs<<audiosize)/100;
924 }
925 return audiosize;
926 }
927
928 int opus_packet_get_nb_channels(const unsigned char *data)
929 {
930 return (data[0]&0x4) ? 2 : 1;
931 }
932
933 int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len)
934 {
935 int count;
936 if (len<1)
937 return OPUS_BAD_ARG;
938 count = packet[0]&0x3;
939 if (count==0)
940 return 1;
941 else if (count!=3)
942 return 2;
943 else if (len<2)
944 return OPUS_INVALID_PACKET;
945 else
946 return packet[1]&0x3F;
947 }
948
949 int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len,
950 opus_int32 Fs)
951 {
952 int samples;
953 int count = opus_packet_get_nb_frames(packet, len);
954
955 if (count<0)
956 return count;
957
958 samples = count*opus_packet_get_samples_per_frame(packet, Fs);
959 /* Can't have more than 120 ms */
960 if (samples*25 > Fs*3)
961 return OPUS_INVALID_PACKET;
962 else
963 return samples;
964 }
965
966 int opus_decoder_get_nb_samples(const OpusDecoder *dec,
967 const unsigned char packet[], opus_int32 len)
968 {
969 return opus_packet_get_nb_samples(packet, len, dec->Fs);
970 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial