lasprs 0.14.1

Library for Acoustic Signal Processing (Rust edition, with optional Python bindings via pyo3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

//! Data types (sample formats) that can come from a DAQ device, or have to be sent as output to a
//! DAQ device.
use std::fmt::Display;

use crate::config::*;
use serde::{Deserialize, Serialize};
use strum::EnumMessage;
use strum_macros::{EnumMessage, FromRepr};

/// Data type description for samples coming from a stream
#[derive(EnumMessage, FromRepr, PartialEq, Copy, Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python-bindings",
    gen_stub_pyclass_enum,
    pyclass(eq, eq_int, from_py_object)
)]
#[repr(u32)]
pub enum DataType {
    /// 32-bit floats
    #[strum(message = "F32", detailed_message = "32-bit floating point")]
    F32 = 0,
    /// 64-bit floats
    #[strum(message = "F64", detailed_message = "64-bit floating point")]
    F64 = 1,
    /// 8-bit integers
    #[strum(message = "I8", detailed_message = "8-bit integer")]
    I8 = 2,
    /// 16-bit integers
    #[strum(message = "I16", detailed_message = "16-bit integer")]
    I16 = 3,
    /// 24-bit integers (stored in 32 bits, in the range of -2^23 to 2^23 - 1)
    #[strum(message = "I24", detailed_message = "24-bit integer")]
    I24 = 4,
    /// 32-bit integers
    #[strum(message = "I32", detailed_message = "32-bit integer")]
    I32 = 5,
}
impl Display for DataType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.get_detailed_message().unwrap())
    }
}

#[cfg_attr(feature = "python-bindings", gen_stub_pymethods, pymethods)]
impl DataType {
    fn __str__(&self) -> String {
        self.get_detailed_message()
            .expect("Should have detailed message")
            .into()
    }
    /// Returns the number of bytes per sample for this data type as stored in
    /// memory. So I24 is stored in 32 bits, so 4.
    pub fn bytes_per_sample_in_memory(&self) -> usize {
        match self {
            DataType::F32 => 4,
            DataType::F64 => 8,
            DataType::I8 => 1,
            DataType::I16 => 2,
            DataType::I24 => 4,
            DataType::I32 => 4,
        }
    }
}