mousiki 0.2.0

Pure Rust Opus codec.
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

use mousiki::{
    Application, Bitrate, Channels, Decoder, Encoder, EncoderBuilderError, OpusDecodeError,
    OpusDecoderInitError, OpusEncodeError,
};
use std::env;
use std::fs::File;
use std::io::{self, Read, Write};
use std::path::Path;

const FRAME_SIZE: usize = 960;
const SAMPLE_RATE: u32 = 48_000;
const CHANNELS: Channels = Channels::Stereo;
const APPLICATION: Application = Application::Audio;
const BITRATE: Bitrate = Bitrate::Bits(64_000);

const MAX_FRAME_SIZE: usize = 6 * 960;
const MAX_PACKET_SIZE: usize = 3 * 1276;

fn main() {
    if let Err(err) = run() {
        report_error(err);
        std::process::exit(1);
    }
}

fn run() -> Result<(), ExampleError> {
    let mut args = env::args_os();
    let _program = args.next();
    let input = args.next().ok_or(ExampleError::Usage)?;
    let output = args.next().ok_or(ExampleError::Usage)?;
    if args.next().is_some() {
        return Err(ExampleError::Usage);
    }

    let input_path = Path::new(&input);
    let output_path = Path::new(&output);

    let mut input_file =
        File::open(input_path).map_err(|err| ExampleError::Io("open input", err.kind()))?;
    let mut output_file =
        File::create(output_path).map_err(|err| ExampleError::Io("create output", err.kind()))?;

    let mut encoder = Encoder::builder(SAMPLE_RATE, CHANNELS, APPLICATION)
        .bitrate(BITRATE)
        .build()
        .map_err(ExampleError::EncoderBuild)?;
    let mut decoder = Decoder::new(SAMPLE_RATE, CHANNELS).map_err(ExampleError::DecoderInit)?;

    let channels = CHANNELS.count();
    let mut input_bytes = vec![0u8; FRAME_SIZE * channels * 2];
    let mut input_pcm = vec![0i16; FRAME_SIZE * channels];
    let mut output_pcm = vec![0i16; MAX_FRAME_SIZE * channels];
    let mut output_bytes = vec![0u8; MAX_FRAME_SIZE * channels * 2];
    let mut packet = vec![0u8; MAX_PACKET_SIZE];

    loop {
        match input_file.read_exact(&mut input_bytes) {
            Ok(()) => {}
            Err(err) if err.kind() == io::ErrorKind::UnexpectedEof => break,
            Err(err) => return Err(ExampleError::Io("read input", err.kind())),
        }

        for (sample, chunk) in input_pcm.iter_mut().zip(input_bytes.chunks_exact(2)) {
            *sample = i16::from_le_bytes([chunk[0], chunk[1]]);
        }

        let packet_len = encoder
            .encode(&input_pcm, &mut packet)
            .map_err(ExampleError::Encode)?;

        let decoded = decoder
            .decode(&packet[..packet_len], &mut output_pcm, false)
            .map_err(ExampleError::Decode)?;

        let total_samples = decoded * channels;
        for (chunk, &sample) in output_bytes
            .chunks_exact_mut(2)
            .take(total_samples)
            .zip(output_pcm.iter().take(total_samples))
        {
            let le = sample.to_le_bytes();
            chunk[0] = le[0];
            chunk[1] = le[1];
        }

        output_file
            .write_all(&output_bytes[..total_samples * 2])
            .map_err(|err| ExampleError::Io("write output", err.kind()))?;
    }

    Ok(())
}

fn report_error(err: ExampleError) {
    match err {
        ExampleError::Usage => {
            eprintln!("usage: trivial_example <input.pcm> <output.pcm>");
            eprintln!("input and output are 16-bit little-endian raw files");
        }
        ExampleError::Io(context, kind) => {
            eprintln!("IO error ({context}): {kind:?}");
        }
        ExampleError::DecoderInit(err) => {
            eprintln!("failed to create decoder: {err:?}");
        }
        ExampleError::EncoderBuild(err) => {
            eprintln!("failed to create encoder: {err:?}");
        }
        ExampleError::Encode(err) => {
            eprintln!("encode failed: {err:?}");
        }
        ExampleError::Decode(err) => {
            eprintln!("decode failed: {err:?}");
        }
    }
}

enum ExampleError {
    Usage,
    Io(&'static str, io::ErrorKind),
    EncoderBuild(EncoderBuilderError),
    DecoderInit(OpusDecoderInitError),
    Encode(OpusEncodeError),
    Decode(OpusDecodeError),
}