sea-codec 0.5.3

Low-complexity, lossy audio codec designed for embedded devices
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

use std::io::Cursor;

use bytemuck::cast_slice;
use decoder::SeaDecoder;
use encoder::{EncoderSettings, SeaEncoder};

mod codec;
pub mod decoder;
pub mod encoder;
#[cfg(all(target_arch = "wasm32", feature = "wasm-api"))]
pub mod wasm_api;

pub fn sea_encode(
    input_samples: &[i16],
    sample_rate: u32,
    channels: u32,
    settings: EncoderSettings,
) -> Vec<u8> {
    let u8_input_samples: &[u8] = cast_slice(input_samples);
    let mut cursor: Cursor<_> = Cursor::new(u8_input_samples);
    let mut sea_encoded = Vec::<u8>::with_capacity(input_samples.len());
    let mut sea_encoder = SeaEncoder::new(
        channels as u8,
        sample_rate,
        Some(input_samples.len() as u32 / channels),
        settings,
        &mut cursor,
        &mut sea_encoded,
    )
    .unwrap();

    while sea_encoder.encode_frame().unwrap() {}
    sea_encoder.finalize().unwrap();

    sea_encoded
}

pub struct SeaDecodeInfo {
    pub samples: Vec<i16>,
    pub sample_rate: u32,
    pub channels: u32,
}

pub fn sea_decode(encoded: &[u8]) -> SeaDecodeInfo {
    let mut cursor: Cursor<&[u8]> = Cursor::new(encoded);
    let mut sea_decoded = Vec::<u8>::with_capacity(encoded.len() * 8);

    let mut sea_decoder: SeaDecoder<&mut Cursor<&[u8]>, &mut Vec<u8>> =
        SeaDecoder::new(&mut cursor, &mut sea_decoded).unwrap();

    while sea_decoder.decode_frame().unwrap() {}
    sea_decoder.finalize().unwrap();

    let header = sea_decoder.get_header();

    let decoded: &[i16] = cast_slice(&sea_decoded);

    SeaDecodeInfo {
        samples: decoded.to_vec(),
        sample_rate: header.sample_rate,
        channels: header.channels as u32,
    }
}