xmrs 0.12.2

A library to edit SoundTracker data with pleasure
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Automation lanes: parameter curves through time.
//!
//! Each lane targets one DAW parameter (global volume, BPM, etc.)
//! and stores a list of `(tick, value)` points sorted by tick. The
//! value is typed via [`AutomationValue`] so that integer-domain
//! targets (BPM, Speed) can't be conflated with normalised targets
//! (volume, panning).

use crate::fixed::fixed::Q15;
use alloc::vec::Vec;
use serde::{Deserialize, Serialize};

/// What an [`AutomationLane`] controls.
#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum AutomationTarget {
    GlobalVolume,
    Bpm,
    Speed,
    ChannelVolume(u8),
    ChannelPanning(u8),
    TrackVolume(u32),
    TrackPanning(u32),
}

/// Typed value of an [`AutomationPoint`], matched against the
/// lane's [`AutomationTarget`] at construction time.
#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
pub enum AutomationValue {
    /// For targets in `[0.0, 1.0]`: volumes, panning, etc.
    Normalized(Q15),
    /// For BPM (typical range 32..=255).
    Bpm(u16),
    /// For Speed (typical range 1..=31).
    Speed(u8),
}

impl AutomationValue {
    /// `true` when the value's variant matches `target`.
    pub fn is_compatible_with(&self, target: AutomationTarget) -> bool {
        matches!(
            (self, target),
            (
                AutomationValue::Normalized(_),
                AutomationTarget::GlobalVolume
            ) | (
                AutomationValue::Normalized(_),
                AutomationTarget::ChannelVolume(_)
            ) | (
                AutomationValue::Normalized(_),
                AutomationTarget::ChannelPanning(_)
            ) | (
                AutomationValue::Normalized(_),
                AutomationTarget::TrackVolume(_)
            ) | (
                AutomationValue::Normalized(_),
                AutomationTarget::TrackPanning(_)
            ) | (AutomationValue::Bpm(_), AutomationTarget::Bpm)
                | (AutomationValue::Speed(_), AutomationTarget::Speed)
        )
    }
}

#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
pub struct AutomationPoint {
    pub tick: u32,
    pub value: AutomationValue,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AutomationLane {
    pub target: AutomationTarget,
    /// Sorted by tick (ascending). The API maintains this invariant.
    pub points: Vec<AutomationPoint>,
    pub enabled: bool,
}

impl AutomationLane {
    /// Build an empty lane for `target`.
    pub fn new(target: AutomationTarget) -> Self {
        Self {
            target,
            points: Vec::new(),
            enabled: true,
        }
    }

    /// Insert a point, keeping `points` sorted by tick. If a point
    /// already exists at the same tick it is replaced.
    pub fn insert_point(&mut self, point: AutomationPoint) {
        match self.points.binary_search_by_key(&point.tick, |p| p.tick) {
            Ok(idx) => self.points[idx] = point,
            Err(idx) => self.points.insert(idx, point),
        }
    }
}