qualia_audio/
session_history.rs1use 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 pub prev_f32: f32,
26 pub prev_bool: bool,
27}
28
29#[derive(Debug, Clone)]
31pub struct SessionHistory {
32 ops: [Option<SessionOp>; MAX_HISTORY],
33 len: usize,
35 cursor: usize,
37}
38
39impl Default for SessionHistory {
40 fn default() -> Self {
41 Self::new()
42 }
43}
44
45impl SessionHistory {
46 pub fn new() -> Self {
48 Self {
49 ops: [None; MAX_HISTORY],
50 len: 0,
51 cursor: 0,
52 }
53 }
54
55 pub fn push(&mut self, op: SessionOp) {
57 if self.cursor < self.len {
58 self.len = self.cursor;
60 }
61 if self.len >= MAX_HISTORY {
62 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 pub fn can_undo(&self) -> bool {
76 self.cursor > 0
77 }
78
79 pub fn can_redo(&self) -> bool {
81 self.cursor < self.len
82 }
83
84 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 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 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#[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 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 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 let n = self.n_points;
229 self.points[..n].sort_by_key(|p| p.frame);
230 true
231 }
232
233 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}