prepare different effect handlers

tracker-engine/src/file/mod.rs

···
 ///
 /// R should be buffered in some way and not do a syscall on every read.
 /// If you ever find yourself using multiple different reader and/or handlers please open an issue on Github, i will change this to take &dyn.
-pub fn parse_song<R: std::io::Read + std::io::Seek, H: FnMut(LoadDefect)>(
+pub fn parse_song<R: std::io::Read + std::io::Seek>(
     reader: &mut R,
-    defect_handler: &mut H,
 ) -> Result<Song<false>, LoadErr> {
-    let header = header::ImpulseHeader::parse(reader, defect_handler)?;
+    //ignore defects
+    let mut defect_handler = |_| ();
+    let header = header::ImpulseHeader::parse(reader, &mut defect_handler)?;
     let mut song = Song::default();
     song.copy_values_from_header(&header);
 
···
         .flat_map(|(idx, ptr)| ptr.map(|ptr| (idx, ptr)))
     {
         ptr.move_to_self(reader)?;
-        let pattern = pattern::parse_pattern(reader, defect_handler)?;
+        let pattern = pattern::parse_pattern(reader, &mut defect_handler)?;
         song.patterns[idx] = pattern;
     }
 

tracker-engine/src/live_audio.rs

···
     }
 
     fn send_state(&mut self, info: Option<Info>) {
-        self.state_sender.write((
-            self.playback_state.as_ref().map(|s| s.get_status()),
-            info,
-        ));
+        self.state_sender
+            .write((self.playback_state.as_ref().map(|s| s.get_status()), info));
     }
 
     #[inline]

tracker-engine/src/manager.rs

···
 
     use super::{OutputConfig, OutputStream, StreamBuilder};
 
-
     impl<Stream: cpal::traits::StreamTrait> OutputStream for Stream {
         type BufferInformation = cpal::OutputStreamTimestamp;
-    
+
         type PauseErr = cpal::PauseStreamError;
-    
+
         type PlayErr = cpal::PlayStreamError;
-    
+
         fn pause(&mut self) -> Result<(), Self::PauseErr> {
             <Self as cpal::traits::StreamTrait>::pause(self)
         }
-    
+
         fn play(&mut self) -> Result<(), Self::PlayErr> {
             <Self as cpal::traits::StreamTrait>::play(self)
         }
···
         type Stream = Device::Stream;
         fn create(
             self,
-            mut data_callback: impl FnMut(&mut [f32], <<Self as StreamBuilder>::Stream as OutputStream>::BufferInformation)
-                + Send
+            mut data_callback: impl FnMut(
+                    &mut [f32],
+                    <<Self as StreamBuilder>::Stream as OutputStream>::BufferInformation,
+                ) + Send
                 + 'static,
             err_callback: impl FnMut(Self::StreamErr) + Send + 'static,
             config: OutputConfig,
···
 
     impl TryFrom<cpal::StreamConfig> for OutputConfig {
         type Error = ();
-    
+
         /// fails if BufferSize isn't explicit or zero output channels are specified.
         fn try_from(value: cpal::StreamConfig) -> Result<Self, Self::Error> {
             match value.buffer_size {
···
     status: triple_buffer::Output<(Option<PlaybackStatus>, Option<S::BufferInformation>)>,
 }
 
-impl<S: OutputStream> Debug for ActiveStream<S> 
-where 
-    S::BufferInformation: Debug
+impl<S: OutputStream> Debug for ActiveStream<S>
+where
+    S::BufferInformation: Debug,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("ActiveStream")
···
     }
 
     /// last playback status sent by the audio worker
-    pub fn playback_status(&mut self) -> Option<&(Option<PlaybackStatus>, Option<S::BufferInformation>)> {
+    pub fn playback_status(
+        &mut self,
+    ) -> Option<&(Option<PlaybackStatus>, Option<S::BufferInformation>)> {
         self.stream.as_mut().map(|s| s.status.read())
     }
 
···
         &mut self,
         create_stream: Builder,
         config: OutputConfig,
-    ) -> Result<(), Builder::CreateErr> 
+    ) -> Result<(), Builder::CreateErr>
     where
-        Builder: StreamBuilder<Stream = S>
+        Builder: StreamBuilder<Stream = S>,
     {
         const TO_WORKER_CAPACITY: usize = 5;
 
···
         let to_worker = rtrb::RingBuffer::new(TO_WORKER_CAPACITY);
         let reader = self.song.build_reader().unwrap();
 
-        let audio_worker = LiveAudio::<S::BufferInformation>::new(reader, to_worker.1, from_worker.0, config);
+        let audio_worker =
+            LiveAudio::<S::BufferInformation>::new(reader, to_worker.1, from_worker.0, config);
 
         // let stream = device.build_output_stream_raw(
         //     &config.into(),
···
         //     |err| println!("{err}"),
         //     None,
         // )?;
-        let stream = create_stream.create(audio_worker.get_typed_callback(), |err| eprintln!("{err:?}"), config)?;
+        let stream = create_stream.create(
+            audio_worker.get_typed_callback(),
+            |err| eprintln!("{err:?}"),
+            config,
+        )?;
         let buffer_time =
             Duration::from_millis((config.buffer_size * 1000 / config.buffer_size).into());