Struct SampleSettingsFile

pub struct SampleSettingsFile {

    pub header: [u8; 21],
    pub datatype_version: u8,
    pub unknown: u8,
    pub tempo: u32,
    pub trim_len: u32,
    pub loop_len: u32,
    pub stretch: u32,
    pub loop_mode: u32,
    pub gain: u16,
    pub quantization: u8,
    pub trim_start: u32,
    pub trim_end: u32,
    pub loop_start: u32,
    pub slices: [Slice; 64],
    pub slices_len: u32,
    pub checksum: u16,
}

Struct to create a valid Octatrack .ot file a.k.a a sample settings file. General metadata for the sample’s configuration on the OT and the slice array with pointer positions for the sliced WAV.

NOTE: On the naming for this – the Octatrack manual specifically refers to

SAVE SAMPLE SETTINGS will save the trim, slice and attribute settings in a separate file and link it to the sample currently being edited. – page 87.

So … this is the SETTINGS file.

Fields

header: [u8; 21]

Header

datatype_version: u8

Datatype’s version ID//

unknown: u8

Unknown data

tempo: u32

Tempo is always the machine UI’s BPM multiplied by 24

trim_len: u32

Number of bars for the sample trim length marker. By default, trim length should be equal to trim end, and probably loop length too for drum hit sample chains.

loop_len: u32

Number of bars for the sample loop length marker. By default, loop length should be equal to trim length for sample chains.

stretch: u32

Default timestrech algorithm applied to the sample. See the ot_sample::options::SampleTimestrechModes enum for suitable choices.

loop_mode: u32

Default loop mode applied to the sample. See the ot_sample::options::SampleLoopModes enum for suitable choices.

gain: u16

Gain of the sample. -24.0 db <= x <= +24 db range in the machine’s UI, with increments of 0.5 db changes. 0 <= x <= 96 range in binary data file.

quantization: u8

Default trig quantization mode applied to the sample. See the ot_sample::options::SampleTrigQuantizationModes enum for suitable choices.

trim_start: u32

Where the trim start marker is placed for the sample, measured in bars. Default is 0 (start of sample). TODO: measured in bars? or samples?

trim_end: u32

Where the trim end marker is placed for the sample. When the sample is being played in normal mode (i.e. not using slices), the Octatrack will not play samples past this point. By default, trim length should be equal to trim end, and probably loop length too for drum hit sample chains. TODO: measured in bars? or samples?

loop_start: u32

Start position for any loops. Default should be the same as trim start. Measured in bars. A note from the Octatrack manual on loop point/start behaviour:

If a loop point is set, the sample will play from the start point to the end point, then loop from the loop point to the end point

slices: [Slice; 64]

64 length array containing Slices. See the Slice struct for more details. Any empty slice positions should have zero-valued struct fields.

slices_len: u32

Number of usuable Slices in this sample. Used by the Octatrack to ignore zero-valued Slices in the slices array when loading the sample.

checksum: u16

Checksum value for the struct. This must be calculated after the struct is created on little-endian systems (requires byte swapping all struct fields to get the correct checksum value).

Implementations

impl SampleSettingsFile

pub fn new( tempo: &u32, stretch: &TimestrechMode, quantization: &TrigQuantizationMode, gain: &u16, trim_config: &TrimConfig, loop_config: &LoopConfig, slices: &Slices, ) -> Result<Self, Box<dyn Error>>

Create a new SampleSettingsFile

Values like tempo and gain need to be normalised to relevant OT bounds before using this method.

let x = SampleSettingsFile::new(
    &2880,
    // ...
    &48,
    // ...
).unwrap();
assert_eq!(x.tempo, 2880);
assert_eq!(x.gain, 48);

Trait Implementations

impl CalculateChecksum for SampleSettingsFile

fn calculate_checksum(&self) -> Result<u16, Box<dyn Error>>

impl CheckChecksum for SampleSettingsFile

fn check_checksum(&self) -> Result<bool, Box<dyn Error>>

impl CheckFileVersion for SampleSettingsFile

fn check_file_version(&self) -> Result<bool, Box<dyn Error>>

impl CheckHeader for SampleSettingsFile

fn check_header(&self) -> bool

impl CheckIntegrity for SampleSettingsFile

fn check_integrity(&self) -> Result<bool, Box<dyn Error>>

impl Clone for SampleSettingsFile

fn clone(&self) -> SampleSettingsFile

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SampleSettingsFile

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

Formats the value using the given formatter.

impl Decode for SampleSettingsFile

fn decode(bytes: &[u8]) -> Result<Self, Box<dyn Error>>

Decode raw bytes of a .ot data file into a new struct, swap byte values if system is little-endian then do some minor post-processing to get user-friendly settings values.

impl<'de> Deserialize<'de> for SampleSettingsFile

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for SampleSettingsFile

fn encode(&self) -> Result<Vec<u8>, Box<dyn Error>>

Encodes struct data to binary representation, after some pre-processing.

Before serializing, will:

1. modify tempo and gain values to machine ranges
2. swaps bytes of values (when current system is little-endian)
3. generate checksum value

impl Hash for SampleSettingsFile

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl OctatrackFileIO for SampleSettingsFile

fn repr(&self, newlines: Option<bool>) -> Result<(), Box<dyn Error>>

where Self: Debug,

Read type from an Octatrack data file at path

fn from_data_file(path: &Path) -> Result<Self, Box<dyn Error>>

Read type from an Octatrack data file at path

fn from_bytes(bytes: &[u8]) -> Result<Self, Box<dyn Error>>

Read type from bytes

fn to_data_file(&self, path: &Path) -> Result<(), Box<dyn Error>>

Write type to an Octatrack data file at path

fn to_bytes(&self) -> Result<Vec<u8>, Box<dyn Error>>

Create bytes from type

fn from_yaml_file(path: &Path) -> Result<Self, Box<dyn Error>>

Read type from a YAML file at path

fn from_yaml_str(yaml: &str) -> Result<Self, Box<dyn Error>>

Read type from YAML string

fn to_yaml_file(&self, path: &Path) -> Result<(), Box<dyn Error>>

Write type to a YAML file at path

fn to_yaml_string(&self) -> Result<String, Box<dyn Error>>

Create YAML string from type

fn from_json_file(path: &Path) -> Result<Self, Box<dyn Error>>

Read type from a JSON file at path

fn from_json_str(json: &str) -> Result<Self, Box<dyn Error>>

Create type from JSON string

fn to_json_file(&self, path: &Path) -> Result<(), Box<dyn Error>>

Write type to a JSON file at path

fn to_json_string(&self) -> Result<String, Box<dyn Error>>

Create JSON string from type

impl PartialEq for SampleSettingsFile

fn eq(&self, other: &SampleSettingsFile) -> 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 SampleSettingsFile

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SwapBytes for SampleSettingsFile

fn swap_bytes(self) -> Result<Self, Box<dyn Error>>

impl StructuralPartialEq for SampleSettingsFile