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

use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use std::error::Error;
use std::sync::{Arc, Mutex};

pub struct AudioCapture {
    pub device: cpal::Device, // Make public
    pub samples: Arc<Mutex<Vec<f32>>>,
}

impl Default for AudioCapture {
    fn default() -> Self {
        Self::new_with_device(match cpal::default_host().default_input_device() {
            Some(device) => device,
            None => panic!("No input device available"),
        })
        .unwrap()
    }
}

impl std::fmt::Debug for AudioCapture {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("AudioCapture")
            .field("device", &self.device.name().unwrap())
            // .field("config", &self.config)
            .finish()
    }
}

impl AudioCapture {
    pub fn new_with_device(device: cpal::Device) -> Result<Self, Box<dyn Error>> {
        Ok(Self {
            device,
            samples: Arc::new(Mutex::new(Vec::new())),
        })
    }

    // UPDATED METHOD: Now takes config as an argument.
    pub fn start_listening(
        &self,
        config: &cpal::StreamConfig,
    ) -> Result<cpal::Stream, Box<dyn Error>> {
        let samples = Arc::clone(&self.samples);
        let stream = self.device.build_input_stream(
            config, // Use the provided config
            move |data: &[f32], _: &_| {
                samples.lock().unwrap().extend_from_slice(data);
            },
            |err| eprintln!("Error in input stream: {}", err),
            None,
        )?;
        Ok(stream)
    }

    pub fn get_samples(&self) -> Vec<f32> {
        let mut samples = self.samples.lock().unwrap();
        let result = samples.to_vec();
        samples.clear();
        result
    }
}

pub struct AudioPlayback {
    pub device: cpal::Device, // Make public
}

// Remove the `config` field from the struct.

impl AudioPlayback {
    pub fn new_with_device(device: cpal::Device) -> Result<Self, Box<dyn Error>> {
        Ok(Self { device })
    }

    // UPDATED METHOD: Now takes config as an argument.
    pub fn transmit(
        &self,
        config: &cpal::StreamConfig,
        samples: &[f32],
    ) -> Result<cpal::Stream, Box<dyn Error>> {
        let channels = config.channels as usize;
        let samples_arc = Arc::new(samples.to_vec());
        let mut sample_clock = 0;

        let stream = self.device.build_output_stream(
            config, // Use the provided config
            move |data: &mut [f32], _: &_| {
                for frame in data.chunks_mut(channels) {
                    let sample_value = *samples_arc.get(sample_clock).unwrap_or(&0.0);
                    for sample in frame.iter_mut() {
                        *sample = sample_value;
                    }
                    sample_clock += 1;
                }
            },
            |err| eprintln!("Error in output stream: {}", err),
            None,
        )?;
        Ok(stream)
    }

}