Skip to main content

ezk_g722/
lib.rs

1use bytes::Bytes;
2use ezk::{ConfigRange, Frame, MediaType};
3use ezk_rtp::{DePayloader, Payloadable, Payloader};
4use std::{iter::from_fn, mem::take};
5
6pub mod libg722;
7
8mod decoder;
9mod encoder;
10
11pub use decoder::G722Decoder;
12pub use encoder::G722Encoder;
13
14#[derive(Debug)]
15pub enum G722 {}
16
17impl MediaType for G722 {
18    type ConfigRange = G722ConfigRange;
19    type Config = G722Config;
20    type FrameData = Bytes;
21}
22
23#[derive(Debug, Clone)]
24pub struct G722ConfigRange;
25
26impl ConfigRange for G722ConfigRange {
27    type Config = G722Config;
28
29    fn any() -> Self {
30        Self {}
31    }
32
33    fn intersect(&self, _other: &Self) -> Option<Self> {
34        Some(Self {})
35    }
36
37    fn contains(&self, _config: &Self::Config) -> bool {
38        true
39    }
40}
41
42#[derive(Default, Debug, Clone)]
43pub struct G722Config;
44
45impl Payloadable for G722 {
46    type Payloader = G722Payloader;
47    type DePayloader = G722DePayloader;
48
49    const STATIC_PT: Option<u8> = Some(9);
50
51    fn make_payloader(_: Self::Config) -> Self::Payloader {
52        G722Payloader {}
53    }
54
55    fn make_depayloader(_: Vec<Self::ConfigRange>) -> (Self::Config, Self::DePayloader) {
56        (Self::Config {}, G722DePayloader {})
57    }
58}
59
60pub struct G722Payloader;
61
62impl Payloader<G722> for G722Payloader {
63    fn payload(&mut self, frame: Frame<G722>, max_size: usize) -> impl Iterator<Item = Bytes> + '_ {
64        let mut data = frame.into_data();
65
66        from_fn(move || {
67            if let Some((pkg, rem)) = data.split_at_checked(max_size) {
68                let pkg = data.slice_ref(pkg);
69                data = data.slice_ref(rem);
70                Some(pkg)
71            } else if data.is_empty() {
72                None
73            } else {
74                Some(take(&mut data))
75            }
76        })
77    }
78}
79
80pub struct G722DePayloader;
81
82impl DePayloader<G722> for G722DePayloader {
83    fn depayload(&mut self, payload: &[u8]) -> Bytes {
84        Bytes::copy_from_slice(payload)
85    }
86}