sea-codec 0.7.0

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

#![cfg_attr(not(feature = "std"), no_std)]

extern crate alloc;

use alloc::vec::Vec;
use decoder::SeaDecoder;
use encoder::{EncoderSettings, SeaEncoder};

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

#[cfg(feature = "c-api")]
pub mod c_api;

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

    while sea_encoder.encode_frame(&mut sea_encoded).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 sea_decoded = Vec::<i16>::with_capacity(encoded.len() * 8);

    let mut sea_decoder = SeaDecoder::from_slice(encoded).unwrap();

    while sea_decoder.decode_frame(&mut sea_decoded).unwrap() {}

    let header = sea_decoder.get_header();

    SeaDecodeInfo {
        samples: sea_decoded,
        sample_rate: header.sample_rate,
        channels: header.channels as u32,
    }
}