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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

/*
 * SPDX-License-Identifier: MIT
 */
use std::io::{Seek, Write};

use pipewire_wrapper_proc_macro::object_type_impl;

use crate::enum_wrapper;
use crate::spa::pod::id::PodIdRef;
use crate::spa::pod::object::param_port_config::Direction;
use crate::spa::pod::object::{PodPropKeyType, PodPropRef};
use crate::spa::pod::{BasicTypePod, PodError, PodFloatRef, PodIntRef, PodLongRef, PodResult};
use crate::wrapper::RawWrapper;

#[repr(u32)]
#[derive(Debug)]
#[allow(non_camel_case_types)]
#[object_type_impl(OBJECT_PARAM_LATENCY)]
pub enum ParamLatencyType<'a> {
    DIRECTION(&'a PodIdRef<Direction>) = ParamLatency::DIRECTION.raw,
    MIN_QUANTUM(&'a PodFloatRef) = ParamLatency::MIN_QUANTUM.raw,
    MAX_QUANTUM(&'a PodFloatRef) = ParamLatency::MAX_QUANTUM.raw,
    MIN_RATE(&'a PodIntRef) = ParamLatency::MIN_RATE.raw,
    MAX_RATE(&'a PodIntRef) = ParamLatency::MAX_RATE.raw,
    MIN_NS(&'a PodLongRef) = ParamLatency::MIN_NS.raw,
    MAX_NS(&'a PodLongRef) = ParamLatency::MAX_NS.raw,
}

impl<'a> TryFrom<&'a PodPropRef<'a, ParamLatencyType<'a>>> for ParamLatencyType<'a> {
    type Error = PodError;

    fn try_from(value: &'a PodPropRef<'a, ParamLatencyType<'a>>) -> Result<Self, Self::Error> {
        unsafe {
            match ParamLatency::from_raw(value.raw.key) {
                ParamLatency::DIRECTION => Ok(ParamLatencyType::DIRECTION(value.pod().cast()?)),
                ParamLatency::MIN_QUANTUM => Ok(ParamLatencyType::MIN_QUANTUM(value.pod().cast()?)),
                ParamLatency::MAX_QUANTUM => Ok(ParamLatencyType::MAX_QUANTUM(value.pod().cast()?)),
                ParamLatency::MIN_RATE => Ok(ParamLatencyType::MIN_RATE(value.pod().cast()?)),
                ParamLatency::MAX_RATE => Ok(ParamLatencyType::MAX_RATE(value.pod().cast()?)),
                ParamLatency::MIN_NS => Ok(ParamLatencyType::MIN_NS(value.pod().cast()?)),
                ParamLatency::MAX_NS => Ok(ParamLatencyType::MAX_NS(value.pod().cast()?)),
                _ => Err(PodError::UnknownPodTypeToDowncast),
            }
        }
    }
}

impl<'a> PodPropKeyType<'a> for ParamLatencyType<'a> {
    fn write_prop<W>(&self, buffer: &mut W) -> PodResult<()>
    where
        W: Write + Seek,
    {
        match self {
            ParamLatencyType::DIRECTION(pod) => {
                Self::write_pod_prop(buffer, ParamLatency::DIRECTION.raw, 0, pod)
            }
            ParamLatencyType::MIN_QUANTUM(pod) => {
                Self::write_pod_prop(buffer, ParamLatency::MIN_QUANTUM.raw, 0, pod)
            }
            ParamLatencyType::MAX_QUANTUM(pod) => {
                Self::write_pod_prop(buffer, ParamLatency::MAX_QUANTUM.raw, 0, pod)
            }
            ParamLatencyType::MIN_RATE(pod) => {
                Self::write_pod_prop(buffer, ParamLatency::MIN_RATE.raw, 0, pod)
            }
            ParamLatencyType::MAX_RATE(pod) => {
                Self::write_pod_prop(buffer, ParamLatency::MAX_RATE.raw, 0, pod)
            }
            ParamLatencyType::MIN_NS(pod) => {
                Self::write_pod_prop(buffer, ParamLatency::MIN_NS.raw, 0, pod)
            }
            ParamLatencyType::MAX_NS(pod) => {
                Self::write_pod_prop(buffer, ParamLatency::MAX_NS.raw, 0, pod)
            }
        }
    }
}

enum_wrapper!(
    ParamLatency,
    spa_sys::spa_param_latency,
    _START: spa_sys::SPA_PARAM_LATENCY_START,
    DIRECTION: spa_sys::SPA_PARAM_LATENCY_direction,
    MIN_QUANTUM: spa_sys::SPA_PARAM_LATENCY_minQuantum,
    MAX_QUANTUM: spa_sys::SPA_PARAM_LATENCY_maxQuantum,
    MIN_RATE: spa_sys::SPA_PARAM_LATENCY_minRate,
    MAX_RATE: spa_sys::SPA_PARAM_LATENCY_maxRate,
    MIN_NS: spa_sys::SPA_PARAM_LATENCY_minNs,
    MAX_NS: spa_sys::SPA_PARAM_LATENCY_maxNs,
);