Merge pull request #123 from mum-rs/typestate

Typestate

mum/src/audio.rs

@@ -175,6 +175,9 @@ impl AudioOutput {
     /// Queues a sound effect.
     pub fn play_effect(&self, effect: NotificationEvents) {
         let samples = self.sounds.get(&effect).unwrap();
-        self.client_streams.lock().unwrap().add_sound_effect(samples);
+        self.client_streams
+            .lock()
+            .unwrap()
+            .add_sound_effect(samples);
     }
 }

mum/src/audio/input.rs

@@ -5,8 +5,8 @@ use log::*;
 use std::fmt::Debug;
 use tokio::sync::watch;
 
-use crate::audio::SAMPLE_RATE;
 use crate::audio::transformers::{NoiseGate, Transformer};
+use crate::audio::SAMPLE_RATE;
 use crate::error::{AudioError, AudioStream};
 use crate::state::StatePhase;
 
@@ -32,7 +32,9 @@ pub fn callback<T: Sample>(
             buffer.extend(data.by_ref().take(buffer_size - buffer.len()));
             let encoded = transformers
                 .iter_mut()
-                .try_fold((opus::Channels::Mono, &mut buffer[..]), |acc, e| e.transform(acc))
+                .try_fold((opus::Channels::Mono, &mut buffer[..]), |acc, e| {
+                    e.transform(acc)
+                })
                 .map(|buf| opus_encoder.encode_vec_float(&*buf.1, buffer_size).unwrap());
 
             if let Some(encoded) = encoded {
@@ -109,14 +111,18 @@ impl DefaultAudioInputDevice {
             match input_config.channels {
                 1 => opus::Channels::Mono,
                 2 => opus::Channels::Stereo,
-                _ => unimplemented!("Only 1 or 2 channels supported, got {}", input_config.channels),
+                _ => unimplemented!(
+                    "Only 1 or 2 channels supported, got {}",
+                    input_config.channels
+                ),
             },
             opus::Application::Voip,
         )
         .unwrap();
         let buffer_size = (sample_rate.0 * frame_size / 400) as usize;
 
-        let transformers = vec![Box::new(NoiseGate::new(50)) as Box<dyn Transformer + Send + 'static>];
+        let transformers =
+            vec![Box::new(NoiseGate::new(50)) as Box<dyn Transformer + Send + 'static>];
 
         let input_stream = match input_supported_sample_format {
             SampleFormat::F32 => input_device.build_input_stream(
@@ -127,7 +133,7 @@ impl DefaultAudioInputDevice {
                     opus_encoder,
                     buffer_size,
                     input_volume_receiver,
-                    phase_watcher
+                    phase_watcher,
                 ),
                 err_fn,
             ),
@@ -139,7 +145,7 @@ impl DefaultAudioInputDevice {
                     opus_encoder,
                     buffer_size,
                     input_volume_receiver,
-                    phase_watcher
+                    phase_watcher,
                 ),
                 err_fn,
             ),
@@ -151,7 +157,7 @@ impl DefaultAudioInputDevice {
                     opus_encoder,
                     buffer_size,
                     input_volume_receiver,
-                    phase_watcher
+                    phase_watcher,
                 ),
                 err_fn,
             ),
@@ -170,15 +176,11 @@ impl DefaultAudioInputDevice {
 
 impl AudioInputDevice for DefaultAudioInputDevice {
     fn play(&self) -> Result<(), AudioError> {
-        self.stream
-            .play()
-            .map_err(AudioError::InputPlayError)
+        self.stream.play().map_err(AudioError::InputPlayError)
     }
 
     fn pause(&self) -> Result<(), AudioError> {
-        self.stream
-            .pause()
-            .map_err(AudioError::InputPauseError)
+        self.stream.pause().map_err(AudioError::InputPauseError)
     }
 
     fn set_volume(&self, volume: f32) {

mum/src/audio/output.rs

@@ -53,16 +53,23 @@ impl ClientAudioData {
             .expect("Error decoding");
         out.truncate(parsed);
         match (packet_channels, self.output_channels) {
-            (opus::Channels::Mono, opus::Channels::Mono) | (opus::Channels::Stereo, opus::Channels::Stereo) => for sample in out {
-                self.buf.push(sample);
-            },
-            (opus::Channels::Mono, opus::Channels::Stereo) => for sample in out {
-                self.buf.push(sample);
-                self.buf.push(sample);
-            },
-            (opus::Channels::Stereo, opus::Channels::Mono) => for sample in out.into_iter().step_by(2) {
-                self.buf.push(sample);
-            },
+            (opus::Channels::Mono, opus::Channels::Mono)
+            | (opus::Channels::Stereo, opus::Channels::Stereo) => {
+                for sample in out {
+                    self.buf.push(sample);
+                }
+            }
+            (opus::Channels::Mono, opus::Channels::Stereo) => {
+                for sample in out {
+                    self.buf.push(sample);
+                    self.buf.push(sample);
+                }
+            }
+            (opus::Channels::Stereo, opus::Channels::Mono) => {
+                for sample in out.into_iter().step_by(2) {
+                    self.buf.push(sample);
+                }
+            }
         }
     }
 }
@@ -92,9 +99,9 @@ impl ClientStream {
     }
 
     fn get_client(&mut self, client: ClientStreamKey) -> &mut ClientAudioData {
-        self.buffer_clients.entry(client).or_insert(
-            ClientAudioData::new(self.sample_rate, self.output_channels)
-        )
+        self.buffer_clients
+            .entry(client)
+            .or_insert(ClientAudioData::new(self.sample_rate, self.output_channels))
     }
 
     /// Decodes a voice packet.
@@ -116,7 +123,7 @@ impl ClientStream {
 }
 
 /// Adds two values in some saturating way.
-/// 
+///
 /// Since we support [f32], [i16] and [u16] we need some way of adding two values
 /// without peaking above/below the edge values. This trait ensures that we can
 /// use all three primitive types as a generic parameter.
@@ -183,7 +190,10 @@ impl DefaultAudioOutputDevice {
             .supported_output_configs()
             .map_err(|e| AudioError::NoConfigs(AudioStream::Output, e))?
             .find_map(|c| {
-                if c.min_sample_rate() <= sample_rate && c.max_sample_rate() >= sample_rate && c.channels() == 2 {
+                if c.min_sample_rate() <= sample_rate
+                    && c.max_sample_rate() >= sample_rate
+                    && c.channels() == 2
+                {
                     Some(c)
                 } else {
                     None
@@ -244,15 +254,11 @@ impl DefaultAudioOutputDevice {
 
 impl AudioOutputDevice for DefaultAudioOutputDevice {
     fn play(&self) -> Result<(), AudioError> {
-        self.stream
-            .play()
-            .map_err(AudioError::OutputPlayError)
+        self.stream.play().map_err(AudioError::OutputPlayError)
     }
 
     fn pause(&self) -> Result<(), AudioError> {
-        self.stream
-            .pause()
-            .map_err(AudioError::OutputPauseError)
+        self.stream.pause().map_err(AudioError::OutputPauseError)
     }
 
     fn set_volume(&self, volume: f32) {
@@ -288,9 +294,7 @@ pub fn callback<T: Sample + AddAssign + SaturatingAdd + std::fmt::Display>(
             let (user_volume, muted) = user_volumes.get(&k.1).cloned().unwrap_or((1.0, false));
             if !muted {
                 for (sample, val) in data.iter_mut().zip(v.buf.drain().chain(iter::repeat(0.0))) {
-                    *sample = sample.saturating_add(Sample::from(
-                        &(val * volume * user_volume),
-                    ));
+                    *sample = sample.saturating_add(Sample::from(&(val * volume * user_volume)));
                 }
             }
         }

mum/src/audio/sound_effects.rs

@@ -69,16 +69,17 @@ impl TryFrom<&str> for NotificationEvents {
             "unmute" => Ok(NotificationEvents::Unmute),
             "deafen" => Ok(NotificationEvents::Deafen),
             "undeafen" => Ok(NotificationEvents::Undeafen),
-            _ => {
-                Err(())
-            }
+            _ => Err(()),
         }
     }
 }
 
 /// Loads files into an "event -> data"-map, with support for overriding
 /// specific events with another sound file.
-pub fn load_sound_effects(overrides: &[SoundEffect], num_channels: usize) -> HashMap<NotificationEvents, Vec<f32>> {
+pub fn load_sound_effects(
+    overrides: &[SoundEffect],
+    num_channels: usize,
+) -> HashMap<NotificationEvents, Vec<f32>> {
     let overrides: HashMap<_, _> = overrides
         .iter()
         .filter_map(|sound_effect| {

mum/src/audio/transformers.rs

@@ -2,7 +2,10 @@
 pub trait Transformer {
     /// Do the transform. Returning `None` is interpreted as "the buffer is unwanted".
     /// The implementor is free to modify the buffer however it wants to.
-    fn transform<'a>(&mut self, buf: (opus::Channels, &'a mut [f32])) -> Option<(opus::Channels, &'a mut [f32])>;
+    fn transform<'a>(
+        &mut self,
+        buf: (opus::Channels, &'a mut [f32]),
+    ) -> Option<(opus::Channels, &'a mut [f32])>;
 }
 
 /// A struct representing a noise gate transform.
@@ -26,10 +29,17 @@ impl NoiseGate {
 }
 
 impl Transformer for NoiseGate {
-    fn transform<'a>(&mut self, (channels, buf): (opus::Channels, &'a mut [f32])) -> Option<(opus::Channels, &'a mut [f32])> {
+    fn transform<'a>(
+        &mut self,
+        (channels, buf): (opus::Channels, &'a mut [f32]),
+    ) -> Option<(opus::Channels, &'a mut [f32])> {
         const MUTE_PERCENTAGE: f32 = 0.1;
 
-        let max = buf.iter().map(|e| e.abs()).max_by(|a, b| a.partial_cmp(b).unwrap()).unwrap();
+        let max = buf
+            .iter()
+            .map(|e| e.abs())
+            .max_by(|a, b| a.partial_cmp(b).unwrap())
+            .unwrap();
 
         if max > self.alltime_high {
             self.alltime_high = max;

mum/src/command.rs

@@ -4,7 +4,13 @@ use crate::state::{ExecutionContext, State};
 use log::*;
 use mumble_protocol::{control::ControlPacket, Serverbound};
 use mumlib::command::{Command, CommandResponse};
-use std::{rc::Rc, sync::{Arc, RwLock, atomic::{AtomicBool, AtomicU64, Ordering}}};
+use std::{
+    rc::Rc,
+    sync::{
+        atomic::{AtomicBool, AtomicU64, Ordering},
+        Arc, RwLock,
+    },
+};
 use tokio::sync::{mpsc, watch};
 
 pub async fn handle(