sonar 0.0.5

Simple data transfer protocol using audio signals
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
126
127
128
129
130
131
132
133

// src/audio/mod.rs

use cpal::traits::{DeviceTrait, HostTrait};
use dev_utils::{format::*, read_input};
use std::{error::Error, time::Duration};

// * mod.rs
pub mod capture;
pub mod config;
pub mod playback;
pub mod signal;

pub fn list_audio_devices() -> Result<(), Box<dyn std::error::Error>> {
    let host = cpal::default_host();

    println!("Input devices:");
    let input_devices = host.input_devices()?;
    for (i, device) in input_devices.enumerate() {
        println!("{}: {}", i, device.name()?);
    }

    println!("Output devices:");
    let output_devices = host.output_devices()?;
    for (i, device) in output_devices.enumerate() {
        println!("{}: {}", i, device.name()?);
    }

    Ok(())
}

pub fn select_device(input: bool) -> Result<cpal::Device, Box<dyn Error>> {
    let host = cpal::default_host();
    let mut devices = if input {
        host.input_devices()?
    } else {
        host.output_devices()?
    };

    println!(
        "\n{}",
        format!(
            "Available {} Devices:",
            if input { "Input" } else { "Output" }
        )
        .color(BLUE)
        .style(Style::Bold)
    );

    let device_list: Vec<_> = devices.collect();
    for (idx, device) in device_list.iter().enumerate() {
        println!(
            "{}. {}",
            idx.to_string().color(GREEN),
            device.name().unwrap_or_default().color(WHITE)
        );
    }

    loop {
        let choice = read_input::<usize>(Some("Select device number: "))?;
        if choice < device_list.len() {
            return Ok(device_list[choice].clone());
        }
        println!("Invalid selection. Try again.");
    }
}

// ? FORMAT RELATED FUNCTIONS
pub fn interpolate_color(value: f32, min: f32, max: f32) -> Color {
    let t = ((value - min) / (max - min)).clamp(0.0, 1.0);

    let colors = [
        (0.0, (0, 0, 255)),   // Blue
        (0.3, (0, 255, 0)),   // Green
        (0.6, (255, 255, 0)), // Yellow
        (1.0, (255, 0, 0)),   // Red
    ];

    let mut color1 = colors[0];
    let mut color2 = colors[1];

    for window in colors.windows(2) {
        if t >= window[0].0 && t <= window[1].0 {
            color1 = window[0];
            color2 = window[1];
            break;
        }
    }

    let factor = (t - color1.0) / (color2.0 - color1.0);

    let r = (color1.1.0 as f32 * (1.0 - factor) + color2.1.0 as f32 * factor) as u8;
    let g = (color1.1.1 as f32 * (1.0 - factor) + color2.1.1 as f32 * factor) as u8;
    let b = (color1.1.2 as f32 * (1.0 - factor) + color2.1.2 as f32 * factor) as u8;

    Color::from((r, g, b))
}

pub fn format_time(duration: Duration) -> String {
    let total_secs = duration.as_secs();
    let hours = total_secs / 3600;
    let minutes = (total_secs % 3600) / 60;
    let seconds = total_secs % 60;
    let millis = duration.subsec_millis();

    format!("[{:02}:{:02}:{:02}.{:03}]", hours, minutes, seconds, millis)
        .style(Style::Dim)
        .style(Style::Italic)
}

pub fn create_gradient_meter(value: f32, width: usize, peak_pos: Option<usize>) -> String {
    let meter_width = (value * width as f32 * 2.0).min(width as f32) as usize;
    let mut meter = String::with_capacity(width * 3);

    for i in 0..width {
        if i < meter_width {
            let segment_value = i as f32 / width as f32;
            let color = interpolate_color(segment_value, 0.0, 1.0);
            meter.push_str(&"█".color(color));
        } else if Some(i) == peak_pos {
            meter.push_str(&"╎".color(WHITE).style(Style::Bold)); // Peak indicator
        } else {
            meter.push(' ');
        }
    }
    format!("│{}│", meter)
}

pub fn format_signal_value(value: f32) -> String {
    format!("{:>10.8}", value)
        .color(interpolate_color(value, 0.0, 0.1))
        .style(Style::Bold)
        .to_string()
}