fix: write jack events in order (many allocations)

src/device/sequencer.rs

@@ -97,6 +97,9 @@ impl Sequencer {
     }
 
     fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
+
+        // Update time
+        let mut sequence = &mut self.sequences[self.sequence];
         let transport = self.transport.query().unwrap();
         self.playing = transport.state;
         let pos   = &transport.pos;
@@ -104,15 +107,61 @@ impl Sequencer {
         let steps = usecs / self.timebase.usec_per_step(self.resolution as usize);
         let step  = steps % self.steps;
         let tick  = step * self.timebase.ppq() / self.resolution;
-        let mut sequence = &mut self.sequences[self.sequence];
+
-        let mut writer = self.output_port.writer(scope);
+        // Prepare output buffer
+        let frames = scope.n_frames() as usize;
+        let mut output: Vec<Option<Vec<Vec<u8>>>> = vec![None;frames];
+
+        // Read from input
+        for event in self.input_port.iter(scope) {
+
+            // Write to output
+            if self.monitoring {
+                let t = event.time as usize;
+                if output[t].is_none() {
+                    output[t] = Some(vec![]);
+                }
+                if let Some(Some(frame)) = output.get_mut(t) {
+                    frame.push(event.bytes.into())
+                }
+            }
+
+            // Write to sequence
+            if self.recording {
+                let tick = tick as u32;
+                match midly::live::LiveEvent::parse(event.bytes).unwrap() {
+                    midly::live::LiveEvent::Midi { channel: _, message } => match message {
+                        midly::MidiMessage::NoteOn { key, vel: _ } => {
+                            self.notes_on[key.as_int() as usize] = true;
+                            let contains = sequence.contains_key(&tick);
+                            if contains {
+                                sequence.get_mut(&tick).unwrap().push(message.clone());
+                            } else {
+                                sequence.insert(tick, vec![message.clone()]);
+                            }
+                        },
+                        midly::MidiMessage::NoteOff { key, vel: _ } => {
+                            self.notes_on[key.as_int() as usize] = false;
+                            let contains = sequence.contains_key(&tick);
+                            if contains {
+                                sequence.get_mut(&tick).unwrap().push(message.clone());
+                            } else {
+                                sequence.insert(tick, vec![message.clone()]);
+                            }
+                        },
+                        _ => {}
+                    },
+                    _ => {}
+                }
+            }
+
+        }
+
+        // Play from sequence
         if self.playing == TransportState::Rolling {
             let frame = transport.pos.frame() as usize;
-            let ticks = self.timebase.frames_to_ticks(
+            let quant = self.timebase.fpb() as usize * self.steps / self.resolution;
-                frame,
+            let ticks = self.timebase.frames_to_ticks(frame, frame + frames, quant);
-                frame + scope.n_frames() as usize,
-                self.timebase.fpb() as usize * self.steps / self.resolution
-            );
             for (time, tick) in ticks.iter() {
                 if let Some(events) = sequence.get(&(*tick as u32)) {
                     for message in events.iter() {
@@ -121,16 +170,34 @@ impl Sequencer {
                             channel: 0.into(),
                             message: *message,
                         }.write(&mut buf).unwrap();
-                        let midi = ::jack::RawMidi {
+                        let t = *time as usize;
-                            time: *time as u32,
+                        if output[t].is_none() {
-                            bytes: &buf
+                            output[t] = Some(vec![]);
-                        };
+                        }
-                        writer.write(&midi).expect(&format!("{midi:?}"));
+                        if let Some(Some(frame)) = output.get_mut(t) {
-                        //panic!("{midi:?}");
+                            frame.push(buf);
+                        }
                     }
                 }
             }
         }
+
+        let mut writer = self.output_port.writer(scope);
+        for t in 0..scope.n_frames() {
+            if let Some(Some(frame)) = output.get_mut(t as usize) {
+                for event in frame.iter() {
+                    writer.write(&::jack::RawMidi {
+                        time:  t,
+                        bytes: &event
+                    }).expect(&format!("{event:?}"));
+                }
+            }
+        }
+
+        ////
+
+        if self.playing == TransportState::Rolling {
+        }
         for event in self.input_port.iter(scope) {
             if self.monitoring {
                 writer.write(&event).expect(&format!("{event:?}"))