law-encoder 0.1.0

A library for encoding 16bit PCM to a-law and mu-law.
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

use crate::InputFormat;
use crate::OutputFormat;

const CLIP: i16 = 0x1FFF;
const BIAS: i16 = 33;

pub fn encode(
    input_format: InputFormat,
    input: &[u8],
    output_format: OutputFormat,
    output: &mut [u8],
) -> usize {
    let mut encoded_bytes = 0;

    for chunk in input.chunks(2) {
        let sample = match input_format {
            InputFormat::LittleEndian => {
                let bytes = if chunk.len() == 2 {
                    chunk.try_into().unwrap()
                } else {
                    break;
                };
                i16::from_le_bytes(bytes)
            }
            InputFormat::BigEndian => {
                let bytes = if chunk.len() == 2 {
                    chunk.try_into().unwrap()
                } else {
                    break;
                };
                i16::from_be_bytes(bytes)
            }
        };
        output[encoded_bytes] = match output_format {
            OutputFormat::Mulaw => mulaw_encode_sample(sample),
            OutputFormat::Alaw => alaw_encode_sample(sample),
        };
        encoded_bytes += 1;
    }
    encoded_bytes
}

fn alaw_encode_sample(input: i16) -> u8 {
    // Find absolute magnitude
    let mut sample = if input < 0 { !input >> 4 } else { input >> 4 };

    // If large enough amplitude find exponent
    if sample > 15 {
        let mut exp_pos = 1;
        while sample > 31 {
            sample >>= 1;
            exp_pos += 1;
        }

        // Remove leading 1
        sample -= 16;

        // Compute encoded value
        sample += exp_pos << 4;
    }

    // Add back in sign
    if input >= 0 {
        sample |= 0x0080;
    }

    // Toggle even bits
    (sample ^ 0x0055) as u8
}

fn mulaw_encode_sample(input: i16) -> u8 {
    // Find absolute magnitude and add bias
    let mut sample = if input < 0 {
        (!input >> 2) + BIAS
    } else {
        (input >> 2) + BIAS
    };

    // Add clipping
    if sample > CLIP {
        sample = CLIP;
    }

    // Find exponent
    let mut i = sample >> 6;
    let mut segno = 1;
    while i != 0 {
        segno += 1;
        i >>= 1;
    }

    // high-nibble
    let high_nibble = (0x0008) - segno;

    // low-nibble
    let low_nibble = (0x000F) - ((sample >> segno) & (0x000F));

    // Join nibbles together
    if input >= 0 {
        ((high_nibble << 4) | low_nibble | (0x0080)) as u8
    } else {
        ((high_nibble << 4) | low_nibble) as u8
    }
}