audio-codec 0.3.30

A collection of VoIP audio codecs in Rust, including G.711, G.722, G.729, and Opus.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use super::{Decoder, Encoder, PcmBuf, Sample};

const BIAS: i16 = 0x84;
const CLIP: i16 = 32635;

const fn linear2ulaw_algo(mut sample: i16) -> u8 {
    // Clip the sample to prevent overflow
    if sample > CLIP {
        sample = CLIP;
    } else if sample < -CLIP {
        sample = -CLIP;
    }

    // Get the sample's sign and make it positive
    let sign: i16 = if sample < 0 { 0x80 } else { 0x00 };
    if sign == 0x80 {
        sample = -sample;
    }

    // Add bias
    sample += BIAS;

    // Compute segment number and step size
    let mut segment: i16 = 0;
    let mut value = sample;
    while value >= 256 {
        segment += 1;
        value >>= 1;
    }

    // Combine sign, segment, and quantization
    let uval = if segment >= 8 {
        0x7F ^ sign
    } else {
        let shift = if segment == 0 { 7 } else { segment + 3 };
        let mask = 0xFF ^ (0xFF >> shift);
        (sign | (segment << 4) | ((sample >> (segment + 3)) & 0x0F)) ^ mask
    };

    uval as u8
}

static MULAW_ENCODE_TABLE: [u8; 65536] = {
    let mut table = [0; 65536];
    let mut i = 0;
    while i < 65536 {
        let s = (i as i32 - 32768) as i16;
        table[i] = linear2ulaw_algo(s);
        i += 1;
    }
    table
};

static MULAW_DECODE_TABLE: [i16; 256] = [
    -32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956, -23932, -22908, -21884, -20860,
    -19836, -18812, -17788, -16764, -15996, -15484, -14972, -14460, -13948, -13436, -12924, -12412,
    -11900, -11388, -10876, -10364, -9852, -9340, -8828, -8316, -7932, -7676, -7420, -7164, -6908,
    -6652, -6396, -6140, -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092, -3900, -3772,
    -3644, -3516, -3388, -3260, -3132, -3004, -2876, -2748, -2620, -2492, -2364, -2236, -2108,
    -1980, -1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436, -1372, -1308, -1244, -1180,
    -1116, -1052, -988, -924, -876, -844, -812, -780, -748, -716, -684, -652, -620, -588, -556,
    -524, -492, -460, -428, -396, -372, -356, -340, -324, -308, -292, -276, -260, -244, -228, -212,
    -196, -180, -164, -148, -132, -120, -112, -104, -96, -88, -80, -72, -64, -56, -48, -40, -32,
    -24, -16, -8, 0, 32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956, 23932, 22908, 21884,
    20860, 19836, 18812, 17788, 16764, 15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
    11900, 11388, 10876, 10364, 9852, 9340, 8828, 8316, 7932, 7676, 7420, 7164, 6908, 6652, 6396,
    6140, 5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092, 3900, 3772, 3644, 3516, 3388, 3260, 3132,
    3004, 2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980, 1884, 1820, 1756, 1692, 1628, 1564, 1500,
    1436, 1372, 1308, 1244, 1180, 1116, 1052, 988, 924, 876, 844, 812, 780, 748, 716, 684, 652,
    620, 588, 556, 524, 492, 460, 428, 396, 372, 356, 340, 324, 308, 292, 276, 260, 244, 228, 212,
    196, 180, 164, 148, 132, 120, 112, 104, 96, 88, 80, 72, 64, 56, 48, 40, 32, 24, 16, 8, 0,
];

/// Decodes a single μ-law encoded byte to a 16-bit PCM sample
fn decode_mu_law(mu_law_sample: u8) -> i16 {
    MULAW_DECODE_TABLE[mu_law_sample as usize]
}

/// Decoder for μ-law (PCMU) format
#[derive(Default)]
pub struct PcmuDecoder {}

impl PcmuDecoder {
    /// Creates a new PcmuDecoder instance
    pub fn new() -> Self {
        Self {}
    }
}

impl Decoder for PcmuDecoder {
    fn decode(&mut self, data: &[u8]) -> PcmBuf {
        data.iter().map(|&sample| decode_mu_law(sample)).collect()
    }

    fn sample_rate(&self) -> u32 {
        8000
    }

    fn channels(&self) -> u16 {
        1
    }
}

/// Encoder for μ-law (PCMU) format
#[derive(Default)]
pub struct PcmuEncoder {}

impl PcmuEncoder {
    /// Creates a new PcmuEncoder instance
    pub fn new() -> Self {
        Self {}
    }

    /// Converts a linear 16-bit PCM sample to a μ-law encoded byte using lookup table
    fn linear2ulaw(&self, sample: i16) -> u8 {
        let index = (sample as i32 + 32768) as usize;
        MULAW_ENCODE_TABLE[index]
    }
}

impl Encoder for PcmuEncoder {
    fn encode(&mut self, samples: &[Sample]) -> Vec<u8> {
        samples
            .iter()
            .map(|&sample| self.linear2ulaw(sample))
            .collect()
    }

    fn sample_rate(&self) -> u32 {
        8000
    }

    fn channels(&self) -> u16 {
        1
    }
}