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 – can sometimes be 1, usually 0.

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 time-stretch algorithm applied to the sample. See the TimeStretchMode enum for suitable choices.

loop_mode: u32

Default loop mode applied to the sample. See the LoopMode 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 TrigQuantizationMode 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).

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.

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 usable 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: &TimeStretchMode, quantization: &TrigQuantizationMode, gain: &u16, trim_config: &TrimConfig, loop_config: &LoopConfig, slices: &Slices, ) -> Result<Self, SampleSettingsError>

Create a new SampleSettingsFile

Values like tempo and gain need to be normalized 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 CheckFileIntegrity for SampleSettingsFile

fn check_integrity(&self) -> Result<bool, OtToolsIoError>

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<'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 From<&SampleSettingsFile> for LoopConfig

fn from(decoded: &SampleSettingsFile) -> Self

Converts to this type from the input type.

impl From<&SampleSettingsFile> for TrimConfig

fn from(decoded: &SampleSettingsFile) -> Self

Converts to this type from the input type.

impl From<(&SlotAttributes, &SlotMarkers)> for SampleSettingsFile

fn from(value: (&SlotAttributes, &SlotMarkers)) -> Self

Converts to this type from the input type.

impl From<(SlotAttributes, SlotMarkers)> for SampleSettingsFile

fn from(value: (SlotAttributes, SlotMarkers)) -> Self

Converts to this type from the input type.

impl From<SampleSettingsFile> for LoopConfig

fn from(decoded: SampleSettingsFile) -> Self

Converts to this type from the input type.

impl From<SampleSettingsFile> for TrimConfig

fn from(decoded: SampleSettingsFile) -> Self

Converts to this type from the input type.

impl HasChecksumField for SampleSettingsFile

fn calculate_checksum(&self) -> Result<u16, OtToolsIoError>

Method for calculating the checksum value for types that have a checksum field

fn check_checksum(&self) -> Result<bool, OtToolsIoError>

Method to verify if checksum is valid in some data type. See this thread.

impl HasFileVersionField for SampleSettingsFile

fn check_file_version(&self) -> Result<bool, OtToolsIoError>

Method to verify if the data file version field is valid for the given type.

impl HasHeaderField for SampleSettingsFile

fn check_header(&self) -> Result<bool, OtToolsIoError>

Method to verify if header(s) are valid in some data. See this thread.

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 encode(&self) -> Result<Vec<u8>, OtToolsIoError>

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

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

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.

fn repr(&self, newlines: Option<bool>)

where Self: Debug,

Read type from an Octatrack data file at path

fn from_data_file(path: &Path) -> Result<Self, OtToolsIoError>

Read type from an Octatrack data file at path

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

Read type from bytes

fn to_data_file(&self, path: &Path) -> Result<(), OtToolsIoError>

Write type to an Octatrack data file at path

fn to_bytes(&self) -> Result<Vec<u8>, OtToolsIoError>

Create bytes from type

fn from_yaml_file(path: &Path) -> Result<Self, OtToolsIoError>

Read type from a YAML file at path

fn from_yaml_str(yaml: &str) -> Result<Self, OtToolsIoError>

Read type from YAML string

fn to_yaml_file(&self, path: &Path) -> Result<(), OtToolsIoError>

Write type to a YAML file at path

fn to_yaml_string(&self) -> Result<String, OtToolsIoError>

Create YAML string from type

fn from_json_file(path: &Path) -> Result<Self, OtToolsIoError>

Read type from a JSON file at path

fn from_json_str(json: &str) -> Result<Self, OtToolsIoError>

Create type from JSON string

fn to_json_file(&self, path: &Path) -> Result<(), OtToolsIoError>

Write type to a JSON file at path

fn to_json_string(&self) -> Result<String, OtToolsIoError>

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 StructuralPartialEq for SampleSettingsFile