Working with bot!

+ decode returns numbers of samples per channel, we were effectively chomping half the samples
+ needs a lot of cleanup

src/audio_source.rs

@@ -1,8 +1,7 @@
-use crate::output_buffer::OutputBuffer;
+use crate::tx_thread::TxThread;
 use crate::udp_connection::OpusUdpConnection;
-use crate::{
-    CIRC_BUFFER_SIZE, SAMPLE_RATE, SAMPLE_RATE_RAW,
-    STEREO_FRAME_SIZE,
+use crate::util::{
+    SAMPLE_RATE, SAMPLE_RATE_RAW, STEREO_FRAME_SIZE, ThreadMessage,
 };
 use anyhow::Error;
 use audiopus::coder::Encoder;
@@ -11,7 +10,8 @@ use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
 use cpal::{BufferSize, FromSample, Host, Sample, StreamConfig};
 use log::{error, info};
 use std::net::SocketAddr;
-use std::sync::{Arc, Mutex};
+use std::sync::mpsc::{Sender, channel};
+use std::thread;
 
 pub fn tap(
     device: &str,
@@ -36,7 +36,7 @@ pub fn tap(
 
     let mut stream_config = StreamConfig::from(config.clone());
     stream_config.sample_rate = cpal::SampleRate(SAMPLE_RATE_RAW as u32);
-    stream_config.buffer_size = BufferSize::Fixed(STEREO_FRAME_SIZE as u32);
+    stream_config.buffer_size = BufferSize::Fixed(STEREO_FRAME_SIZE as u32 * 2);
 
     for cfg in device.supported_input_configs()? {
         info!("{:?}", cfg)
@@ -50,39 +50,38 @@ pub fn tap(
     encoder.set_complexity(10)?;
     encoder.set_signal(Signal::Music)?;
 
-    let sound_buffer = Arc::new(Mutex::new(OutputBuffer::new(
-        STEREO_FRAME_SIZE,
-        encoder,
-        udp_connection,
-    )));
+    let (sender, receiver) = channel();
+
+    let tx_thread = TxThread::new(receiver, encoder, udp_connection);
+
+    thread::spawn(move || tx_thread.thread());
 
     let err_fn = move |err| {
         error!("an error occurred on stream: {err}");
     };
 
-    let sound_buffer2 = sound_buffer.clone();
     let stream = match config.sample_format() {
         cpal::SampleFormat::I8 => device.build_input_stream(
             &stream_config,
-            move |data, _: &_| write_input_data::<CIRC_BUFFER_SIZE, i8>(data, &sound_buffer2),
+            move |data, _: &_| write_input_data::<i8>(data, &sender),
             err_fn,
             None,
         )?,
         cpal::SampleFormat::I16 => device.build_input_stream(
             &stream_config,
-            move |data, _: &_| write_input_data::<CIRC_BUFFER_SIZE, i16>(data, &sound_buffer2),
+            move |data, _: &_| write_input_data::<i16>(data, &sender),
             err_fn,
             None,
         )?,
         cpal::SampleFormat::I32 => device.build_input_stream(
             &stream_config,
-            move |data, _: &_| write_input_data::<CIRC_BUFFER_SIZE, i32>(data, &sound_buffer2),
+            move |data, _: &_| write_input_data::<i32>(data, &sender),
             err_fn,
             None,
         )?,
         cpal::SampleFormat::F32 => device.build_input_stream(
             &stream_config,
-            move |data, _: &_| write_input_data::<CIRC_BUFFER_SIZE, f32>(data, &sound_buffer2),
+            move |data, _: &_| write_input_data::<f32>(data, &sender),
             err_fn,
             None,
         )?,
@@ -96,23 +95,20 @@ pub fn tap(
     info!("Running tap...");
     stream.play()?;
 
-    std::thread::park();
+    thread::park();
 
     info!("Exiting...");
     Ok(())
 }
 
-fn write_input_data<const N: usize, T>(
-    input: &[T],
-    ctx: &Arc<Mutex<OutputBuffer<N, OpusUdpConnection>>>,
-) where
+fn write_input_data<T>(input: &[T], ctx: &Sender<ThreadMessage>)
+where
     T: Sample,
     f32: FromSample<T>,
 {
-    let mut ctx = ctx.lock().expect("Mutex poisoned");
     let sample: Vec<f32> = input.iter().map(|s| f32::from_sample(*s)).collect();
 
-    if let Err(err) = ctx.write_data(&sample) {
-        error!("Got error when writing data to sound buffer: {err}")
+    if let Err(err) = ctx.send(ThreadMessage::Data(sample)) {
+        error!("Got error when sending data: {err}")
     }
 }