Enum InstrumentType 

pub enum InstrumentType {
    Synth,
    DrumRack,
    DX7,
    Jupiter8,
    Odyssey,
    Juno60,
    Rhodes,
    Sampler,
    LittlePhatty,
}

Variants

Synth

DrumRack

DX7

Jupiter8

Odyssey

Juno60

Rhodes

Sampler

LittlePhatty

Implementations

impl InstrumentType

pub const ALL: &[InstrumentType]

Appended to, never reordered: a session stores an instrument by its key rather than by position, but the menu’s own order is what a player has learned, and the preset browser walks this list.

pub fn label(self) -> &'static str

Examples found in repository

examples/session_digest.rs (line 22)

fn main() {
    println!("== instrument layouts ==");
    for instrument in InstrumentType::ALL {
        let key = session::instrument_key(*instrument);
        println!(
            "{key:<10} params={:<3} layout={} label={:?}",
            param_count(*instrument),
            layout_fingerprint(*instrument),
            instrument.label()
        );
        // Every selector on the panel, and how many positions it has, because
        // that is what a stored position is an index into.
        let count = param_count(*instrument);
        let mut selectors = Vec::new();
        for param in 0..count {
            if let Some(positions) = phosphor_app::discrete::positions(*instrument, param) {
                selectors.push(format!("{param}:{}", positions.len()));
            }
        }
        println!("           selectors {}", selectors.join(" "));
    }

    for path in std::env::args().skip(1) {
        println!("\n== {path} ==");
        let file = match session::load(std::path::Path::new(&path)) {
            Ok(f) => f,
            Err(e) => {
                println!("  unreadable: {e}");
                continue;
            }
        };
        println!("  version {} tracks {}", file.version, file.tracks.len());
        for track in &file.tracks {
            let Some(instrument) = session::parse_instrument_type(&track.instrument_type) else {
                println!("  {:<12} UNKNOWN {}", track.name, track.instrument_type);
                continue;
            };
            let mut params = track.synth_params.clone();
            let clamped = session::apply_selectors(instrument, &mut params, &track.discrete);
            let digest: u64 = params.iter().fold(0xcbf2_9ce4_8422_2325u64, |h, v| {
                v.to_bits().to_le_bytes().iter().fold(h, |h, b| {
                    (h ^ u64::from(*b)).wrapping_mul(0x0000_0100_0000_01b3)
                })
            });
            println!(
                "  {:<12} {:<10} n={:<3} digest={digest:016x} clamped={clamped:?}",
                track.name, track.instrument_type, params.len()
            );
        }
    }
}

pub fn description(self) -> &'static str

Trait Implementations

impl Clone for InstrumentType

fn clone(&self) -> InstrumentType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for InstrumentType

impl Debug for InstrumentType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for InstrumentType

impl PartialEq for InstrumentType

fn eq(&self, other: &InstrumentType) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for InstrumentType