phoxal 0.10.0

Phoxal — production-oriented autonomous robot framework (engine, model, typed bus, contracts).
Documentation 
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use crate::bus::zenoh::BusyResponse;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Quality {
    Auto,
    P144,
    P240,
    P360,
    P480,
    P720,
    P1080,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct OpenRequest {
    /// Source camera as `component_id.capability_id` (`CapabilityRef` display form).
    pub source: String,
    pub quality: Quality,
}

impl OpenRequest {
    pub fn new(source: impl Into<String>, quality: Quality) -> Self {
        Self {
            source: source.into(),
            quality,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum OpenResponse {
    Ok {
        stream_id: String,
        format: StreamFormat,
    },
    UnknownSource,
    Unavailable(UnavailableReason),
    Busy,
}

impl BusyResponse for OpenResponse {
    fn busy() -> Self {
        Self::Busy
    }
}

#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum UnavailableReason {
    NoCamerasAvailable,
}

#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Codec {
    H264,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StreamFormat {
    pub codec: Codec,
    pub width_px: u32,
    pub height_px: u32,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum StreamEvent {
    Opened { format: StreamFormat },
    Packet(StreamPacket),
    Reconfigured { format: StreamFormat },
    End { reason: EndReason },
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StreamPacket {
    pub sequence: u64,
    pub captured_at_ns: u64,
    #[serde(with = "serde_bytes")]
    pub bytes: Vec<u8>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum EndReason {
    SourceUnavailable,
    IdleTimeout,
    RuntimeStopping,
    RejectedByPolicy,
    Released,
}

pub mod open {
    pub use crate::api::video::v1::{OpenRequest as Request, OpenResponse as Response, Quality};
}

pub mod stream {
    pub use crate::api::video::v1::{
        Codec, EndReason, StreamEvent as Event, StreamFormat as Format, StreamPacket as Packet,
    };
}

#[cfg(test)]
mod tests {
    use crate::bus::zenoh::BusyResponse;

    use super::OpenResponse;

    #[test]
    fn open_response_busy_uses_busy_variant() {
        assert_eq!(OpenResponse::busy(), OpenResponse::Busy);
    }
}