Enum ClassicSystem 

pub enum ClassicSystem {
    Nes,
    Commodore64,
    SegaGenesis,
    RolandD50,
    AkaiS900,
    EmulatorII,
    FairlightCMI,
    LinnDrum,
    Custom {
        bit_depth: u8,
        sample_rate: f32,
        nonlinear: bool,
        noise_floor: f32,
    },
}

Classic digital audio systems that inform the lo-fi emulation parameters.

Variants

Nes

Nintendo Entertainment System (7-bit).

Commodore64

Commodore 64 (8-bit).

SegaGenesis

Sega Genesis / Mega Drive (9-bit).

RolandD50

Roland D-50 (16-bit, 32 kHz).

AkaiS900

Akai S900 (12-bit, 40 kHz, non-linear).

EmulatorII

E-mu Emulator II (8-bit, 27.7 kHz).

FairlightCMI

Fairlight CMI (8-bit, 16 kHz).

LinnDrum

LinnDrum (8-bit).

Custom

User-defined system with custom parameters.

Fields

bit_depth: u8

Bit depth (1–16).

sample_rate: f32

Sample rate in Hz.

nonlinear: bool

Whether the system uses non-linear encoding.

noise_floor: f32

Noise floor in dB.

Implementations

impl ClassicSystem

pub fn get_bit_depth(&self) -> u8

Returns the bit depth for this classic system.

pub fn get_sample_rate(&self) -> f32

Returns the sample rate in Hz for this classic system.

pub fn has_nonlinear_encoding(&self) -> bool

Returns true if this system uses non-linear encoding (e.g. Akai S900).

pub fn get_noise_floor_db(&self) -> f32

Returns the noise floor in dB for this classic system.

Trait Implementations

impl Clone for ClassicSystem

fn clone(&self) -> ClassicSystem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ClassicSystem

impl Debug for ClassicSystem

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ClassicSystem

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ClassicSystem

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ClassicSystem

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ClassicSystem