oximedia-graph 0.1.5

Filter pipeline for OxiMedia
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Error types for the filter graph.

use thiserror::Error;

use crate::node::NodeId;
use crate::port::PortId;

/// Result type for graph operations.
pub type GraphResult<T> = Result<T, GraphError>;

/// Errors that can occur in filter graph operations.
#[derive(Error, Debug)]
pub enum GraphError {
    /// Node not found in the graph.
    #[error("node not found: {0:?}")]
    NodeNotFound(NodeId),

    /// Port not found on node.
    #[error("port not found: node {node:?}, port {port:?}")]
    PortNotFound {
        /// The node ID.
        node: NodeId,
        /// The port ID.
        port: PortId,
    },

    /// Connection already exists.
    #[error(
        "connection already exists from {from_node:?}:{from_port:?} to {to_node:?}:{to_port:?}"
    )]
    ConnectionExists {
        /// Source node ID.
        from_node: NodeId,
        /// Source port ID.
        from_port: PortId,
        /// Destination node ID.
        to_node: NodeId,
        /// Destination port ID.
        to_port: PortId,
    },

    /// Incompatible port formats.
    #[error("incompatible formats: source {source_format}, destination {dest_format}")]
    IncompatibleFormats {
        /// Source format description.
        source_format: String,
        /// Destination format description.
        dest_format: String,
    },

    /// Cycle detected in the graph.
    #[error("cycle detected in graph involving node {0:?}")]
    CycleDetected(NodeId),

    /// Graph is not configured properly.
    #[error("graph configuration error: {0}")]
    ConfigurationError(String),

    /// Node processing error.
    #[error("processing error in node {node:?}: {message}")]
    ProcessingError {
        /// The node where processing failed.
        node: NodeId,
        /// Error message.
        message: String,
    },

    /// End of stream reached.
    #[error("end of stream")]
    EndOfStream,

    /// No data available (non-blocking).
    #[error("no data available, try again")]
    WouldBlock,

    /// Invalid node state transition.
    #[error("invalid state transition for node {node:?}: from {from} to {to}")]
    InvalidStateTransition {
        /// The node ID.
        node: NodeId,
        /// Current state name.
        from: String,
        /// Attempted state name.
        to: String,
    },

    /// Graph is empty.
    #[error("graph has no nodes")]
    EmptyGraph,

    /// No source nodes found.
    #[error("graph has no source nodes")]
    NoSourceNodes,

    /// No sink nodes found.
    #[error("graph has no sink nodes")]
    NoSinkNodes,

    /// Port type mismatch.
    #[error("port type mismatch: expected {expected}, got {actual}")]
    PortTypeMismatch {
        /// Expected port type.
        expected: String,
        /// Actual port type.
        actual: String,
    },
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_error_display() {
        let err = GraphError::NodeNotFound(NodeId(42));
        assert!(err.to_string().contains("42"));

        let err = GraphError::CycleDetected(NodeId(1));
        assert!(err.to_string().contains("cycle"));

        let err = GraphError::EmptyGraph;
        assert!(err.to_string().contains("no nodes"));
    }

    #[test]
    fn test_port_not_found_error() {
        let err = GraphError::PortNotFound {
            node: NodeId(1),
            port: PortId(2),
        };
        let msg = err.to_string();
        assert!(msg.contains("1"));
        assert!(msg.contains("2"));
    }

    #[test]
    fn test_incompatible_formats_error() {
        let err = GraphError::IncompatibleFormats {
            source_format: "video/yuv420p".to_string(),
            dest_format: "audio/pcm".to_string(),
        };
        let msg = err.to_string();
        assert!(msg.contains("video"));
        assert!(msg.contains("audio"));
    }
}