#[cfg(feature = "std")]
use super::PcmBuf;
use super::{CodecError, Decoder, Encoder, Sample};
use crate::fade;
#[cfg(test)]
use crate::fade::RECOVER_MS;
#[cfg(not(feature = "std"))]
use alloc::boxed::Box;
pub use opus_rs::Application as OpusApplication;
use opus_rs::{Application, OpusDecoder as OpusDecoderRaw, OpusEncoder as OpusEncoderRaw};
const OPUS_MAX_FRAME: usize = 960; const OPUS_MAX_CHANNELS: usize = 2;
const OPUS_MAX_SAMPLES: usize = OPUS_MAX_FRAME * OPUS_MAX_CHANNELS; #[cfg(feature = "std")]
const OPUS_MAX_PACKET: usize = 1276;
pub struct OpusDecoder {
decoder: Box<OpusDecoderRaw>,
sample_rate: u32,
channels: u16,
w_output_f32: [f32; OPUS_MAX_SAMPLES],
w_pcm_i16: [i16; OPUS_MAX_SAMPLES],
loss: fade::LossFade,
}
impl OpusDecoder {
pub fn new(sample_rate: u32, channels: u16) -> Self {
let decoder = Box::new(
OpusDecoderRaw::new(sample_rate as i32, channels as usize)
.expect("Failed to create Opus decoder"),
);
Self {
decoder,
sample_rate,
channels,
w_output_f32: [0.0; OPUS_MAX_SAMPLES],
w_pcm_i16: [0; OPUS_MAX_SAMPLES],
loss: fade::LossFade::default(),
}
}
pub fn new_default() -> Self {
Self::new(48000, 2)
}
pub fn decode_into_raw(&mut self, data: &[u8], output: &mut [i16]) -> usize {
if data.is_empty() {
return 0;
}
let packet_channels = if data[0] & 0x04 != 0 { 2usize } else { 1 };
if self.channels as usize != packet_channels {
self.channels = packet_channels as u16;
*self.decoder = OpusDecoderRaw::new(self.sample_rate as i32, packet_channels)
.expect("Failed to create Opus decoder");
self.loss.clear();
}
let channels = usize::from(self.channels);
let frame_size = (self.sample_rate as usize * 20) / 1000;
let max_samples = frame_size * channels;
match self
.decoder
.decode(data, frame_size, &mut self.w_output_f32[..max_samples])
{
Ok(len) => {
let total_samples = len * channels;
if total_samples == 0 {
return 0;
}
for i in 0..total_samples {
self.w_pcm_i16[i] =
(self.w_output_f32[i] * 32768.0).clamp(-32768.0, 32767.0) as i16;
}
let n = total_samples.min(output.len());
output[..n].copy_from_slice(&self.w_pcm_i16[..n]);
if data.len() > 1 {
self.loss
.end_loss(&mut output[..n], channels, self.sample_rate);
}
n
}
Err(_) => 0,
}
}
}
impl OpusDecoder {
fn conceal_into_raw(
&mut self,
next: Option<&[u8]>,
samples: usize,
out: &mut [Sample],
) -> Result<usize, CodecError> {
let channels = usize::from(self.channels);
let total = samples * channels;
if total > OPUS_MAX_SAMPLES {
return Err(CodecError::InvalidInput);
}
if out.len() < total {
return Err(CodecError::BufferTooSmall);
}
let pcm = &mut self.w_output_f32[..total];
let len = match next {
Some(next) => self.decoder.decode_fec(next, samples, pcm),
None => self.decoder.decode(&[], samples, pcm),
}
.map_err(|_| CodecError::DecodeFailed)?;
let n = len * channels;
for (o, f) in out[..n].iter_mut().zip(&self.w_output_f32[..n]) {
*o = (f * 32768.0).clamp(-32768.0, 32767.0) as i16;
}
match next {
Some(_) => self
.loss
.end_loss(&mut out[..n], channels, self.sample_rate),
None => self.loss.fade(&mut out[..n], channels, self.sample_rate),
}
Ok(n)
}
#[cfg(feature = "std")]
fn conceal_downmixed(&mut self, next: Option<&[u8]>, samples: usize) -> PcmBuf {
let mut pcm = vec![0i16; samples * usize::from(self.channels)];
match self.conceal_into_raw(next, samples, &mut pcm) {
Ok(n) => pcm.truncate(n),
Err(_) => return Vec::new(),
}
if usize::from(self.channels) == 2 {
pcm = pcm
.chunks_exact(2)
.map(|chunk| ((chunk[0] as i32 + chunk[1] as i32) / 2) as i16)
.collect();
}
pcm
}
}
impl Decoder for OpusDecoder {
fn enable_concealment(&mut self) -> bool {
true
}
fn conceal_into(&mut self, samples: usize, out: &mut [Sample]) -> Result<usize, CodecError> {
self.conceal_into_raw(None, samples, out)
}
#[cfg(feature = "std")]
fn conceal(&mut self, samples: usize) -> PcmBuf {
self.conceal_downmixed(None, samples)
}
fn recover_into(
&mut self,
next: &[u8],
samples: usize,
out: &mut [Sample],
) -> Result<usize, CodecError> {
self.conceal_into_raw(Some(next), samples, out)
}
#[cfg(feature = "std")]
fn recover(&mut self, next: &[u8], samples: usize) -> PcmBuf {
self.conceal_downmixed(Some(next), samples)
}
fn decode_into(&mut self, data: &[u8], out: &mut [Sample]) -> Result<usize, CodecError> {
if data.is_empty() {
return Ok(0);
}
let n = self.decode_into_raw(data, out);
if n == 0 {
Err(CodecError::DecodeFailed)
} else {
Ok(n)
}
}
fn max_decode_samples(&self, n_bytes: usize) -> usize {
let frame_size = (self.sample_rate as usize * 20) / 1000;
let _ = n_bytes;
frame_size * 2
}
fn sample_rate(&self) -> u32 {
self.sample_rate
}
fn channels(&self) -> u16 {
self.channels
}
#[cfg(feature = "std")]
fn decode(&mut self, data: &[u8]) -> PcmBuf {
if data.is_empty() {
return Vec::new();
}
let packet_channels = if data[0] & 0x04 != 0 { 2usize } else { 1 };
let frame_size = (self.sample_rate as usize * 20) / 1000;
let max_samples = frame_size * packet_channels;
let mut pcm = vec![0i16; max_samples];
let n = self.decode_into_raw(data, &mut pcm);
pcm.truncate(n);
if usize::from(self.channels) == 2 {
pcm = pcm
.chunks_exact(2)
.map(|chunk| ((chunk[0] as i32 + chunk[1] as i32) / 2) as i16)
.collect();
}
pcm
}
}
pub struct OpusEncoder {
encoder: Box<OpusEncoderRaw>,
sample_rate: u32,
channels: u16,
w_input_f32: [f32; OPUS_MAX_SAMPLES],
}
impl OpusEncoder {
pub fn new_with_application(sample_rate: u32, channels: u16, application: Application) -> Self {
let encoder = Box::new(
OpusEncoderRaw::new(sample_rate as i32, channels as usize, application)
.expect("Failed to create Opus encoder"),
);
Self {
encoder,
sample_rate,
channels,
w_input_f32: [0.0; OPUS_MAX_SAMPLES],
}
}
pub fn new(sample_rate: u32, channels: u16) -> Self {
let mut enc = Self::new_with_application(sample_rate, channels, Application::Voip);
enc.encoder.bitrate_bps = if channels == 2 { 64000 } else { 48000 };
enc.encoder.complexity = 5;
enc.encoder.use_cbr = true;
enc
}
pub fn new_default() -> Self {
Self::new(48000, 2)
}
pub fn set_bitrate(&mut self, bitrate_bps: i32) {
self.encoder.bitrate_bps = bitrate_bps;
}
pub fn set_complexity(&mut self, complexity: i32) {
self.encoder.complexity = complexity;
}
pub fn set_cbr(&mut self, cbr: bool) {
self.encoder.use_cbr = cbr;
}
pub fn set_inband_fec(&mut self, enabled: bool) {
self.encoder.use_inband_fec = enabled;
}
pub fn set_packet_loss_perc(&mut self, percent: i32) {
self.encoder.packet_loss_perc = percent.clamp(0, 100);
}
pub fn encode_into_raw(&mut self, samples: &[Sample], output: &mut [u8]) -> Option<usize> {
let channels = usize::from(self.channels);
if samples.is_empty() || channels == 0 || !samples.len().is_multiple_of(channels) {
return None;
}
if samples.len() > OPUS_MAX_SAMPLES {
return None;
}
let frame_size = samples.len() / channels;
for (dst, &s) in self.w_input_f32[..samples.len()]
.iter_mut()
.zip(samples.iter())
{
*dst = s as f32 / 32768.0;
}
self.encoder
.encode(&self.w_input_f32[..samples.len()], frame_size, output)
.ok()
}
#[cfg(feature = "std")]
fn encode_raw(&mut self, samples: &[Sample]) -> Vec<u8> {
let channels = usize::from(self.channels);
if samples.is_empty()
|| channels == 0
|| !samples.len().is_multiple_of(channels)
|| samples.len() > OPUS_MAX_SAMPLES
{
return Vec::new();
}
let frame_size = samples.len() / channels;
for (dst, &s) in self.w_input_f32[..samples.len()]
.iter_mut()
.zip(samples.iter())
{
*dst = s as f32 / 32768.0;
}
let mut packet = [0u8; OPUS_MAX_PACKET];
match self
.encoder
.encode(&self.w_input_f32[..samples.len()], frame_size, &mut packet)
{
Ok(len) => packet[..len].to_vec(),
Err(_) => Vec::new(),
}
}
}
impl Encoder for OpusEncoder {
fn encode_into(&mut self, samples: &[Sample], out: &mut [u8]) -> Result<usize, CodecError> {
if samples.is_empty() {
return Ok(0);
}
match self.encode_into_raw(samples, out) {
Some(n) => Ok(n),
None => Err(CodecError::EncodeFailed),
}
}
fn max_encode_bytes(&self, _n_samples: usize) -> usize {
1275
}
fn sample_rate(&self) -> u32 {
self.sample_rate
}
fn channels(&self) -> u16 {
self.channels
}
#[cfg(feature = "std")]
fn encode(&mut self, samples: &[Sample]) -> Vec<u8> {
if self.channels == 2 {
if samples.len() > OPUS_MAX_FRAME {
return Vec::new();
}
let mut stereo = [0i16; OPUS_MAX_SAMPLES];
for (i, &sample) in samples.iter().enumerate() {
stereo[2 * i] = sample;
stereo[2 * i + 1] = sample;
}
return self.encode_raw(&stereo[..samples.len() * 2]);
}
self.encode_raw(samples)
}
}
#[cfg(all(test, feature = "std"))]
mod tests {
use super::*;
fn make_mono_pcm_20ms() -> Vec<i16> {
(0..960).map(|i| ((i * 100) % 32767) as i16).collect()
}
fn tone_frame(frame: usize) -> Vec<i16> {
(0..960)
.map(|i| {
let t = (frame * 960 + i) as f32 / 48000.0;
(8000.0 * (2.0 * core::f32::consts::PI * 220.0 * t).sin()) as i16
})
.collect()
}
fn rms(s: &[i16]) -> f64 {
(s.iter().map(|x| (*x as f64).powi(2)).sum::<f64>() / s.len() as f64).sqrt()
}
#[test]
fn test_opus_conceals_a_lost_frame_with_its_own_plc() {
let mut enc = OpusEncoder::new_default();
let mut dec = OpusDecoder::new_default();
for f in 0..10 {
dec.decode(&enc.encode(&tone_frame(f)));
}
let concealed = dec.conceal(960);
assert_eq!(concealed.len(), 960, "downmixed like decode");
assert!(
rms(&concealed) > 1000.0,
"concealment is silent: rms {}",
rms(&concealed)
);
enc.encode(&tone_frame(10));
let next = dec.decode(&enc.encode(&tone_frame(11)));
assert_eq!(next.len(), 960);
assert!(rms(&next) > 1000.0);
}
fn voice(frames: usize) -> Vec<Vec<i16>> {
let mut phase = 0f32;
let pcm: Vec<i16> = (0..frames * 960)
.map(|i| {
let t = i as f32 / 48000.0;
let f0 = 120.0 + 60.0 * (t / 0.6).min(1.0);
phase += 2.0 * core::f32::consts::PI * f0 / 48000.0;
let env = 0.6 + 0.4 * (2.0 * core::f32::consts::PI * 2.0 * t).sin();
let v: f32 = (1..=8).map(|k| (k as f32 * phase).sin() / k as f32).sum();
(6000.0 * env * v) as i16
})
.collect();
pcm.chunks(960).map(<[i16]>::to_vec).collect()
}
#[test]
fn test_opus_recovers_a_lost_frame_from_inband_fec() {
let mut enc = OpusEncoder::new(48000, 1);
enc.set_bitrate(32000);
enc.set_inband_fec(true);
enc.set_packet_loss_perc(20);
let packets: Vec<Vec<u8>> = voice(40).iter().map(|f| enc.encode(f)).collect();
let has_silk = |p: &[u8]| p[0] >> 3 < 16;
assert!(packets.iter().all(|p| has_silk(p)), "coded without SILK");
let mut reference = OpusDecoder::new(48000, 1);
let clean: Vec<Vec<i16>> = packets.iter().map(|p| reference.decode(p)).collect();
let error_db = |out: &[i16], clean: &[i16]| {
let err: f64 = out
.iter()
.zip(clean)
.map(|(a, b)| (*a as f64 - *b as f64).powi(2))
.sum();
let sig: f64 = clean.iter().map(|b| (*b as f64).powi(2)).sum();
10.0 * (err / sig).log10()
};
let (mut recovered_db, mut concealed_db) = (0f64, 0f64);
let losses = [10, 17, 23, 31];
for &lost in &losses {
let mut recovering = OpusDecoder::new(48000, 1);
let mut concealing = OpusDecoder::new(48000, 1);
for p in &packets[..lost] {
recovering.decode(p);
concealing.decode(p);
}
let recovered = recovering.recover(&packets[lost + 1], 960);
let concealed = concealing.conceal(960);
assert_eq!(recovered.len(), 960);
recovered_db += error_db(&recovered, &clean[lost]);
concealed_db += error_db(&concealed, &clean[lost]);
assert_eq!(recovering.decode(&packets[lost + 1]).len(), 960);
}
let n = losses.len() as f64;
let (recovered_db, concealed_db) = (recovered_db / n, concealed_db / n);
println!(
"lost frame error: recovered {recovered_db:.1} dB, concealed {concealed_db:.1} dB"
);
assert!(
recovered_db < concealed_db - 4.0,
"FEC no better than concealment: {recovered_db:.1} vs {concealed_db:.1} dB"
);
}
#[test]
fn test_opus_concealment_fades_through_a_long_loss() {
let mut enc = OpusEncoder::new(48000, 1);
let packets: Vec<Vec<u8>> = voice(12).iter().map(|f| enc.encode(f)).collect();
let mut dec = OpusDecoder::new(48000, 1);
for p in &packets[..10] {
dec.decode(p);
}
let levels: Vec<f64> = (0..5).map(|_| rms(&dec.conceal(960))).collect();
assert!(
levels[0] > 500.0,
"first frame of a loss is audible: {levels:?}"
);
assert!(
levels[1] < levels[0] && levels[2] < levels[1],
"not fading: {levels:?}"
);
assert_eq!(levels[3..], [0.0, 0.0], "not silent from 60 ms: {levels:?}");
}
#[test]
fn test_opus_decoding_after_a_faded_loss_ramps_in() {
let mut enc = OpusEncoder::new(48000, 1);
let packets: Vec<Vec<u8>> = voice(12).iter().map(|f| enc.encode(f)).collect();
let mut dec = OpusDecoder::new(48000, 1);
let mut raw = OpusDecoderRaw::new(48000, 1).unwrap();
let mut raw_out = [0f32; 960];
for p in &packets[..10] {
dec.decode(p);
raw.decode(p, 960, &mut raw_out).unwrap();
}
for _ in 0..5 {
dec.conceal(960);
raw.decode(&[], 960, &mut raw_out).unwrap();
}
let resumed = dec.decode(&packets[10]);
raw.decode(&packets[10], 960, &mut raw_out).unwrap();
let expected: Vec<i16> = raw_out
.iter()
.map(|f| (f * 32768.0).clamp(-32768.0, 32767.0) as i16)
.collect();
let ramp = 48000 * RECOVER_MS as usize / 1000;
assert!(resumed[0].unsigned_abs() <= expected[0].unsigned_abs() / 100 + 1);
assert_eq!(resumed[ramp..], expected[ramp..]);
dec.conceal(960);
assert_eq!(dec.loss.concealed(), 960);
}
#[test]
fn test_opus_recover_without_fec_conceals() {
let mut enc = OpusEncoder::new(48000, 1);
let packets: Vec<Vec<u8>> = voice(12).iter().map(|f| enc.encode(f)).collect();
let mut dec = OpusDecoder::new(48000, 1);
for p in &packets[..10] {
dec.decode(p);
}
let recovered = dec.recover(&packets[11], 960);
assert_eq!(recovered.len(), 960);
assert!(rms(&recovered) > 500.0, "rms {}", rms(&recovered));
}
#[test]
fn test_opus_conceal_into_is_interleaved_and_checks_the_buffer() {
let mut enc = OpusEncoder::new_default();
let mut dec = OpusDecoder::new_default();
dec.decode(&enc.encode(&tone_frame(0)));
let mut out = [0i16; 1920];
assert_eq!(dec.conceal_into(960, &mut out), Ok(1920));
let mut small = [0i16; 100];
assert_eq!(
dec.conceal_into(960, &mut small),
Err(CodecError::BufferTooSmall)
);
}
#[test]
fn test_opus_encode_decode_20ms_produces_960_mono_samples() {
let mut enc = OpusEncoder::new_default();
let pcm = make_mono_pcm_20ms();
let opus_pkt = enc.encode(&pcm);
assert!(!opus_pkt.is_empty(), "encoder should produce output");
assert!(opus_pkt[0] & 0x04 != 0, "packet should be stereo");
let mut dec = OpusDecoder::new_default();
let decoded = dec.decode(&opus_pkt);
assert_eq!(
decoded.len(),
960,
"decoder should downmix stereo→mono and output 960 samples, got {}",
decoded.len()
);
}
#[test]
fn test_opus_consecutive_frames_all_produce_960() {
let mut enc = OpusEncoder::new_default();
let pcm = make_mono_pcm_20ms();
let opus_pkt = enc.encode(&pcm);
let mut dec = OpusDecoder::new_default();
for i in 0..5 {
let decoded = dec.decode(&opus_pkt);
assert_eq!(
decoded.len(),
960,
"frame {} should produce 960 mono samples, got {}",
i,
decoded.len()
);
}
}
#[test]
fn test_opus_decoder_output_has_reasonable_energy() {
let mut enc = OpusEncoder::new_default();
let pcm: Vec<i16> = (0..960)
.map(|i| {
let t = i as f64 / 48000.0;
(16384.0 * (2.0 * std::f64::consts::PI * 440.0 * t).sin()) as i16
})
.collect();
let opus_pkt = enc.encode(&pcm);
let mut dec = OpusDecoder::new_default();
let decoded = dec.decode(&opus_pkt);
assert_eq!(decoded.len(), 960);
let energy: f64 =
decoded.iter().map(|&s| (s as f64).powi(2)).sum::<f64>() / decoded.len() as f64;
let rms = energy.sqrt();
assert!(
rms > 100.0 && rms < 20000.0,
"decoded audio RMS {} should be in reasonable range",
rms
);
}
#[test]
fn test_opus_decoder_handles_mono_packet_gracefully() {
let mut mono_enc = OpusEncoder::new(48000, 1);
let pcm = make_mono_pcm_20ms();
let mono_pkt = mono_enc.encode(&pcm);
assert!(!mono_pkt.is_empty());
assert!(
mono_pkt[0] & 0x04 == 0,
"mono encoder should produce mono packet"
);
let mut dec = OpusDecoder::new_default();
let decoded = dec.decode(&mono_pkt);
assert_eq!(
decoded.len(),
960,
"first mono packet should produce exactly 960 mono samples, got {}",
decoded.len()
);
let decoded2 = dec.decode(&mono_pkt);
assert_eq!(
decoded2.len(),
960,
"second mono packet should also produce 960 mono samples, got {}",
decoded2.len()
);
}
#[test]
fn test_opus_stereo_packet_downmix_produces_960() {
let mut enc = OpusEncoder::new_default();
let pcm = make_mono_pcm_20ms();
let stereo_pkt = enc.encode(&pcm);
assert!(stereo_pkt[0] & 0x04 != 0);
let mut dec = OpusDecoder::new_default();
let decoded = dec.decode(&stereo_pkt);
assert_eq!(
decoded.len(),
960,
"stereo packet should downmix to 960 mono samples"
);
}
}
#[cfg(all(test, feature = "opus"))]
mod no_std_tests {
use super::*;
use alloc::vec::Vec;
#[test]
fn test_opus_into_roundtrip() {
let mut enc = OpusEncoder::new_default();
let mut dec = OpusDecoder::new(48000, 1);
let pcm: Vec<i16> = (0..960).map(|i| ((i * 100) % 32767) as i16).collect();
let mut packet = alloc::vec![0u8; enc.max_encode_bytes(pcm.len())];
let n = enc
.encode_into(&pcm, &mut packet)
.expect("packet sized by max_encode_bytes");
packet.truncate(n);
assert!(!packet.is_empty(), "encoder should produce output");
let mut out = alloc::vec![0i16; dec.max_decode_samples(packet.len())];
let samples = dec
.decode_into(&packet, &mut out)
.expect("out sized by max_decode_samples");
assert_eq!(samples, 960, "20 ms at 48 kHz must decode to 960 samples");
let rms: f64 = out[..samples]
.iter()
.map(|&s| (s as f64) * (s as f64))
.sum::<f64>()
/ samples as f64;
assert!(rms.sqrt() > 1000.0, "decoded signal should keep energy");
}
}