Pattern Operation + small stuff

examples/pattern_playback.rs

···
     song::{
         event_command::NoteCommand,
         note_event::{Note, NoteEvent, VolumeEffect},
-        pattern::InPatternPosition,
+        pattern::{InPatternPosition, PatternOperation},
         song::Song,
     },
 };
···
     let mut song = manager.edit_song();
     song.set_sample(0, meta, sample);
     for i in 0..12 {
-        song.set_note_event(
-            0,
-            InPatternPosition { row: i, channel: i as u8 },
-            NoteEvent {
+        let command = PatternOperation::SetEvent {
+            position: InPatternPosition {
+                row: i,
+                channel: i as u8,
+            },
+            event: NoteEvent {
                 note: Note::new(60 + i as u8).unwrap(),
                 sample_instr: 0,
                 vol: VolumeEffect::None,
                 command: NoteCommand::None,
             },
-        );
+        };
+        song.pattern_operation(0, command);
     }
     song.set_order(
         0,
···
     manager.play_song(PlaybackSettings {});
 
     std::thread::sleep(Duration::from_secs(5));
-    while let Ok(event) = recv.try_next() {
-        println!("{event:?}");
-    }
+    manager.deinit_audio();
+    // while let Ok(event) = recv.try_next() {
+    //     println!("{event:?}");
+    // }
 }

simple-left-right/src/inner.rs

···
-
 use core::{cell::UnsafeCell, hint::unreachable_unchecked, sync::atomic::AtomicU8};
 
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]

simple-left-right/src/lib.rs

···
-#![warn(clippy::all, clippy::pedantic, clippy::perf, clippy::style, clippy::complexity, clippy::suspicious, clippy::correctness)]
-
-use std::{borrow::Borrow, cell::UnsafeCell, collections::VecDeque, marker::PhantomData, ops::Deref, sync::{atomic::{fence, AtomicU8, Ordering}, Arc}};
+#![warn(
+    clippy::all,
+    clippy::pedantic,
+    clippy::perf,
+    clippy::style,
+    clippy::complexity,
+    clippy::suspicious,
+    clippy::correctness
+)]
 
-use inner::{Ptr, ReadState, Shared};
+use std::{
+    borrow::Borrow,
+    cell::UnsafeCell,
+    collections::VecDeque,
+    marker::PhantomData,
+    ops::Deref,
+    sync::{
+        atomic::{fence, AtomicU8, Ordering},
+        Arc,
+    },
+};
 
 mod inner;
+
+use inner::{Ptr, ReadState, Shared};
 
 pub trait Absorb<O> {
     /// has to be deterministic. Operations will be applied in the same order to both buffers
···
             inner.value_1.get_mut().absorb(operation.clone());
             inner.value_2.get_mut().absorb(operation);
         } else {
-            self.get_data_mut().absorb(operation.clone());
-            self.writer.op_buffer.push_back(operation);
+            self.writer.op_buffer.push_back(operation.clone());
+            self.get_data_mut().absorb(operation);
         }
     }
 }
···
     }
 }
 
-/// This impl is only ok because this is an internal library. 
+/// This impl is only ok because this is an internal library.
 /// If one would publish the library it would lead to function name collisions
 /// If there ever is a internal collision, rename a function or remove this impl
 impl<T, O> Deref for Writer<T, O> {

src/audio_processing/sample.rs

···
 use std::ops::{ControlFlow, Deref};
 
-use crate::{sample::{SampleData, SampleMetaData, SampleRef}, song::note_event::{Note, NoteEvent}};
+use crate::{
+    sample::{SampleData, SampleMetaData, SampleRef},
+    song::note_event::Note,
+};
 
 use super::Frame;
 
···
             meta_data: sample.0,
             position: (SampleData::PAD_SIZE_EACH, 0.),
             out_rate,
-            step_size: Self::compute_step_size(sample.0.sample_rate, out_rate, sample.0.base_note, note),
+            step_size: Self::compute_step_size(
+                sample.0.sample_rate,
+                out_rate,
+                sample.0.base_note,
+                note,
+            ),
             note,
         }
     }
···
         }
     }
 
-    fn compute_step_size(in_rate: u32, out_rate: u32, sample_base_note: Note, playing_note: Note) -> f32 {
-        (f32::from(i16::from(playing_note.get()) - i16::from(sample_base_note.get())) / 12. ).exp2() * (out_rate as f32 / in_rate as f32)
+    fn compute_step_size(
+        in_rate: u32,
+        out_rate: u32,
+        sample_base_note: Note,
+        playing_note: Note,
+    ) -> f32 {
+        // original formula: (outrate / inrate) * (playing_freq / sample_base_freq).
+        // Where each freq is computed with MIDI tuning standard formula: 440 * 2^((note - 69)/12)
+        // manually reduced formula: 2^((play_note - sample_base_note)/12) * (outrate / inrate)
+        // herbie (https://herbie.uwplse.org/demo/index.html) can't optimize further: https://herbie.uwplse.org/demo/e096ef89ee257ad611dd56378bd139a065a6bea0.02e7ec5a3709ad3e06968daa97db50d636f1e44b/graph.html
+        (f32::from(i16::from(playing_note.get()) - i16::from(sample_base_note.get())) / 12.).exp2() * (out_rate as f32 / in_rate as f32)
     }
 
     fn set_step_size(&mut self) {
-        self.step_size = Self::compute_step_size(self.meta_data.sample_rate, self.out_rate, self.meta_data.base_note, self.note);
+        self.step_size = Self::compute_step_size(
+            self.meta_data.sample_rate,
+            self.out_rate,
+            self.meta_data.base_note,
+            self.note,
+        );
     }
 
     pub fn set_out_samplerate(&mut self, samplerate: u32) {
···
                 Frame::from((diff * self.position.1) + mono[self.position.0])
             }
             SampleData::Stereo(stereo) => {
-                let diff: Frame =
-                    Frame::from(stereo[self.position.0 + 1]) - Frame::from(stereo[self.position.0]);
+                let diff = Frame::from(stereo[self.position.0 + 1]) - Frame::from(stereo[self.position.0]);
 
-                (diff * self.position.1) + stereo[self.position.0].into()
+                (diff * self.position.1) + Frame::from(stereo[self.position.0])
             }
         };
 

src/live_audio.rs

···
 use crate::song::song::Song;
 use crate::{audio_processing::sample::SamplePlayer, playback::PlaybackState};
 use cpal::{Sample, SampleFormat};
+use simple_left_right::Reader;
 
 pub(crate) struct LiveAudio {
-    song: simple_left_right::Reader<Song<true>>,
+    song: Reader<Song<true>>,
     playback_state: Option<PlaybackState<'static, true>>,
     live_note: Option<SamplePlayer<'static, true>>,
     manager: Receiver<ToWorkerMsg>,
···
     const INTERPOLATION: u8 = Interpolation::Linear as u8;
 
     pub fn new(
-        song: simple_left_right::Reader<Song<true>>,
+        song: Reader<Song<true>>,
         manager: Receiver<ToWorkerMsg>,
         audio_msg_config: AudioMsgConfig,
         to_app: futures::channel::mpsc::Sender<FromWorkerMsg>,
···
     }
 
     #[inline]
-    /// returns if work was done
+    /// returns true if work was done
     fn fill_internal_buffer(&mut self) -> bool {
         let song = self.song.lock();
 
···
                     * usize::from(self.config.channel_count.get())
             );
 
-            // actual audio work
-            if self.fill_internal_buffer() {
-                // convert to the right output format
-                match data.sample_format() {
-                    SampleFormat::I8 => self.fill_from_internal::<i8>(data.as_slice_mut().unwrap()),
-                    SampleFormat::I16 => {
-                        self.fill_from_internal::<i16>(data.as_slice_mut().unwrap())
-                    }
-                    SampleFormat::I32 => {
-                        self.fill_from_internal::<i32>(data.as_slice_mut().unwrap())
-                    }
-                    SampleFormat::I64 => {
-                        self.fill_from_internal::<i64>(data.as_slice_mut().unwrap())
-                    }
-                    SampleFormat::U8 => self.fill_from_internal::<u8>(data.as_slice_mut().unwrap()),
-                    SampleFormat::U16 => {
-                        self.fill_from_internal::<u16>(data.as_slice_mut().unwrap())
-                    }
-                    SampleFormat::U32 => {
-                        self.fill_from_internal::<u32>(data.as_slice_mut().unwrap())
-                    }
-                    SampleFormat::U64 => {
-                        self.fill_from_internal::<u64>(data.as_slice_mut().unwrap())
-                    }
-                    SampleFormat::F32 => {
-                        self.fill_from_internal::<f32>(data.as_slice_mut().unwrap())
-                    }
-                    SampleFormat::F64 => {
-                        self.fill_from_internal::<f64>(data.as_slice_mut().unwrap())
-                    }
-                    /*
-                    I want to support all formats. This panic being triggered means that there is a version
-                    mismatch between cpal and this library.
-                    */
-                    _ => panic!("Sample Format not supported."),
-                }
+            // actual audio work, if false no work was done
+            if !self.fill_internal_buffer() {
+                return;
+            }
+
+            // convert to the right output format
+            match data.sample_format() {
+                SampleFormat::I8 => self.fill_from_internal::<i8>(data.as_slice_mut().unwrap()),
+                SampleFormat::I16 => self.fill_from_internal::<i16>(data.as_slice_mut().unwrap()),
+                SampleFormat::I32 => self.fill_from_internal::<i32>(data.as_slice_mut().unwrap()),
+                SampleFormat::I64 => self.fill_from_internal::<i64>(data.as_slice_mut().unwrap()),
+                SampleFormat::U8 => self.fill_from_internal::<u8>(data.as_slice_mut().unwrap()),
+                SampleFormat::U16 => self.fill_from_internal::<u16>(data.as_slice_mut().unwrap()),
+                SampleFormat::U32 => self.fill_from_internal::<u32>(data.as_slice_mut().unwrap()),
+                SampleFormat::U64 => self.fill_from_internal::<u64>(data.as_slice_mut().unwrap()),
+                SampleFormat::F32 => self.fill_from_internal::<f32>(data.as_slice_mut().unwrap()),
+                SampleFormat::F64 => self.fill_from_internal::<f64>(data.as_slice_mut().unwrap()),
+                /*
+                I want to support all formats. This panic being triggered means that there is a version
+                mismatch between cpal and this library.
+                */
+                _ => panic!("Sample Format not supported."),
             }
 
             if self.audio_msg_config.buffer_finished {

src/manager/audio_manager.rs

···
-use std::num::NonZeroU16;
+use std::{mem::ManuallyDrop, num::NonZeroU16};
 
 use basedrop::{Collector, Handle, Shared};
 use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
+use simple_left_right::{WriteGuard, Writer};
 
 use crate::{
     channel::Pan,
···
     sample::{SampleData, SampleMetaData},
     song::{
         note_event::NoteEvent,
-        pattern::InPatternPosition,
+        pattern::{InPatternPosition, Pattern, PatternOperation},
         song::{Song, SongOperation},
     },
 };
 
 pub struct AudioManager {
-    song: simple_left_right::Writer<Song<true>, SongOperation>,
-    gc: std::mem::ManuallyDrop<Collector>,
+    song: Writer<Song<true>, SongOperation>,
+    gc: ManuallyDrop<Collector>,
     stream: Option<(cpal::Stream, std::sync::mpsc::Sender<ToWorkerMsg>)>,
 }
 
···
         }
     }
 
-    /// resume the audio thread. doesn't start any playback
+    /// resume the audio thread. doesn't start any playback (only on some platforms, see cpal docs for stream.pause())
     pub fn resume_audio(&self) {
         if let Some((stream, _)) = &self.stream {
             stream.play().unwrap();
         }
     }
 
-    /// need to think about the API more
     pub fn play_note(&self, note_event: crate::song::note_event::NoteEvent) {
         if let Some((_, channel)) = &self.stream {
             channel.send(ToWorkerMsg::PlayEvent(note_event)).unwrap();
···
 // should do all the verfication of
 // need manuallyDrop because i need consume on drop behaviour
 pub struct SongEdit<'a> {
-    song: std::mem::ManuallyDrop<
-        simple_left_right::WriteGuard<'a, Song<true>, SongOperation>,
-    >,
+    song: ManuallyDrop<WriteGuard<'a, Song<true>, SongOperation>>,
     gc_handle: Handle,
 }
 
···
         self.song.apply_op(op);
     }
 
-    pub fn set_note_event(
-        &mut self,
-        pattern: usize,
-        position: InPatternPosition,
-        event: NoteEvent,
-    ) {
+    pub fn pattern_operation(&mut self, pattern: usize, op: PatternOperation) {
         assert!(pattern < Song::<false>::MAX_PATTERNS);
-        assert!(position.row < self.song.patterns[pattern].row_count());
-        let op = SongOperation::SetNoteEvent(pattern, position, event);
-        self.song.apply_op(op);
-    }
-
-    pub fn remove_note_event(&mut self, pattern: usize, position: InPatternPosition) {
-        assert!(pattern < Song::<false>::MAX_PATTERNS);
-        assert!(position.row < self.song.patterns[pattern].row_count());
-        let op = SongOperation::DeleteNoteEvent(pattern, position);
-        self.song.apply_op(op);
+        assert!(self.song.patterns[pattern].operation_is_valid(&op));
+        self.song.apply_op(SongOperation::PatternOperation(pattern, op));
     }
 
     pub fn set_order(&mut self, idx: usize, order: PatternOrder) {
···
     }
 
     /// Finish the changes and publish them to the live playing song
-    pub fn finish(self) {
-        drop(self)
-    }
+    pub fn finish(self) {}
 }
 
 impl Drop for SongEdit<'_> {
···
         // SAFETY:
         // the ManuallyDrop isn't used after this as this is the drop function
         // can't use into_inner, as i only have &mut not owned
-        unsafe { std::mem::ManuallyDrop::take(&mut self.song) }.swap()
+        unsafe { ManuallyDrop::take(&mut self.song) }.swap()
     }
 }
 

src/playback.rs

···
     pub fn get_position(&self) -> PlaybackPosition {
         self.position
     }
+
+    pub fn set_samplerate(&mut self, samplerate: u32) {
+        self.samplerate = samplerate;
+        self.voices.iter_mut().flatten().for_each(|voice| voice.set_out_samplerate(samplerate));
+    }
 }
 
 macro_rules! new {

src/song/pattern.rs

···
     pub channel: u8,
 }
 
-const fn key(data: &(InPatternPosition, NoteEvent)) -> InPatternPosition {
-    data.0
-}
-
 #[cfg(test)]
 mod test {
     use crate::song::pattern::InPatternPosition;
···
     data: Vec<(InPatternPosition, NoteEvent)>,
 }
 
+const fn key(data: &(InPatternPosition, NoteEvent)) -> InPatternPosition {
+    data.0
+}
+
 impl Default for Pattern {
     fn default() -> Self {
         Self::new(Self::DEFAULT_ROWS)
···
     pub const DEFAULT_ROWS: u16 = 64;
 
     /// panics if len larger than 'Self::MAX_LEN'
-    pub fn new(len: u16) -> Self {
+    pub const fn new(len: u16) -> Self {
         assert!(len <= Self::MAX_ROWS);
         Self {
             rows: len,
···
         assert!(new_len <= Self::MAX_ROWS);
         // gets the index of the first element of the first row to be removed
         if new_len < self.rows {
-            let idx = self
-                .data
-                .binary_search_by_key(
-                    &InPatternPosition {
-                        row: new_len,
-                        channel: 0,
-                    },
-                    |(pos, _)| *pos,
-                )
-                .unwrap_or_else(|i| i);
+            let idx = self.data.partition_point(|(pos, _)| pos.row < new_len);
             self.data.truncate(idx);
         }
         self.rows = new_len;
···
     /// overwrites the event if the row already has an event for that channel
     /// panics if the row position is larger than current amount of rows
     pub fn set_event(&mut self, position: InPatternPosition, event: NoteEvent) {
-        assert!(self.rows > position.row);
+        assert!(position.row < self.rows);
         match self.data.binary_search_by_key(&position, key) {
             Ok(idx) => self.data[idx].1 = event,
             Err(idx) => self.data.insert(idx, (position, event)),
···
 
     /// if there is no event, does nothing
     pub fn remove_event(&mut self, position: InPatternPosition) {
-        if let Ok(index) = self.data.binary_search_by_key(&position, |(pos, _)| *pos) {
+        if let Ok(index) = self.data.binary_search_by_key(&position, key) {
             self.data.remove(index);
         }
     }
 
-    pub fn row_count(&self) -> u16 {
+    pub const fn row_count(&self) -> u16 {
         self.rows
     }
+
+    /// Panics if the Operation is invalid
+    pub fn apply_operation(&mut self, op: PatternOperation) {
+        match op {
+            PatternOperation::SetLength { new_len } => self.set_length(new_len),
+            PatternOperation::SetEvent { position, event } => self.set_event(position, event),
+            PatternOperation::RemoveEvent { position } => self.remove_event(position),
+            
+        }
+    }
+
+    pub const fn operation_is_valid(&self, op: &PatternOperation) -> bool {
+        match op {
+            PatternOperation::SetLength { new_len } => *new_len < Self::MAX_ROWS,
+            PatternOperation::SetEvent { position, event: _ } => position.row < self.rows && position.channel as usize <= Song::<false>::MAX_CHANNELS,
+            PatternOperation::RemoveEvent { position: _ } => true,
+        }
+    }
 }
 
 impl Index<u16> for Pattern {
···
 }
 
 /// assumes the Operations are correct (not out of bounds, ...)
+#[derive(Debug, Clone, Copy)]
 pub enum PatternOperation {
-    Load(Box<[Pattern; Song::<false>::MAX_PATTERNS]>),
     SetLength {
-        pattern: usize,
         new_len: u16,
     },
     SetEvent {
-        pattern: usize,
-        row: u16,
-        channel: u8,
+        position: InPatternPosition,
         event: NoteEvent,
     },
     RemoveEvent {
-        pattern: usize,
-        row: u16,
-        channel: u8,
+        position: InPatternPosition,
     },
 }

src/song/song.rs

···
 use basedrop::Shared;
 
 use super::note_event::NoteEvent;
-use super::pattern::InPatternPosition;
+use super::pattern::{InPatternPosition, PatternOperation};
 
 #[derive(Clone)]
 pub struct Project<const GC: bool> {
···
     SetVolume(usize, u8),
     SetPan(usize, Pan),
     SetSample(usize, SampleMetaData, Shared<SampleData>),
-    SetNoteEvent(usize, InPatternPosition, NoteEvent),
-    DeleteNoteEvent(usize, InPatternPosition),
+    PatternOperation(usize, PatternOperation),
     SetOrder(usize, PatternOrder),
 }
 
···
         match operation {
             SongOperation::SetVolume(chan, val) => self.volume[chan] = val,
             SongOperation::SetPan(chan, val) => self.pan[chan] = val,
-            SongOperation::SetSample(sample, meta, data) => {
-                self.samples[sample] = Some((meta, Sample::<true>::new(data)))
-            }
-            SongOperation::SetNoteEvent(pattern, position, event) => {
-                self.patterns[pattern].set_event(position, event)
-            }
-            SongOperation::DeleteNoteEvent(pattern, position) => {
-                self.patterns[pattern].remove_event(position)
-            }
+            SongOperation::SetSample(sample, meta, data) => self.samples[sample] = Some((meta, Sample::<true>::new(data))),
+            SongOperation::PatternOperation(pattern, op) => self.patterns[pattern].apply_operation(op),
             SongOperation::SetOrder(idx, order) => self.pattern_order[idx] = order,
         }
     }