Struct SampleAttributes

pub struct SampleAttributes {

    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. General metadata for the sample’s configuration on the OT and the slice array with pointer positions for the sliced WAV.

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 SampleAttributes

pub fn new( tempo: &f32, stretch: &SampleAttributeTimestrechMode, quantization: &SampleAttributeTrigQuantizationMode, gain: &f32, trim_config: &SampleTrimConfig, loop_config: &SampleLoopConfig, slices: &Slices, ) -> Result<Self, Box<dyn Error>>

Create a new SampleAttributesFile struct. ‘Human-readable’ f32 values for gain and tempo are converted to proper u8 values in this method.

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

Trait Implementations

impl CalculateChecksum for SampleAttributes

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

impl CheckChecksum for SampleAttributes

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

impl CheckHeader for SampleAttributes

fn check_header(&self) -> bool

impl CheckIntegrity for SampleAttributes

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

impl Clone for SampleAttributes

fn clone(&self) -> SampleAttributes

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SampleAttributes

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

Formats the value using the given formatter.

impl Decode for SampleAttributes

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 SampleAttributes

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for SampleAttributes

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 PartialEq for SampleAttributes

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

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 SampleAttributes

type T = SampleAttributes

Swaps the bytes on all struct fields. MUST BE CALLED BEFORE SERIALISATION WHEN SYSTEM IS LITTLE ENDIAN!

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

Swap the bytes of all struct fields. Must be applied to the SampleAttributes file to deal with litle-endian/big-endian systems.

impl StructuralPartialEq for SampleAttributes