feat: add Opus codec support

Author: shenjinti

Cargo.toml

@@ -14,12 +14,14 @@ categories = ["network-programming", "multimedia"]
 vad_webrtc = ["webrtc-vad"]
 vad_silero = ["ort", "ort-sys"]
 vad_ten = ["ort", "ort-sys"]
-default = ["vad_webrtc", "vad_silero", "vad_ten"]
+opus = ["dep:opus"]
+default = ["vad_webrtc", "vad_silero", "vad_ten", "opus"]
 not_vad = []
 
 [dependencies]
 anyhow = "1.0.98"
 async-trait = "0.1.88"
+opus = { version = "0.3", optional = true }
 axum = { version = "0.8.3", features = ["ws", "tokio"] }
 tower-http = { version = "0.6.2", features = ["fs", "cors"] }
 bytes = "1.10.1"
@@ -43,7 +45,7 @@ uuid = { version = "1.16.0", features = ["v4"] }
 webrtc = "0.13.0"
 webrtc-vad = { version = "0.4.0", optional = true }
 clap = { version = "4.5", features = ["derive"] }
-toml = "0.8"
+toml = "0.9.2"
 rand = "0.9.0"
 hound = "3.5.1"
 ort = { version = "2.0.0-rc.10", features = ["ndarray"], optional = true }

Dockerfile

@@ -1,5 +1,5 @@
 FROM rust:bookworm AS rust-builder
-RUN apt-get update && apt-get install -y libasound2-dev
+RUN apt-get update && apt-get install -y libasound2-dev libopus-dev
 RUN mkdir /build
 ADD . /build/
 WORKDIR /build

README.md

@@ -37,6 +37,17 @@ RustPBX is a high-performance, secure software-defined PBX (Private Branch Excha
 ### Prerequisites
 - Rust 1.75 or later
 - Cargo package manager
+- opus, alsa
+
+Linux: 
+```bash
+apt-get install -y libasound2-dev libopus-dev
+```
+
+Mac:
+```bash
+brew install opus
+```
 
 ### Installation
 ```bash

src/media/codecs/mod.rs

@@ -1,5 +1,7 @@
 use crate::{PcmBuf, Sample};
 pub mod g722;
+#[cfg(feature = "opus")]
+pub mod opus;
 pub mod pcma;
 pub mod pcmu;
 pub mod resample;
@@ -11,6 +13,8 @@ pub enum CodecType {
     PCMU,
     PCMA,
     G722,
+    #[cfg(feature = "opus")]
+    Opus,
     TelephoneEvent,
 }
 
@@ -41,6 +45,8 @@ pub fn create_decoder(codec: CodecType) -> Box<dyn Decoder> {
         CodecType::PCMU => Box::new(pcmu::PcmuDecoder::new()),
         CodecType::PCMA => Box::new(pcma::PcmaDecoder::new()),
         CodecType::G722 => Box::new(g722::G722Decoder::new()),
+        #[cfg(feature = "opus")]
+        CodecType::Opus => Box::new(opus::OpusDecoder::new_default()),
         CodecType::TelephoneEvent => Box::new(telephone_event::TelephoneEventDecoder::new()),
     }
 }
@@ -50,6 +56,8 @@ pub fn create_encoder(codec: CodecType) -> Box<dyn Encoder> {
         CodecType::PCMU => Box::new(pcmu::PcmuEncoder::new()),
         CodecType::PCMA => Box::new(pcma::PcmaEncoder::new()),
         CodecType::G722 => Box::new(g722::G722Encoder::new()),
+        #[cfg(feature = "opus")]
+        CodecType::Opus => Box::new(opus::OpusEncoder::new_default()),
         CodecType::TelephoneEvent => Box::new(telephone_event::TelephoneEventEncoder::new()),
     }
 }
@@ -60,6 +68,8 @@ impl CodecType {
             CodecType::PCMU => "audio/PCMU",
             CodecType::PCMA => "audio/PCMA",
             CodecType::G722 => "audio/G722",
+            #[cfg(feature = "opus")]
+            CodecType::Opus => "audio/opus",
             CodecType::TelephoneEvent => "audio/telephone-event",
         }
     }
@@ -68,6 +78,8 @@ impl CodecType {
             CodecType::PCMU => "PCMU/8000",
             CodecType::PCMA => "PCMA/8000",
             CodecType::G722 => "G722/16000",
+            #[cfg(feature = "opus")]
+            CodecType::Opus => "opus/48000",
             CodecType::TelephoneEvent => "telephone-event/8000",
         }
     }
@@ -77,6 +89,8 @@ impl CodecType {
             CodecType::PCMU => 8000,
             CodecType::PCMA => 8000,
             CodecType::G722 => 8000,
+            #[cfg(feature = "opus")]
+            CodecType::Opus => 48000,
             CodecType::TelephoneEvent => 8000,
         }
     }
@@ -85,6 +99,7 @@ impl CodecType {
             CodecType::PCMU => 0,
             CodecType::PCMA => 8,
             CodecType::G722 => 9,
+            CodecType::Opus => 111, // Dynamic payload type
             CodecType::TelephoneEvent => 101,
         }
     }
@@ -93,12 +108,16 @@ impl CodecType {
             CodecType::PCMU => 8000,
             CodecType::PCMA => 8000,
             CodecType::G722 => 16000,
+            #[cfg(feature = "opus")]
+            CodecType::Opus => 48000,
             CodecType::TelephoneEvent => 8000,
         }
     }
     pub fn is_audio(&self) -> bool {
         match self {
             CodecType::PCMU | CodecType::PCMA | CodecType::G722 => true,
+            #[cfg(feature = "opus")]
+            CodecType::Opus => true,
             _ => false,
         }
     }
@@ -112,6 +131,8 @@ impl TryFrom<&String> for CodecType {
             "0" => Ok(CodecType::PCMU),
             "8" => Ok(CodecType::PCMA),
             "9" => Ok(CodecType::G722),
+            #[cfg(feature = "opus")]
+            "111" => Ok(CodecType::Opus), // Dynamic payload type
             "101" => Ok(CodecType::TelephoneEvent),
             _ => Err(anyhow::anyhow!("Invalid codec type: {}", value)),
         }

src/media/codecs/opus.rs

@@ -0,0 +1,139 @@
+use super::{Decoder, Encoder};
+use crate::{PcmBuf, Sample};
+use opus::{Application, Channels, Decoder as OpusDecoderCore, Encoder as OpusEncoderCore};
+
+/// Opus audio decoder
+pub struct OpusDecoder {
+    decoder: OpusDecoderCore,
+    sample_rate: u32,
+    channels: u16,
+}
+
+impl OpusDecoder {
+    /// Create a new Opus decoder instance
+    pub fn new(sample_rate: u32, channels: u16) -> Self {
+        let channels = if channels == 1 {
+            Channels::Mono
+        } else {
+            Channels::Stereo
+        };
+
+        let decoder = match OpusDecoderCore::new(sample_rate, channels) {
+            Ok(decoder) => decoder,
+            Err(e) => {
+                panic!("Failed to create Opus decoder: {}", e);
+            }
+        };
+
+        Self {
+            decoder,
+            sample_rate,
+            channels: if matches!(channels, Channels::Mono) {
+                1
+            } else {
+                2
+            },
+        }
+    }
+
+    /// Create a default Opus decoder (48kHz, mono)
+    pub fn new_default() -> Self {
+        Self::new(48000, 1)
+    }
+}
+
+unsafe impl Send for OpusDecoder {}
+unsafe impl Sync for OpusDecoder {}
+
+impl Decoder for OpusDecoder {
+    fn decode(&mut self, data: &[u8]) -> PcmBuf {
+        // Allocate output buffer - Opus can decode up to 120ms of audio
+        // 48kHz * 0.12s * 2(stereo) = 11520 samples
+        let max_samples = 11520;
+        let mut output = vec![0i16; max_samples];
+
+        match self.decoder.decode(data, &mut output, false) {
+            Ok(len) => {
+                output.truncate(len);
+                output
+            }
+            Err(_) => {
+                // If decoding fails, return empty buffer
+                vec![]
+            }
+        }
+    }
+
+    fn sample_rate(&self) -> u32 {
+        self.sample_rate
+    }
+
+    fn channels(&self) -> u16 {
+        self.channels
+    }
+}
+
+/// Opus audio encoder
+pub struct OpusEncoder {
+    encoder: OpusEncoderCore,
+    sample_rate: u32,
+    channels: u16,
+}
+
+impl OpusEncoder {
+    /// Create a new Opus encoder instance
+    pub fn new(sample_rate: u32, channels: u16) -> Self {
+        let channels_enum = if channels == 1 {
+            Channels::Mono
+        } else {
+            Channels::Stereo
+        };
+
+        let encoder = match OpusEncoderCore::new(sample_rate, channels_enum, Application::Voip) {
+            Ok(encoder) => encoder,
+            Err(e) => {
+                panic!("Failed to create Opus encoder: {}", e);
+            }
+        };
+
+        Self {
+            encoder,
+            sample_rate,
+            channels,
+        }
+    }
+
+    /// Create a default Opus encoder (48kHz, mono)
+    pub fn new_default() -> Self {
+        Self::new(48000, 1)
+    }
+}
+
+unsafe impl Send for OpusEncoder {}
+unsafe impl Sync for OpusEncoder {}
+
+impl Encoder for OpusEncoder {
+    fn encode(&mut self, samples: &[Sample]) -> Vec<u8> {
+        // Allocate output buffer - Opus encoded data is typically smaller than raw data
+        let mut output = vec![0u8; samples.len()];
+
+        match self.encoder.encode(samples, &mut output) {
+            Ok(len) => {
+                output.truncate(len);
+                output
+            }
+            Err(_) => {
+                // If encoding fails, return empty buffer
+                vec![]
+            }
+        }
+    }
+
+    fn sample_rate(&self) -> u32 {
+        self.sample_rate
+    }
+
+    fn channels(&self) -> u16 {
+        self.channels
+    }
+}

src/media/codecs/tests.rs

@@ -373,3 +373,89 @@ fn test_pcma_edge_cases() {
     println!("Original: {:?}", samples);
     println!("Decoded: {:?}", decoded);
 }
+
+#[cfg(feature = "opus")]
+#[test]
+fn test_opus_codec() {
+    use super::opus::{OpusDecoder, OpusEncoder};
+    use super::{Decoder, Encoder};
+
+    // Create encoder and decoder
+    let mut encoder = OpusEncoder::new_default();
+    let mut decoder = OpusDecoder::new_default();
+
+    // Create test audio data (48kHz mono, 20ms = 960 samples)
+    let samples_per_frame = 960;
+    let input_samples: Vec<i16> = (0..samples_per_frame)
+        .map(|i| (1000.0 * (2.0 * std::f64::consts::PI * 440.0 * i as f64 / 48000.0).sin()) as i16)
+        .collect();
+
+    // Encode
+    let encoded = encoder.encode(&input_samples);
+    assert!(!encoded.is_empty(), "Encoded data should not be empty");
+
+    // Decode
+    let decoded = decoder.decode(&encoded);
+    assert!(!decoded.is_empty(), "Decoded data should not be empty");
+
+    // Verify sample rate and channels
+    assert_eq!(encoder.sample_rate(), 48000);
+    assert_eq!(encoder.channels(), 1);
+    assert_eq!(decoder.sample_rate(), 48000);
+    assert_eq!(decoder.channels(), 1);
+}
+
+#[cfg(feature = "opus")]
+#[test]
+fn test_opus_encode_decode() {
+    use super::opus::{OpusDecoder, OpusEncoder};
+
+    // Test different configurations
+    let configs = vec![
+        (48000, 1), // 48kHz mono
+        (48000, 2), // 48kHz stereo
+        (16000, 1), // 16kHz mono
+        (8000, 1),  // 8kHz mono
+    ];
+
+    for (sample_rate, channels) in configs {
+        let mut encoder = OpusEncoder::new(sample_rate, channels);
+        let mut decoder = OpusDecoder::new(sample_rate, channels);
+
+        // Create test data
+        let frame_size = (sample_rate / 50) as usize * channels as usize; // 20ms frame
+        let input_samples: Vec<i16> = (0..frame_size)
+            .map(|i| {
+                (500.0 * (2.0 * std::f64::consts::PI * 440.0 * i as f64 / sample_rate as f64).sin())
+                    as i16
+            })
+            .collect();
+
+        // Encode
+        let encoded = encoder.encode(&input_samples);
+        assert!(
+            !encoded.is_empty(),
+            "Encoded data should not be empty for {}Hz {}ch",
+            sample_rate,
+            channels
+        );
+
+        // Decode
+        let decoded = decoder.decode(&encoded);
+        assert!(
+            !decoded.is_empty(),
+            "Decoded data should not be empty for {}Hz {}ch",
+            sample_rate,
+            channels
+        );
+
+        println!(
+            "✓ Opus {}Hz {}ch: {} samples -> {} bytes -> {} samples",
+            sample_rate,
+            channels,
+            input_samples.len(),
+            encoded.len(),
+            decoded.len()
+        );
+    }
+}