auden 0.1.0

Audio Engine
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

use clap::Parser;
use auden::{buffer::*, play, plot, pool::*};
use std::path::PathBuf;

#[derive(Parser, Debug)]
struct Args {
    #[arg(long)]
    sample_dir: Option<PathBuf>,

    #[arg(long)]
    manifest: Option<PathBuf>,

    #[arg(long)]
    save: Option<PathBuf>,

    #[arg(long)]
    print: bool,

    #[arg(long)]
    plot: Option<PathBuf>,

    #[arg(long)]
    play: Option<PathBuf>,
}

pub fn main() {
    env_logger::init();

    let args = Args::parse();
    let mut pool = SamplePool::default();

    if let Some(manifest) = args.manifest {
        let manifest = PoolManifest::from_file(manifest).unwrap();
        pool = SamplePool::from_manifest(manifest).unwrap();
    }

    if let Some(dir) = args.sample_dir {
        pool.add_samples(&dir).unwrap();
    }

    if let Some(ref save) = args.save {
        pool.build_manifest().unwrap().save(save).unwrap();
    }

    if args.print {
        log::info!("{:#?}", pool.build_manifest().unwrap());
    }

    if let Some(file) = args.plot {
        let mut pool = SamplePool::default();
        pool.add_sample(file).unwrap();
        for (id, buf) in pool.samples() {
            let id = format!("{id:?}");
            match buf {
                SharedAudioBuffer::Mono(b) => plot::mono_waveform(&id, b),
                SharedAudioBuffer::Stereo(b) => plot::stereo_waveform(&id, b.l, b.r),
            };
        }
    }

    if let Some(file) = args.play {
        let id = pool.add_sample(file).unwrap();
        let config = cpal::StreamConfig {
            channels: 2,
            sample_rate: cpal::SampleRate(44100),
            buffer_size: cpal::BufferSize::Fixed(1024),
        };
        play::Stream::launch_with_timeout(&config, std::time::Duration::from_secs(3), {
            let mut i = 0;
            move |output, channels| {
                let sample = pool.sample(id).unwrap();
                for frame in output.chunks_mut(channels) {
                    frame[0] = sample.left()[i];
                    frame[1] = sample.right()[i];
                    i += 1;
                }
            }
        })
        .unwrap();
    }
}