1use crate::externs::{free, malloc};
2
3pub mod arch_h {
4 pub type opus_val16 = f32;
5 pub type opus_val32 = f32;
6}
7pub mod stddef_h {
8 pub type size_t = u64;
9 pub const NULL: i32 = 0;
10}
11pub mod xmmintrin_h {
12 #[cfg(target_arch = "x86")]
13 pub use core::arch::x86::{__m128, _mm_cvt_ss2si, _mm_cvtss_si32, _mm_set_ss};
14 #[cfg(target_arch = "x86_64")]
15 pub use core::arch::x86_64::{__m128, _mm_cvt_ss2si, _mm_cvtss_si32, _mm_set_ss};
16}
17pub mod cpu_support_h {
18 #[inline]
19 pub unsafe fn opus_select_arch() -> i32 {
20 return 0;
21 }
22}
23pub mod stack_alloc_h {
24 pub const ALLOC_NONE: i32 = 1;
25 #[inline]
26 pub unsafe fn _opus_false() -> i32 {
27 return 0;
28 }
29}
30pub use self::arch_h::{opus_val16, opus_val32};
31pub use self::cpu_support_h::opus_select_arch;
32pub use self::stack_alloc_h::{_opus_false, ALLOC_NONE};
33pub use self::stddef_h::{size_t, NULL};
34use crate::celt::celt::CELT_SET_SIGNALLING_REQUEST;
35use crate::celt::celt_decoder::{
36 celt_decode_with_ec, celt_decoder_get_size, celt_decoder_init, OpusCustomDecoder,
37};
38use crate::celt::entcode::ec_tell;
39use crate::celt::entdec::ec_dec;
40use crate::celt::entdec::{ec_dec_bit_logp, ec_dec_init, ec_dec_uint};
41use crate::celt::float_cast::FLOAT2INT16;
42use crate::celt::mathops::celt_exp2;
43use crate::celt::modes::OpusCustomMode;
44use crate::externs::memset;
45use crate::silk::dec_API::silk_DecControlStruct;
46use crate::silk::dec_API::{silk_Decode, silk_Get_Decoder_Size, silk_InitDecoder};
47use crate::src::opus::opus_packet_parse_impl;
48use crate::src::opus_defines::{
49 OPUS_ALLOC_FAIL, OPUS_BAD_ARG, OPUS_BANDWIDTH_FULLBAND, OPUS_BANDWIDTH_MEDIUMBAND,
50 OPUS_BANDWIDTH_NARROWBAND, OPUS_BANDWIDTH_SUPERWIDEBAND, OPUS_BANDWIDTH_WIDEBAND,
51 OPUS_BUFFER_TOO_SMALL, OPUS_GET_BANDWIDTH_REQUEST, OPUS_GET_FINAL_RANGE_REQUEST,
52 OPUS_GET_GAIN_REQUEST, OPUS_GET_LAST_PACKET_DURATION_REQUEST,
53 OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST, OPUS_GET_PITCH_REQUEST,
54 OPUS_GET_SAMPLE_RATE_REQUEST, OPUS_INTERNAL_ERROR, OPUS_INVALID_PACKET, OPUS_OK,
55 OPUS_RESET_STATE, OPUS_SET_GAIN_REQUEST, OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST,
56 OPUS_UNIMPLEMENTED,
57};
58use crate::src::opus_private::{align, MODE_CELT_ONLY, MODE_HYBRID, MODE_SILK_ONLY};
59use crate::varargs::VarArgs;
60use crate::{opus_custom_decoder_ctl, opus_packet_get_samples_per_frame, opus_pcm_soft_clip};
61
62#[derive(Copy, Clone)]
63#[repr(C)]
64pub struct OpusDecoder {
65 pub(crate) celt_dec_offset: i32,
66 pub(crate) silk_dec_offset: i32,
67 pub(crate) channels: i32,
68 pub(crate) Fs: i32,
69 pub(crate) DecControl: silk_DecControlStruct,
70 pub(crate) decode_gain: i32,
71 pub(crate) arch: i32,
72 pub(crate) stream_channels: i32,
73 pub(crate) bandwidth: i32,
74 pub(crate) mode: i32,
75 pub(crate) prev_mode: i32,
76 pub(crate) frame_size: i32,
77 pub(crate) prev_redundancy: i32,
78 pub(crate) last_packet_duration: i32,
79 pub(crate) softclip_mem: [opus_val16; 2],
80 pub(crate) rangeFinal: u32,
81}
82unsafe fn validate_opus_decoder(st: *mut OpusDecoder) {
83 assert!((*st).channels == 1 || (*st).channels == 2);
84 assert!(
85 (*st).Fs == 48000
86 || (*st).Fs == 24000
87 || (*st).Fs == 16000
88 || (*st).Fs == 12000
89 || (*st).Fs == 8000
90 );
91 assert!((*st).DecControl.API_sampleRate == (*st).Fs);
92 assert!(
93 (*st).DecControl.internalSampleRate == 0
94 || (*st).DecControl.internalSampleRate == 16000
95 || (*st).DecControl.internalSampleRate == 12000
96 || (*st).DecControl.internalSampleRate == 8000
97 );
98 assert!((*st).DecControl.nChannelsAPI == (*st).channels);
99 assert!(
100 (*st).DecControl.nChannelsInternal == 0
101 || (*st).DecControl.nChannelsInternal == 1
102 || (*st).DecControl.nChannelsInternal == 2
103 );
104 assert!(
105 (*st).DecControl.payloadSize_ms == 0
106 || (*st).DecControl.payloadSize_ms == 10
107 || (*st).DecControl.payloadSize_ms == 20
108 || (*st).DecControl.payloadSize_ms == 40
109 || (*st).DecControl.payloadSize_ms == 60
110 );
111 assert!((*st).arch >= 0);
112 assert!((*st).arch <= 0);
113 assert!((*st).stream_channels == 1 || (*st).stream_channels == 2);
114}
115pub unsafe fn opus_decoder_get_size(channels: i32) -> i32 {
116 let mut silkDecSizeBytes: i32 = 0;
117 let mut celtDecSizeBytes: i32 = 0;
118 let mut ret: i32 = 0;
119 if channels < 1 || channels > 2 {
120 return 0;
121 }
122 ret = silk_Get_Decoder_Size(&mut silkDecSizeBytes);
123 if ret != 0 {
124 return 0;
125 }
126 silkDecSizeBytes = align(silkDecSizeBytes);
127 celtDecSizeBytes = celt_decoder_get_size(channels);
128 return align(::core::mem::size_of::<OpusDecoder>() as u64 as i32)
129 + silkDecSizeBytes
130 + celtDecSizeBytes;
131}
132pub unsafe fn opus_decoder_init(st: *mut OpusDecoder, Fs: i32, channels: i32) -> i32 {
133 let mut silk_dec: *mut core::ffi::c_void = 0 as *mut core::ffi::c_void;
134 let mut celt_dec: *mut OpusCustomDecoder = 0 as *mut OpusCustomDecoder;
135 let mut ret: i32 = 0;
136 let mut silkDecSizeBytes: i32 = 0;
137 if Fs != 48000 && Fs != 24000 && Fs != 16000 && Fs != 12000 && Fs != 8000
138 || channels != 1 && channels != 2
139 {
140 return OPUS_BAD_ARG;
141 }
142 memset(
143 st as *mut i8 as *mut core::ffi::c_void,
144 0,
145 (opus_decoder_get_size(channels) as u64).wrapping_mul(::core::mem::size_of::<i8>() as u64),
146 );
147 ret = silk_Get_Decoder_Size(&mut silkDecSizeBytes);
148 if ret != 0 {
149 return OPUS_INTERNAL_ERROR;
150 }
151 silkDecSizeBytes = align(silkDecSizeBytes);
152 (*st).silk_dec_offset = align(::core::mem::size_of::<OpusDecoder>() as u64 as i32);
153 (*st).celt_dec_offset = (*st).silk_dec_offset + silkDecSizeBytes;
154 silk_dec = (st as *mut i8).offset((*st).silk_dec_offset as isize) as *mut core::ffi::c_void;
155 celt_dec = (st as *mut i8).offset((*st).celt_dec_offset as isize) as *mut OpusCustomDecoder;
156 (*st).channels = channels;
157 (*st).stream_channels = (*st).channels;
158 (*st).Fs = Fs;
159 (*st).DecControl.API_sampleRate = (*st).Fs;
160 (*st).DecControl.nChannelsAPI = (*st).channels;
161 ret = silk_InitDecoder(silk_dec);
162 if ret != 0 {
163 return OPUS_INTERNAL_ERROR;
164 }
165 ret = celt_decoder_init(celt_dec, Fs, channels);
166 if ret != OPUS_OK {
167 return OPUS_INTERNAL_ERROR;
168 }
169 opus_custom_decoder_ctl!(celt_dec, CELT_SET_SIGNALLING_REQUEST, 0);
170 (*st).prev_mode = 0;
171 (*st).frame_size = Fs / 400;
172 (*st).arch = opus_select_arch();
173 return OPUS_OK;
174}
175pub unsafe fn opus_decoder_create(Fs: i32, channels: i32, error: *mut i32) -> *mut OpusDecoder {
176 let mut ret: i32 = 0;
177 let mut st: *mut OpusDecoder = 0 as *mut OpusDecoder;
178 if Fs != 48000 && Fs != 24000 && Fs != 16000 && Fs != 12000 && Fs != 8000
179 || channels != 1 && channels != 2
180 {
181 if !error.is_null() {
182 *error = OPUS_BAD_ARG;
183 }
184 return NULL as *mut OpusDecoder;
185 }
186 st = malloc(opus_decoder_get_size(channels) as size_t) as *mut OpusDecoder;
187 if st.is_null() {
188 if !error.is_null() {
189 *error = OPUS_ALLOC_FAIL;
190 }
191 return NULL as *mut OpusDecoder;
192 }
193 ret = opus_decoder_init(st, Fs, channels);
194 if !error.is_null() {
195 *error = ret;
196 }
197 if ret != OPUS_OK {
198 free(st as *mut core::ffi::c_void);
199 st = NULL as *mut OpusDecoder;
200 }
201 return st;
202}
203unsafe fn smooth_fade(
204 in1: *const opus_val16,
205 in2: *const opus_val16,
206 out: *mut opus_val16,
207 overlap: i32,
208 channels: i32,
209 window: *const opus_val16,
210 Fs: i32,
211) {
212 let mut i: i32 = 0;
213 let mut c: i32 = 0;
214 let inc: i32 = 48000 / Fs;
215 c = 0;
216 while c < channels {
217 i = 0;
218 while i < overlap {
219 let w: opus_val16 =
220 *window.offset((i * inc) as isize) * *window.offset((i * inc) as isize);
221 *out.offset((i * channels + c) as isize) = w * *in2.offset((i * channels + c) as isize)
222 + (1.0f32 - w) * *in1.offset((i * channels + c) as isize);
223 i += 1;
224 }
225 c += 1;
226 }
227}
228unsafe fn opus_packet_get_mode(data: *const u8) -> i32 {
229 let mut mode: i32 = 0;
230 if *data.offset(0 as isize) as i32 & 0x80 != 0 {
231 mode = MODE_CELT_ONLY;
232 } else if *data.offset(0 as isize) as i32 & 0x60 == 0x60 {
233 mode = MODE_HYBRID;
234 } else {
235 mode = MODE_SILK_ONLY;
236 }
237 return mode;
238}
239unsafe fn opus_decode_frame(
240 st: *mut OpusDecoder,
241 mut data: *const u8,
242 mut len: i32,
243 mut pcm: *mut opus_val16,
244 mut frame_size: i32,
245 decode_fec: i32,
246) -> i32 {
247 let mut silk_dec: *mut core::ffi::c_void = 0 as *mut core::ffi::c_void;
248 let mut celt_dec: *mut OpusCustomDecoder = 0 as *mut OpusCustomDecoder;
249 let mut i: i32 = 0;
250 let mut silk_ret: i32 = 0;
251 let mut celt_ret: i32 = 0;
252 let mut dec: ec_dec = ec_dec {
253 buf: &mut [],
254 storage: 0,
255 end_offs: 0,
256 end_window: 0,
257 nend_bits: 0,
258 nbits_total: 0,
259 offs: 0,
260 rng: 0,
261 val: 0,
262 ext: 0,
263 rem: 0,
264 error: 0,
265 };
266 let mut silk_frame_size: i32 = 0;
267 let mut pcm_silk_size: i32 = 0;
268 let mut pcm_transition_silk_size: i32 = 0;
269 let mut pcm_transition_celt_size: i32 = 0;
270 let mut pcm_transition: *mut opus_val16 = NULL as *mut opus_val16;
271 let mut redundant_audio_size: i32 = 0;
272 let mut audiosize: i32 = 0;
273 let mut mode: i32 = 0;
274 let mut bandwidth: i32 = 0;
275 let mut transition: i32 = 0;
276 let mut start_band: i32 = 0;
277 let mut redundancy: i32 = 0;
278 let mut redundancy_bytes: i32 = 0;
279 let mut celt_to_silk: i32 = 0;
280 let mut c: i32 = 0;
281 let mut F2_5: i32 = 0;
282 let mut F5: i32 = 0;
283 let mut F10: i32 = 0;
284 let mut F20: i32 = 0;
285 let mut window: *const opus_val16 = 0 as *const opus_val16;
286 let mut redundant_rng: u32 = 0;
287 let mut celt_accum: i32 = 0;
288 silk_dec = (st as *mut i8).offset((*st).silk_dec_offset as isize) as *mut core::ffi::c_void;
289 celt_dec = (st as *mut i8).offset((*st).celt_dec_offset as isize) as *mut OpusCustomDecoder;
290 F20 = (*st).Fs / 50;
291 F10 = F20 >> 1;
292 F5 = F10 >> 1;
293 F2_5 = F5 >> 1;
294 if frame_size < F2_5 {
295 return OPUS_BUFFER_TOO_SMALL;
296 }
297 frame_size = if frame_size < (*st).Fs / 25 * 3 {
298 frame_size
299 } else {
300 (*st).Fs / 25 * 3
301 };
302 if len <= 1 {
303 data = NULL as *const u8;
304 frame_size = if frame_size < (*st).frame_size {
305 frame_size
306 } else {
307 (*st).frame_size
308 };
309 }
310 if !data.is_null() {
311 audiosize = (*st).frame_size;
312 mode = (*st).mode;
313 bandwidth = (*st).bandwidth;
314 dec = ec_dec_init(std::slice::from_raw_parts_mut(
315 data as *mut u8,
316 len as usize,
317 ));
318 } else {
319 audiosize = frame_size;
320 mode = (*st).prev_mode;
321 bandwidth = 0;
322 if mode == 0 {
323 i = 0;
324 while i < audiosize * (*st).channels {
325 *pcm.offset(i as isize) = 0 as opus_val16;
326 i += 1;
327 }
328 return audiosize;
329 }
330 if audiosize > F20 {
331 loop {
332 let ret: i32 = opus_decode_frame(
333 st,
334 NULL as *const u8,
335 0,
336 pcm,
337 if audiosize < F20 { audiosize } else { F20 },
338 0,
339 );
340 if ret < 0 {
341 return ret;
342 }
343 pcm = pcm.offset((ret * (*st).channels) as isize);
344 audiosize -= ret;
345 if !(audiosize > 0) {
346 break;
347 }
348 }
349 return frame_size;
350 } else {
351 if audiosize < F20 {
352 if audiosize > F10 {
353 audiosize = F10;
354 } else if mode != MODE_SILK_ONLY && audiosize > F5 && audiosize < F10 {
355 audiosize = F5;
356 }
357 }
358 }
359 }
360 celt_accum = 0;
361 pcm_transition_silk_size = ALLOC_NONE;
362 pcm_transition_celt_size = ALLOC_NONE;
363 if !data.is_null()
364 && (*st).prev_mode > 0
365 && (mode == MODE_CELT_ONLY
366 && (*st).prev_mode != MODE_CELT_ONLY
367 && (*st).prev_redundancy == 0
368 || mode != MODE_CELT_ONLY && (*st).prev_mode == MODE_CELT_ONLY)
369 {
370 transition = 1;
371 if mode == MODE_CELT_ONLY {
372 pcm_transition_celt_size = F5 * (*st).channels;
373 } else {
374 pcm_transition_silk_size = F5 * (*st).channels;
375 }
376 }
377 let vla = pcm_transition_celt_size as usize;
378 let mut pcm_transition_celt: Vec<opus_val16> = ::std::vec::from_elem(0., vla);
379 if transition != 0 && mode == MODE_CELT_ONLY {
380 pcm_transition = pcm_transition_celt.as_mut_ptr();
381 opus_decode_frame(
382 st,
383 NULL as *const u8,
384 0,
385 pcm_transition,
386 if F5 < audiosize { F5 } else { audiosize },
387 0,
388 );
389 }
390 if audiosize > frame_size {
391 return OPUS_BAD_ARG;
392 } else {
393 frame_size = audiosize;
394 }
395 pcm_silk_size = if mode != MODE_CELT_ONLY && celt_accum == 0 {
396 (if F10 > frame_size { F10 } else { frame_size }) * (*st).channels
397 } else {
398 ALLOC_NONE
399 };
400 let vla_0 = pcm_silk_size as usize;
401 let mut pcm_silk: Vec<i16> = ::std::vec::from_elem(0, vla_0);
402 if mode != MODE_CELT_ONLY {
403 let mut lost_flag: i32 = 0;
404 let mut decoded_samples: i32 = 0;
405 let mut pcm_ptr: *mut i16 = 0 as *mut i16;
406 pcm_ptr = pcm_silk.as_mut_ptr();
407 if (*st).prev_mode == MODE_CELT_ONLY {
408 silk_InitDecoder(silk_dec);
409 }
410 (*st).DecControl.payloadSize_ms = if 10 > 1000 * audiosize / (*st).Fs {
411 10
412 } else {
413 1000 * audiosize / (*st).Fs
414 };
415 if !data.is_null() {
416 (*st).DecControl.nChannelsInternal = (*st).stream_channels;
417 if mode == MODE_SILK_ONLY {
418 if bandwidth == OPUS_BANDWIDTH_NARROWBAND {
419 (*st).DecControl.internalSampleRate = 8000;
420 } else if bandwidth == OPUS_BANDWIDTH_MEDIUMBAND {
421 (*st).DecControl.internalSampleRate = 12000;
422 } else if bandwidth == OPUS_BANDWIDTH_WIDEBAND {
423 (*st).DecControl.internalSampleRate = 16000;
424 } else {
425 (*st).DecControl.internalSampleRate = 16000;
426 panic!("libopus: assert(0) called");
427 }
428 } else {
429 (*st).DecControl.internalSampleRate = 16000;
430 }
431 }
432 lost_flag = if data.is_null() { 1 } else { 2 * decode_fec };
433 decoded_samples = 0;
434 loop {
435 let first_frame: i32 = (decoded_samples == 0) as i32;
436 silk_ret = silk_Decode(
437 silk_dec,
438 &mut (*st).DecControl,
439 lost_flag,
440 first_frame,
441 &mut dec,
442 pcm_ptr,
443 &mut silk_frame_size,
444 (*st).arch,
445 );
446 if silk_ret != 0 {
447 if lost_flag != 0 {
448 silk_frame_size = frame_size;
449 i = 0;
450 while i < frame_size * (*st).channels {
451 *pcm_ptr.offset(i as isize) = 0;
452 i += 1;
453 }
454 } else {
455 return OPUS_INTERNAL_ERROR;
456 }
457 }
458 pcm_ptr = pcm_ptr.offset((silk_frame_size * (*st).channels) as isize);
459 decoded_samples += silk_frame_size;
460 if !(decoded_samples < frame_size) {
461 break;
462 }
463 }
464 }
465 start_band = 0;
466 if decode_fec == 0
467 && mode != MODE_CELT_ONLY
468 && !data.is_null()
469 && ec_tell(&mut dec) + 17 + 20 * ((*st).mode == MODE_HYBRID) as i32 <= 8 * len
470 {
471 if mode == MODE_HYBRID {
472 redundancy = ec_dec_bit_logp(&mut dec, 12);
473 } else {
474 redundancy = 1;
475 }
476 if redundancy != 0 {
477 celt_to_silk = ec_dec_bit_logp(&mut dec, 1);
478 redundancy_bytes = if mode == MODE_HYBRID {
479 ec_dec_uint(&mut dec, 256) as i32 + 2
480 } else {
481 len - (ec_tell(&mut dec) + 7 >> 3)
482 };
483 len -= redundancy_bytes;
484 if (len * 8) < ec_tell(&mut dec) {
485 len = 0;
486 redundancy_bytes = 0;
487 redundancy = 0;
488 }
489 dec.storage = (dec.storage as u32).wrapping_sub(redundancy_bytes as u32) as u32 as u32;
490 }
491 }
492 if mode != MODE_CELT_ONLY {
493 start_band = 17;
494 }
495 if redundancy != 0 {
496 transition = 0;
497 pcm_transition_silk_size = ALLOC_NONE;
498 }
499 let vla_1 = pcm_transition_silk_size as usize;
500 let mut pcm_transition_silk: Vec<opus_val16> = ::std::vec::from_elem(0., vla_1);
501 if transition != 0 && mode != MODE_CELT_ONLY {
502 pcm_transition = pcm_transition_silk.as_mut_ptr();
503 opus_decode_frame(
504 st,
505 NULL as *const u8,
506 0,
507 pcm_transition,
508 if F5 < audiosize { F5 } else { audiosize },
509 0,
510 );
511 }
512 if bandwidth != 0 {
513 let mut endband: i32 = 21;
514 match bandwidth {
515 OPUS_BANDWIDTH_NARROWBAND => {
516 endband = 13;
517 }
518 OPUS_BANDWIDTH_MEDIUMBAND | OPUS_BANDWIDTH_WIDEBAND => {
519 endband = 17;
520 }
521 OPUS_BANDWIDTH_SUPERWIDEBAND => {
522 endband = 19;
523 }
524 OPUS_BANDWIDTH_FULLBAND => {
525 endband = 21;
526 }
527 _ => {
528 panic!("libopus: assert(0) called");
529 }
530 }
531 assert!(opus_custom_decoder_ctl!(celt_dec, 10012, endband) == 0);
532 }
533 assert!(opus_custom_decoder_ctl!(celt_dec, 10008, (*st).stream_channels) == 0);
534 redundant_audio_size = if redundancy != 0 {
535 F5 * (*st).channels
536 } else {
537 ALLOC_NONE
538 };
539 let vla_2 = redundant_audio_size as usize;
540 let mut redundant_audio: Vec<opus_val16> = ::std::vec::from_elem(0., vla_2);
541 if redundancy != 0 && celt_to_silk != 0 {
542 assert!(opus_custom_decoder_ctl!(celt_dec, 10010, 0) == 0);
543 celt_decode_with_ec(
544 celt_dec,
545 data.offset(len as isize),
546 redundancy_bytes,
547 redundant_audio.as_mut_ptr(),
548 F5,
549 None,
550 0,
551 );
552 assert!(opus_custom_decoder_ctl!(celt_dec, 4031, &mut redundant_rng) == 0);
553 }
554 assert!(opus_custom_decoder_ctl!(celt_dec, 10010, start_band) == 0);
555 if mode != MODE_SILK_ONLY {
556 let celt_frame_size: i32 = if F20 < frame_size { F20 } else { frame_size };
557 if mode != (*st).prev_mode && (*st).prev_mode > 0 && (*st).prev_redundancy == 0 {
558 assert!(opus_custom_decoder_ctl!(celt_dec, 4028) == 0);
559 }
560 celt_ret = celt_decode_with_ec(
561 celt_dec,
562 if decode_fec != 0 {
563 NULL as *const u8
564 } else {
565 data
566 },
567 len,
568 pcm,
569 celt_frame_size,
570 Some(&mut dec),
571 celt_accum,
572 );
573 } else {
574 let mut silence: [u8; 2] = [0xff, 0xff];
575 if celt_accum == 0 {
576 i = 0;
577 while i < frame_size * (*st).channels {
578 *pcm.offset(i as isize) = 0 as opus_val16;
579 i += 1;
580 }
581 }
582 if (*st).prev_mode == MODE_HYBRID
583 && !(redundancy != 0 && celt_to_silk != 0 && (*st).prev_redundancy != 0)
584 {
585 assert!(opus_custom_decoder_ctl!(celt_dec, 10010, 0) == 0);
586 celt_decode_with_ec(
587 celt_dec,
588 silence.as_mut_ptr(),
589 2,
590 pcm,
591 F2_5,
592 None,
593 celt_accum,
594 );
595 }
596 }
597 if mode != MODE_CELT_ONLY && celt_accum == 0 {
598 i = 0;
599 while i < frame_size * (*st).channels {
600 *pcm.offset(i as isize) = *pcm.offset(i as isize)
601 + 1.0f32 / 32768.0f32 * *pcm_silk.as_mut_ptr().offset(i as isize) as i32 as f32;
602 i += 1;
603 }
604 }
605 let mut celt_mode: *const OpusCustomMode = 0 as *const OpusCustomMode;
606 assert!(opus_custom_decoder_ctl!(celt_dec, 10015, &mut celt_mode) == 0);
607 window = (*celt_mode).window;
608 if redundancy != 0 && celt_to_silk == 0 {
609 assert!(opus_custom_decoder_ctl!(celt_dec, 4028) == 0);
610 assert!(opus_custom_decoder_ctl!(celt_dec, 10010, 0) == 0);
611 celt_decode_with_ec(
612 celt_dec,
613 data.offset(len as isize),
614 redundancy_bytes,
615 redundant_audio.as_mut_ptr(),
616 F5,
617 None,
618 0,
619 );
620 assert!(opus_custom_decoder_ctl!(celt_dec, 4031, &mut redundant_rng) == 0);
621 smooth_fade(
622 pcm.offset(((*st).channels * (frame_size - F2_5)) as isize),
623 redundant_audio
624 .as_mut_ptr()
625 .offset(((*st).channels * F2_5) as isize),
626 pcm.offset(((*st).channels * (frame_size - F2_5)) as isize),
627 F2_5,
628 (*st).channels,
629 window,
630 (*st).Fs,
631 );
632 }
633 if redundancy != 0 && celt_to_silk != 0 {
634 c = 0;
635 while c < (*st).channels {
636 i = 0;
637 while i < F2_5 {
638 *pcm.offset(((*st).channels * i + c) as isize) = *redundant_audio
639 .as_mut_ptr()
640 .offset(((*st).channels * i + c) as isize);
641 i += 1;
642 }
643 c += 1;
644 }
645 smooth_fade(
646 redundant_audio
647 .as_mut_ptr()
648 .offset(((*st).channels * F2_5) as isize),
649 pcm.offset(((*st).channels * F2_5) as isize),
650 pcm.offset(((*st).channels * F2_5) as isize),
651 F2_5,
652 (*st).channels,
653 window,
654 (*st).Fs,
655 );
656 }
657 if transition != 0 {
658 if audiosize >= F5 {
659 i = 0;
660 while i < (*st).channels * F2_5 {
661 *pcm.offset(i as isize) = *pcm_transition.offset(i as isize);
662 i += 1;
663 }
664 smooth_fade(
665 pcm_transition.offset(((*st).channels * F2_5) as isize),
666 pcm.offset(((*st).channels * F2_5) as isize),
667 pcm.offset(((*st).channels * F2_5) as isize),
668 F2_5,
669 (*st).channels,
670 window,
671 (*st).Fs,
672 );
673 } else {
674 smooth_fade(
675 pcm_transition,
676 pcm,
677 pcm,
678 F2_5,
679 (*st).channels,
680 window,
681 (*st).Fs,
682 );
683 }
684 }
685 if (*st).decode_gain != 0 {
686 let mut gain: opus_val32 = 0.;
687 gain = celt_exp2(6.48814081e-4f32 * (*st).decode_gain as f32);
688 i = 0;
689 while i < frame_size * (*st).channels {
690 let mut x: opus_val32 = 0.;
691 x = *pcm.offset(i as isize) * gain;
692 *pcm.offset(i as isize) = x;
693 i += 1;
694 }
695 }
696 if len <= 1 {
697 (*st).rangeFinal = 0;
698 } else {
699 (*st).rangeFinal = dec.rng ^ redundant_rng;
700 }
701 (*st).prev_mode = mode;
702 (*st).prev_redundancy = (redundancy != 0 && celt_to_silk == 0) as i32;
703 if celt_ret >= 0 {
704 let _ = _opus_false() != 0;
705 }
706 return if celt_ret < 0 { celt_ret } else { audiosize };
707}
708pub unsafe fn opus_decode_native(
709 st: *mut OpusDecoder,
710 mut data: *const u8,
711 len: i32,
712 pcm: *mut opus_val16,
713 frame_size: i32,
714 decode_fec: i32,
715 self_delimited: i32,
716 packet_offset: *mut i32,
717 soft_clip: i32,
718) -> i32 {
719 let mut i: i32 = 0;
720 let mut nb_samples: i32 = 0;
721 let mut count: i32 = 0;
722 let mut offset: i32 = 0;
723 let mut toc: u8 = 0;
724 let mut packet_frame_size: i32 = 0;
725 let mut packet_bandwidth: i32 = 0;
726 let mut packet_mode: i32 = 0;
727 let mut packet_stream_channels: i32 = 0;
728 let mut size: [i16; 48] = [0; 48];
729 validate_opus_decoder(st);
730 if decode_fec < 0 || decode_fec > 1 {
731 return OPUS_BAD_ARG;
732 }
733 if (decode_fec != 0 || len == 0 || data.is_null()) && frame_size % ((*st).Fs / 400) != 0 {
734 return OPUS_BAD_ARG;
735 }
736 if len == 0 || data.is_null() {
737 let mut pcm_count: i32 = 0;
738 loop {
739 let mut ret: i32 = 0;
740 ret = opus_decode_frame(
741 st,
742 NULL as *const u8,
743 0,
744 pcm.offset((pcm_count * (*st).channels) as isize),
745 frame_size - pcm_count,
746 0,
747 );
748 if ret < 0 {
749 return ret;
750 }
751 pcm_count += ret;
752 if !(pcm_count < frame_size) {
753 break;
754 }
755 }
756 assert!(pcm_count == frame_size);
757 let _ = _opus_false() != 0;
758 (*st).last_packet_duration = pcm_count;
759 return pcm_count;
760 } else {
761 if len < 0 {
762 return OPUS_BAD_ARG;
763 }
764 }
765 packet_mode = opus_packet_get_mode(data);
766 packet_bandwidth = opus_packet_get_bandwidth(data);
767 packet_frame_size = opus_packet_get_samples_per_frame(data, (*st).Fs);
768 packet_stream_channels = opus_packet_get_nb_channels(data);
769 count = opus_packet_parse_impl(
770 data,
771 len,
772 self_delimited,
773 &mut toc,
774 NULL as *mut *const u8,
775 size.as_mut_ptr(),
776 &mut offset,
777 packet_offset,
778 );
779 if count < 0 {
780 return count;
781 }
782 data = data.offset(offset as isize);
783 if decode_fec != 0 {
784 let mut duration_copy: i32 = 0;
785 let mut ret_0: i32 = 0;
786 if frame_size < packet_frame_size
787 || packet_mode == MODE_CELT_ONLY
788 || (*st).mode == MODE_CELT_ONLY
789 {
790 return opus_decode_native(
791 st,
792 NULL as *const u8,
793 0,
794 pcm,
795 frame_size,
796 0,
797 0,
798 NULL as *mut i32,
799 soft_clip,
800 );
801 }
802 duration_copy = (*st).last_packet_duration;
803 if frame_size - packet_frame_size != 0 {
804 ret_0 = opus_decode_native(
805 st,
806 NULL as *const u8,
807 0,
808 pcm,
809 frame_size - packet_frame_size,
810 0,
811 0,
812 NULL as *mut i32,
813 soft_clip,
814 );
815 if ret_0 < 0 {
816 (*st).last_packet_duration = duration_copy;
817 return ret_0;
818 }
819 assert!(ret_0 == frame_size - packet_frame_size);
820 }
821 (*st).mode = packet_mode;
822 (*st).bandwidth = packet_bandwidth;
823 (*st).frame_size = packet_frame_size;
824 (*st).stream_channels = packet_stream_channels;
825 ret_0 = opus_decode_frame(
826 st,
827 data,
828 size[0 as usize] as i32,
829 pcm.offset(((*st).channels * (frame_size - packet_frame_size)) as isize),
830 packet_frame_size,
831 1,
832 );
833 if ret_0 < 0 {
834 return ret_0;
835 } else {
836 let _ = _opus_false() != 0;
837 (*st).last_packet_duration = frame_size;
838 return frame_size;
839 }
840 }
841 if count * packet_frame_size > frame_size {
842 return OPUS_BUFFER_TOO_SMALL;
843 }
844 (*st).mode = packet_mode;
845 (*st).bandwidth = packet_bandwidth;
846 (*st).frame_size = packet_frame_size;
847 (*st).stream_channels = packet_stream_channels;
848 nb_samples = 0;
849 i = 0;
850 while i < count {
851 let mut ret_1: i32 = 0;
852 ret_1 = opus_decode_frame(
853 st,
854 data,
855 size[i as usize] as i32,
856 pcm.offset((nb_samples * (*st).channels) as isize),
857 frame_size - nb_samples,
858 0,
859 );
860 if ret_1 < 0 {
861 return ret_1;
862 }
863 assert!(ret_1 == packet_frame_size);
864 data = data.offset(size[i as usize] as i32 as isize);
865 nb_samples += ret_1;
866 i += 1;
867 }
868 (*st).last_packet_duration = nb_samples;
869 let _ = _opus_false() != 0;
870 if soft_clip != 0 {
871 opus_pcm_soft_clip(
872 pcm,
873 nb_samples,
874 (*st).channels,
875 ((*st).softclip_mem).as_mut_ptr(),
876 );
877 } else {
878 (*st).softclip_mem[1 as usize] = 0 as opus_val16;
879 (*st).softclip_mem[0 as usize] = (*st).softclip_mem[1 as usize];
880 }
881 return nb_samples;
882}
883pub unsafe fn opus_decode(
884 st: *mut OpusDecoder,
885 data: *const u8,
886 len: i32,
887 pcm: *mut i16,
888 mut frame_size: i32,
889 decode_fec: i32,
890) -> i32 {
891 let mut ret: i32 = 0;
892 let mut i: i32 = 0;
893 let mut nb_samples: i32 = 0;
894 if frame_size <= 0 {
895 return OPUS_BAD_ARG;
896 }
897 if !data.is_null() && len > 0 && decode_fec == 0 {
898 nb_samples = opus_decoder_get_nb_samples(st, data, len);
899 if nb_samples > 0 {
900 frame_size = if frame_size < nb_samples {
901 frame_size
902 } else {
903 nb_samples
904 };
905 } else {
906 return OPUS_INVALID_PACKET;
907 }
908 }
909 assert!((*st).channels == 1 || (*st).channels == 2);
910 let vla = (frame_size * (*st).channels) as usize;
911 let mut out: Vec<f32> = ::std::vec::from_elem(0., vla);
912 ret = opus_decode_native(
913 st,
914 data,
915 len,
916 out.as_mut_ptr(),
917 frame_size,
918 decode_fec,
919 0,
920 NULL as *mut i32,
921 1,
922 );
923 if ret > 0 {
924 i = 0;
925 while i < ret * (*st).channels {
926 *pcm.offset(i as isize) = FLOAT2INT16(*out.as_mut_ptr().offset(i as isize));
927 i += 1;
928 }
929 }
930 return ret;
931}
932pub unsafe fn opus_decode_float(
933 st: *mut OpusDecoder,
934 data: *const u8,
935 len: i32,
936 pcm: *mut opus_val16,
937 frame_size: i32,
938 decode_fec: i32,
939) -> i32 {
940 if frame_size <= 0 {
941 return OPUS_BAD_ARG;
942 }
943 return opus_decode_native(
944 st,
945 data,
946 len,
947 pcm,
948 frame_size,
949 decode_fec,
950 0,
951 NULL as *mut i32,
952 0,
953 );
954}
955pub unsafe fn opus_decoder_ctl_impl(st: *mut OpusDecoder, request: i32, args: VarArgs) -> i32 {
956 let mut silk_dec: *mut core::ffi::c_void = 0 as *mut core::ffi::c_void;
957 let mut celt_dec: *mut OpusCustomDecoder = 0 as *mut OpusCustomDecoder;
958 silk_dec = (st as *mut i8).offset((*st).silk_dec_offset as isize) as *mut core::ffi::c_void;
959 celt_dec = (st as *mut i8).offset((*st).celt_dec_offset as isize) as *mut OpusCustomDecoder;
960
961 let mut ap = args;
962
963 match request {
964 OPUS_GET_BANDWIDTH_REQUEST => {
965 let value = ap.arg::<&mut i32>();
966 *value = (*st).bandwidth;
967 OPUS_OK
968 }
969 OPUS_GET_FINAL_RANGE_REQUEST => {
970 let value_0 = ap.arg::<&mut u32>();
971 *value_0 = (*st).rangeFinal;
972 OPUS_OK
973 }
974 OPUS_RESET_STATE => {
975 memset(
976 &mut (*st).stream_channels as *mut i32 as *mut i8 as *mut core::ffi::c_void,
977 0,
978 (::core::mem::size_of::<OpusDecoder>() as u64)
979 .wrapping_sub(
980 (&mut (*st).stream_channels as *mut i32 as *mut i8)
981 .offset_from(st as *mut i8) as i64 as u64,
982 )
983 .wrapping_mul(::core::mem::size_of::<i8>() as u64),
984 );
985 opus_custom_decoder_ctl!(celt_dec, OPUS_RESET_STATE);
986 silk_InitDecoder(silk_dec);
987 (*st).stream_channels = (*st).channels;
988 (*st).frame_size = (*st).Fs / 400;
989 OPUS_OK
990 }
991 OPUS_GET_SAMPLE_RATE_REQUEST => {
992 let value_1 = ap.arg::<&mut i32>();
993 *value_1 = (*st).Fs;
994 OPUS_OK
995 }
996 OPUS_GET_PITCH_REQUEST => {
997 let value_2 = ap.arg::<&mut i32>();
998 if (*st).prev_mode == MODE_CELT_ONLY {
999 opus_custom_decoder_ctl!(celt_dec, OPUS_GET_PITCH_REQUEST, value_2,)
1000 } else {
1001 *value_2 = (*st).DecControl.prevPitchLag;
1002 OPUS_OK
1003 }
1004 }
1005 OPUS_GET_GAIN_REQUEST => {
1006 let value_3 = ap.arg::<&mut i32>();
1007 *value_3 = (*st).decode_gain;
1008 OPUS_OK
1009 }
1010 OPUS_SET_GAIN_REQUEST => {
1011 let value_4: i32 = ap.arg::<i32>();
1012 if value_4 < -(32768) || value_4 > 32767 {
1013 OPUS_BAD_ARG
1014 } else {
1015 (*st).decode_gain = value_4;
1016 OPUS_OK
1017 }
1018 }
1019 OPUS_GET_LAST_PACKET_DURATION_REQUEST => {
1020 let value_5 = ap.arg::<&mut i32>();
1021 *value_5 = (*st).last_packet_duration;
1022 OPUS_OK
1023 }
1024 OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST => {
1025 let value_6: i32 = ap.arg::<i32>();
1026 if value_6 < 0 || value_6 > 1 {
1027 OPUS_BAD_ARG
1028 } else {
1029 opus_custom_decoder_ctl!(
1030 celt_dec,
1031 OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST,
1032 value_6
1033 )
1034 }
1035 }
1036 OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST => {
1037 let value_7 = ap.arg::<&mut i32>();
1038 opus_custom_decoder_ctl!(celt_dec, OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST, value_7)
1039 }
1040 _ => OPUS_UNIMPLEMENTED,
1041 }
1042}
1043#[macro_export]
1044macro_rules! opus_decoder_ctl {
1045 ($st:expr,$request:expr, $($arg:expr),*) => {
1046 $crate::opus_decoder_ctl_impl(
1047 $st,
1048 $request,
1049 $crate::varargs!($($arg),*)
1050 )
1051 };
1052 ($st:expr,$request:expr, $($arg:expr),*,) => {
1053 opus_decoder_ctl!($st, $request, $($arg),*)
1054 };
1055 ($st:expr,$request:expr) => {
1056 opus_decoder_ctl!($st, $request,)
1057 };
1058}
1059pub unsafe fn opus_decoder_destroy(st: *mut OpusDecoder) {
1060 free(st as *mut core::ffi::c_void);
1061}
1062pub unsafe fn opus_packet_get_bandwidth(data: *const u8) -> i32 {
1063 let mut bandwidth: i32 = 0;
1064 if *data.offset(0 as isize) as i32 & 0x80 != 0 {
1065 bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + (*data.offset(0 as isize) as i32 >> 5 & 0x3);
1066 if bandwidth == OPUS_BANDWIDTH_MEDIUMBAND {
1067 bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1068 }
1069 } else if *data.offset(0 as isize) as i32 & 0x60 == 0x60 {
1070 bandwidth = if *data.offset(0 as isize) as i32 & 0x10 != 0 {
1071 OPUS_BANDWIDTH_FULLBAND
1072 } else {
1073 OPUS_BANDWIDTH_SUPERWIDEBAND
1074 };
1075 } else {
1076 bandwidth = OPUS_BANDWIDTH_NARROWBAND + (*data.offset(0 as isize) as i32 >> 5 & 0x3);
1077 }
1078 return bandwidth;
1079}
1080pub unsafe fn opus_packet_get_nb_channels(data: *const u8) -> i32 {
1081 return if *data.offset(0 as isize) as i32 & 0x4 != 0 {
1082 2
1083 } else {
1084 1
1085 };
1086}
1087pub unsafe fn opus_packet_get_nb_frames(packet: *const u8, len: i32) -> i32 {
1088 let mut count: i32 = 0;
1089 if len < 1 {
1090 return OPUS_BAD_ARG;
1091 }
1092 count = *packet.offset(0 as isize) as i32 & 0x3;
1093 if count == 0 {
1094 return 1;
1095 } else if count != 3 {
1096 return 2;
1097 } else if len < 2 {
1098 return OPUS_INVALID_PACKET;
1099 } else {
1100 return *packet.offset(1 as isize) as i32 & 0x3f;
1101 };
1102}
1103pub unsafe fn opus_packet_get_nb_samples(packet: *const u8, len: i32, Fs: i32) -> i32 {
1104 let mut samples: i32 = 0;
1105 let count: i32 = opus_packet_get_nb_frames(packet, len);
1106 if count < 0 {
1107 return count;
1108 }
1109 samples = count * opus_packet_get_samples_per_frame(packet, Fs);
1110 if samples * 25 > Fs * 3 {
1111 return OPUS_INVALID_PACKET;
1112 } else {
1113 return samples;
1114 };
1115}
1116pub unsafe fn opus_decoder_get_nb_samples(
1117 dec: *const OpusDecoder,
1118 packet: *const u8,
1119 len: i32,
1120) -> i32 {
1121 return opus_packet_get_nb_samples(packet, len, (*dec).Fs);
1122}