Skip to main content

qualia_audio/
session_history.rs

1//! DAW session operation history (cold path — not in audio callback).
2
3use crate::production::{ProcessPlan, TrackState, MAX_TRACKS};
4
5pub const MAX_HISTORY: usize = 64;
6
7#[repr(u8)]
8#[derive(Debug, Clone, Copy, PartialEq, Eq)]
9pub enum OpKind {
10    SetGain = 1,
11    SetPan = 2,
12    SetMute = 3,
13    SetSolo = 4,
14    SetLowpass = 5,
15    AddTrack = 6,
16}
17
18#[derive(Debug, Clone, Copy)]
19pub struct SessionOp {
20    pub kind: OpKind,
21    pub track: u8,
22    pub value_f32: f32,
23    pub value_bool: bool,
24    /// Prior value for undo.
25    pub prev_f32: f32,
26    pub prev_bool: bool,
27}
28
29/// Ring of ops + cursor for undo/redo.
30#[derive(Debug, Clone)]
31pub struct SessionHistory {
32    ops: [Option<SessionOp>; MAX_HISTORY],
33    /// Next write index.
34    len: usize,
35    /// Undo cursor (ops applied are [0..cursor)).
36    cursor: usize,
37}
38
39impl Default for SessionHistory {
40    fn default() -> Self {
41        Self::new()
42    }
43}
44
45impl SessionHistory {
46    /// Creates a new instance.
47    pub fn new() -> Self {
48        Self {
49            ops: [None; MAX_HISTORY],
50            len: 0,
51            cursor: 0,
52        }
53    }
54
55    /// Pushes an item.
56    pub fn push(&mut self, op: SessionOp) {
57        if self.cursor < self.len {
58            // drop redo tail
59            self.len = self.cursor;
60        }
61        if self.len >= MAX_HISTORY {
62            // drop oldest
63            for i in 0..MAX_HISTORY - 1 {
64                self.ops[i] = self.ops[i + 1];
65            }
66            self.len = MAX_HISTORY - 1;
67            self.cursor = self.len;
68        }
69        self.ops[self.len] = Some(op);
70        self.len += 1;
71        self.cursor = self.len;
72    }
73
74    /// `true` when able to undo.
75    pub fn can_undo(&self) -> bool {
76        self.cursor > 0
77    }
78
79    /// `true` when able to redo.
80    pub fn can_redo(&self) -> bool {
81        self.cursor < self.len
82    }
83
84    /// Undoes.
85    pub fn undo(&mut self, plan: &mut ProcessPlan) -> bool {
86        if self.cursor == 0 {
87            return false;
88        }
89        self.cursor -= 1;
90        if let Some(op) = self.ops[self.cursor] {
91            apply_inverse(plan, op);
92        }
93        true
94    }
95
96    /// Redoes.
97    pub fn redo(&mut self, plan: &mut ProcessPlan) -> bool {
98        if self.cursor >= self.len {
99            return false;
100        }
101        if let Some(op) = self.ops[self.cursor] {
102            apply_forward(plan, op);
103        }
104        self.cursor += 1;
105        true
106    }
107
108    /// Applies and-record.
109    pub fn apply_and_record(&mut self, plan: &mut ProcessPlan, op: SessionOp) {
110        apply_forward(plan, op);
111        self.push(op);
112    }
113}
114
115fn apply_forward(plan: &mut ProcessPlan, op: SessionOp) {
116    let t = op.track as usize;
117    if t >= MAX_TRACKS {
118        return;
119    }
120    match op.kind {
121        OpKind::SetGain => {
122            if t < plan.n_tracks {
123                plan.tracks[t].gain = op.value_f32;
124            }
125        }
126        OpKind::SetPan => {
127            if t < plan.n_tracks {
128                plan.tracks[t].pan = op.value_f32;
129            }
130        }
131        OpKind::SetMute => {
132            if t < plan.n_tracks {
133                plan.tracks[t].mute = op.value_bool;
134            }
135        }
136        OpKind::SetSolo => {
137            if t < plan.n_tracks {
138                plan.tracks[t].solo = op.value_bool;
139            }
140        }
141        OpKind::SetLowpass => {
142            if t < plan.n_tracks {
143                plan.tracks[t].lowpass = op.value_f32;
144            }
145        }
146        OpKind::AddTrack => {
147            let _ = plan.add_track(TrackState {
148                gain: op.value_f32,
149                ..TrackState::default()
150            });
151        }
152    }
153}
154
155fn apply_inverse(plan: &mut ProcessPlan, op: SessionOp) {
156    let t = op.track as usize;
157    match op.kind {
158        OpKind::SetGain => {
159            if t < plan.n_tracks {
160                plan.tracks[t].gain = op.prev_f32;
161            }
162        }
163        OpKind::SetPan => {
164            if t < plan.n_tracks {
165                plan.tracks[t].pan = op.prev_f32;
166            }
167        }
168        OpKind::SetMute => {
169            if t < plan.n_tracks {
170                plan.tracks[t].mute = op.prev_bool;
171            }
172        }
173        OpKind::SetSolo => {
174            if t < plan.n_tracks {
175                plan.tracks[t].solo = op.prev_bool;
176            }
177        }
178        OpKind::SetLowpass => {
179            if t < plan.n_tracks {
180                plan.tracks[t].lowpass = op.prev_f32;
181            }
182        }
183        OpKind::AddTrack => {
184            if plan.n_tracks > 0 {
185                plan.n_tracks -= 1;
186            }
187        }
188    }
189}
190
191/// Sample-accurate automation point (cold compile into per-block gains).
192#[derive(Debug, Clone, Copy)]
193pub struct AutomationPoint {
194    pub frame: u64,
195    pub value: f32,
196}
197
198pub const MAX_AUTO_POINTS: usize = 32;
199
200#[derive(Debug, Clone)]
201pub struct AutomationLane {
202    pub track: u8,
203    pub points: [AutomationPoint; MAX_AUTO_POINTS],
204    pub n_points: usize,
205}
206
207impl AutomationLane {
208    /// Creates a new instance.
209    pub fn new(track: u8) -> Self {
210        Self {
211            track,
212            points: [AutomationPoint {
213                frame: 0,
214                value: 1.0,
215            }; MAX_AUTO_POINTS],
216            n_points: 0,
217        }
218    }
219
220    /// Adds.
221    pub fn add(&mut self, frame: u64, value: f32) -> bool {
222        if self.n_points >= MAX_AUTO_POINTS {
223            return false;
224        }
225        self.points[self.n_points] = AutomationPoint { frame, value };
226        self.n_points += 1;
227        // keep sorted by frame
228        let n = self.n_points;
229        self.points[..n].sort_by_key(|p| p.frame);
230        true
231    }
232
233    /// Linear interpolate gain at `frame`.
234    pub fn value_at(&self, frame: u64) -> f32 {
235        if self.n_points == 0 {
236            return 1.0;
237        }
238        if frame <= self.points[0].frame {
239            return self.points[0].value;
240        }
241        for i in 1..self.n_points {
242            if frame <= self.points[i].frame {
243                let a = self.points[i - 1];
244                let b = self.points[i];
245                let span = (b.frame - a.frame).max(1) as f32;
246                let t = (frame - a.frame) as f32 / span;
247                return a.value + (b.value - a.value) * t;
248            }
249        }
250        self.points[self.n_points - 1].value
251    }
252}
253
254#[cfg(test)]
255mod tests {
256    use super::*;
257
258    #[test]
259    fn undo_redo_gain() {
260        let mut plan = ProcessPlan::new(48000, 64);
261        plan.add_track(TrackState::default());
262        let mut h = SessionHistory::new();
263        let op = SessionOp {
264            kind: OpKind::SetGain,
265            track: 0,
266            value_f32: 0.5,
267            value_bool: false,
268            prev_f32: 1.0,
269            prev_bool: false,
270        };
271        h.apply_and_record(&mut plan, op);
272        assert!((plan.tracks[0].gain - 0.5).abs() < 1e-6);
273        assert!(h.undo(&mut plan));
274        assert!((plan.tracks[0].gain - 1.0).abs() < 1e-6);
275        assert!(h.redo(&mut plan));
276        assert!((plan.tracks[0].gain - 0.5).abs() < 1e-6);
277    }
278
279    #[test]
280    fn automation_interp() {
281        let mut lane = AutomationLane::new(0);
282        lane.add(0, 0.0);
283        lane.add(100, 1.0);
284        assert!((lane.value_at(50) - 0.5).abs() < 1e-5);
285    }
286}