Implement cutting via stream

Author: Tehforsch

Cargo.lock

@@ -12,6 +12,7 @@ anyhow = "1.0.86"
 chrono = "0.4.38"
 clap = { version = "4.5.11", features = ["derive"] }
 dbus = "0.9.7"
+futures = "0.3.30"
 hound = "3.5.1"
 iced = { version = "0.12.1", features = ["canvas"] }
 log = "0.4.22"

Cargo.toml

@@ -15,14 +15,14 @@ use crate::consts::{self};
 use crate::recording_session::RecordingSessionWithPath;
 use crate::song::Song;
 
-#[derive(Deserialize, Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug, Clone)]
 pub struct Cut {
     pub start_time_secs: f64,
     pub end_time_secs: f64,
     pub song: Song,
 }
 
-#[derive(Deserialize, Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug, Clone)]
 pub struct CutInfo {
     pub buffer_file: PathBuf,
     pub music_dir: PathBuf,

src/audio/cut.rs

@@ -3,6 +3,7 @@ use std::{
     process::Child,
 };
 
+use futures::{channel::mpsc::Sender, SinkExt};
 use log::{error, warn};
 
 use crate::recording_session::{RecordingSession, RecordingSessionWithPath};
@@ -57,15 +58,17 @@ fn filter_invalid_songs(reader: &mut WavFileReader, session: &mut RecordingSessi
 
 pub struct Cutter {
     cuts: Vec<CutInfo>,
-    handles: Vec<Child>,
+    handles: Vec<(Child, CutInfo)>,
+    sender: Sender<CutInfo>,
 }
 
 impl Cutter {
-    pub async fn run(path: PathBuf, strategy: impl CuttingStrategy) {
+    pub async fn run(path: PathBuf, strategy: impl CuttingStrategy, sender: Sender<CutInfo>) {
         let cuts = get_cuts(&path, strategy);
         Self {
             cuts,
             handles: vec![],
+            sender,
         }
         .run_internal()
         .await
@@ -85,13 +88,13 @@ impl Cutter {
                 if let Some(cut) = self.pop_front() {
                     let mut command = get_cut_command(&cut).unwrap();
                     self.handles
-                        .push(command.spawn().expect("Failed to cut song."));
+                        .push((command.spawn().expect("Failed to cut song."), cut.clone()));
                 }
             }
             let mut finished: Vec<_> = self
                 .handles
                 .iter_mut()
-                .map(|handle| match handle.try_wait().unwrap() {
+                .map(|(handle, _)| match handle.try_wait().unwrap() {
                     Some(status) => {
                         if status.success() {
                             true
@@ -102,8 +105,12 @@ impl Cutter {
                     None => false,
                 })
                 .collect();
-            let (_, still_running): (Vec<_>, Vec<_>) =
+            let (finished, still_running): (Vec<_>, Vec<_>) =
                 self.handles.drain(..).partition(|_| finished.remove(0));
+
+            for (_, cut) in finished {
+                self.sender.send(cut).await.unwrap()
+            }
             self.handles = still_running;
         }
     }

src/audio/cutter.rs

@@ -126,7 +126,14 @@ impl Manual {
 }
 
 impl CuttingStrategy for Manual {
-    fn get_timestamps(&self, _: &mut WavFileReader, _: &RecordingSession) -> Vec<AudioTime> {
-        self.0.clone()
+    fn get_timestamps(&self, _: &mut WavFileReader, session: &RecordingSession) -> Vec<AudioTime> {
+        // Only take as many as there are (valid!) songs in the session.
+        // TODO: maybe do the song filtering before all of this, so we can
+        // avoid this uglyness
+        self.0
+            .iter()
+            .take(session.songs.len() + 1)
+            .cloned()
+            .collect()
     }
 }

src/audio/cutting_strategy.rs

@@ -6,6 +6,7 @@ mod playback;
 mod sample_reader;
 mod time;
 
+pub use cut::CutInfo;
 pub use cutter::Cutter;
 pub use cutting_strategy::*;
 pub use sample_reader::get_volume_at;

src/audio/mod.rs

@@ -2,7 +2,6 @@ mod plot;
 mod session_gui;
 mod session_selector;
 
-use crate::audio::{AudioTime, Cutter};
 use crate::config::Config;
 use crate::recording_session::SessionPath;
 use anyhow::Result;

src/gui/mod.rs

@@ -7,7 +7,7 @@ use iced::{
 };
 
 use crate::{
-    audio::{get_volume_at, interpolate, interpolation_factor, AudioTime, WavFileReader},
+    audio::{get_volume_at, interpolate, interpolation_factor, AudioTime, CutInfo, WavFileReader},
     song::Song,
 };
 
@@ -21,11 +21,13 @@ const MARKER_COLOR: Color = Palette::GRUVBOX_DARK.primary;
 
 pub struct Plot {
     data: Vec<Point>,
-    _song_before: Option<Song>,
-    _song_after: Option<Song>,
+    song_before: Option<Song>,
+    song_after: Option<Song>,
     start: AudioTime,
     end: AudioTime,
     cut_time: AudioTime,
+    finished_cut_before: bool,
+    finished_cut_after: bool,
 }
 
 impl Plot {
@@ -48,11 +50,13 @@ impl Plot {
             .collect();
         Self {
             data,
-            _song_before: song_before,
-            _song_after: song_after,
+            song_before,
+            song_after,
             start,
             end,
             cut_time,
+            finished_cut_before: false,
+            finished_cut_after: false,
         }
     }
 
@@ -64,16 +68,34 @@ impl Plot {
         WIDTH * interpolation_factor(self.start, self.end, time) as f32
     }
 
-    pub fn get_plot_path(&self) -> Path {
+    pub fn get_plot_path(&self, data: &[Point]) -> Path {
         let mut path = Builder::new();
 
-        path.move_to(self.data[0]);
-        for point in self.data.iter() {
-            path.line_to(*point);
+        if data.len() > 0 {
+            path.move_to(data[0]);
+            for point in data.iter() {
+                path.line_to(*point);
+            }
         }
         path.build()
     }
 
+    /// Return the path left of the marker and the path right
+    /// of the marker, so they can be colored individually.
+    pub fn get_plot_paths(&self) -> (Path, Path) {
+        let cutoff = self
+            .data
+            .iter()
+            .enumerate()
+            .find(|(_, p)| self.pos_to_time(**p) > self.cut_time)
+            .map(|(i, _)| i)
+            .unwrap_or(self.data.len() - 1);
+        (
+            self.get_plot_path(&self.data[..=cutoff]),
+            self.get_plot_path(&self.data[cutoff..]),
+        )
+    }
+
     pub fn get_marker_path(&self) -> Path {
         let mut path = Builder::new();
         let x = self.time_to_pos(self.cut_time);
@@ -84,6 +106,17 @@ impl Plot {
 
     pub fn set_cut_position(&mut self, time: AudioTime) {
         self.cut_time = time;
+        self.finished_cut_before = false;
+        self.finished_cut_after = false;
+    }
+
+    pub fn update_on_finished_cut(&mut self, cut_song: &CutInfo) {
+        if self.song_before.as_ref() == Some(&cut_song.cut.song) {
+            self.finished_cut_before = true;
+        }
+        if self.song_after.as_ref() == Some(&cut_song.cut.song) {
+            self.finished_cut_after = true;
+        }
     }
 }
 
@@ -126,12 +159,25 @@ impl Program<PlotMarkerMoved> for Plot {
     ) -> Vec<Geometry> {
         let mut frame = Frame::new(renderer, bounds.size());
 
-        let plot = self.get_plot_path();
+        let (plot_before, plot_after) = self.get_plot_paths();
+        let color = |finished_cutting| {
+            if finished_cutting {
+                Color::from_rgb(0.0, 0.8, 0.0)
+            } else {
+                PLOT_COLOR
+            }
+        };
+        frame.stroke(
+            &plot_before,
+            Stroke::default()
+                .with_width(PLOT_STROKE_WIDTH)
+                .with_color(color(self.finished_cut_before)),
+        );
         frame.stroke(
-            &plot,
+            &plot_after,
             Stroke::default()
                 .with_width(PLOT_STROKE_WIDTH)
-                .with_color(PLOT_COLOR),
+                .with_color(color(self.finished_cut_after)),
         );
         let marker = self.get_marker_path();
         frame.stroke(

src/gui/plot.rs

@@ -1,13 +1,14 @@
 use crate::audio::{
-    AudioTime, Cutter, CuttingStrategy, DbusLengthsStrategy, Manual, WavFileReader,
+    AudioTime, CutInfo, Cutter, CuttingStrategy, DbusLengthsStrategy, Manual, WavFileReader,
 };
 use crate::recording_session::{RecordingSession, RecordingSessionWithPath, SessionPath};
 use anyhow::Result;
+use iced::command::channel;
 use iced::widget::{row, Canvas, Column};
 use iced::{Command, Element};
+use log::debug;
 
 use super::plot::{Plot, PlotMarkerMoved};
-use super::Message;
 
 const CANVAS_WIDTH: f32 = 800.0;
 const CANVAS_HEIGHT: f32 = 80.0;
@@ -16,7 +17,7 @@ const CANVAS_HEIGHT: f32 = 80.0;
 pub enum SessionMessage {
     SetCutPosition(SetCutPosition),
     CutSongs,
-    FinishedCutting,
+    FinishedCutting(CutInfo),
 }
 
 #[derive(Clone, Debug)]
@@ -82,7 +83,12 @@ impl SessionGui {
             SessionMessage::CutSongs => {
                 return self.cut_current_session();
             }
-            _ => panic!("we did it"),
+            SessionMessage::FinishedCutting(cut) => {
+                for plot in self.plots.iter_mut() {
+                    plot.update_on_finished_cut(&cut);
+                }
+                debug!("Finished {}", cut.cut.song);
+            }
         }
         Command::none()
     }
@@ -117,6 +123,7 @@ impl SessionGui {
     pub fn cut_current_session(&self) -> Command<SessionMessage> {
         let path = self.path.0.clone();
         let cuts = self.cuts.clone();
-        Command::perform(Cutter::run(path, cuts), |_| SessionMessage::FinishedCutting)
+        channel(5, move |sender| Cutter::run(path, cuts, sender))
+            .map(|m| SessionMessage::FinishedCutting(m))
     }
 }

src/gui/session_gui.rs

@@ -10,8 +10,6 @@ mod song;
 use std::path::Path;
 
 use anyhow::Result;
-use audio::Cutter;
-use audio::SilenceOptimizer;
 use config::Command;
 use config::Config;
 use log::info;