ccap-rs 1.6.0

Rust bindings for ccap — high-performance, cross-platform webcam/camera capture with hardware-accelerated pixel format conversion (DirectShow/AVFoundation/V4L2), including common RGB/YUV workflows and video file input/playback support
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

//! Error handling for ccap library

use thiserror::Error;

/// Error types for ccap operations
#[derive(Debug, Error)]
pub enum CcapError {
    /// No error occurred
    #[error("No error")]
    None,

    /// No camera device found
    #[error("No camera device found")]
    NoDeviceFound,

    /// Invalid device specified
    #[error("Invalid device: {0}")]
    InvalidDevice(String),

    /// Camera device open failed
    #[error("Camera device open failed")]
    DeviceOpenFailed,

    /// Device already opened
    #[error("Device already opened")]
    DeviceAlreadyOpened,

    /// Device not opened
    #[error("Device not opened")]
    DeviceNotOpened,

    /// Capture start failed
    #[error("Capture start failed")]
    CaptureStartFailed,

    /// Capture stop failed
    #[error("Capture stop failed")]
    CaptureStopFailed,

    /// Frame grab failed
    #[error("Frame grab failed")]
    FrameGrabFailed,

    /// Timeout occurred
    #[error("Timeout occurred")]
    Timeout,

    /// Invalid parameter
    #[error("Invalid parameter: {0}")]
    InvalidParameter(String),

    /// Not supported operation
    #[error("Operation not supported")]
    NotSupported,

    /// Backend set failed
    #[error("Backend set failed")]
    BackendSetFailed,

    /// String conversion error
    #[error("String conversion error: {0}")]
    StringConversionError(String),

    /// File operation failed
    #[error("File operation failed: {0}")]
    FileOperationFailed(String),

    /// Device not found (alias for NoDeviceFound for compatibility)
    #[error("Device not found")]
    DeviceNotFound,

    /// Internal error
    #[error("Internal error: {0}")]
    InternalError(String),

    /// Unknown error with error code
    #[error("Unknown error: {code}")]
    Unknown {
        /// Error code from the underlying system
        code: i32,
    },
}

impl From<i32> for CcapError {
    fn from(code: i32) -> Self {
        use crate::sys::*;

        // Convert i32 to CcapErrorCode for matching
        // On some platforms CcapErrorCode might be unsigned
        let code_u = code as CcapErrorCode;

        #[allow(non_upper_case_globals)]
        match code_u {
            CcapErrorCode_CCAP_ERROR_NONE => CcapError::None,
            CcapErrorCode_CCAP_ERROR_NO_DEVICE_FOUND => CcapError::NoDeviceFound,
            CcapErrorCode_CCAP_ERROR_INVALID_DEVICE => CcapError::InvalidDevice("".to_string()),
            CcapErrorCode_CCAP_ERROR_DEVICE_OPEN_FAILED => CcapError::DeviceOpenFailed,
            CcapErrorCode_CCAP_ERROR_DEVICE_START_FAILED => CcapError::CaptureStartFailed,
            CcapErrorCode_CCAP_ERROR_DEVICE_STOP_FAILED => CcapError::CaptureStopFailed,
            CcapErrorCode_CCAP_ERROR_FRAME_CAPTURE_FAILED => CcapError::FrameGrabFailed,
            CcapErrorCode_CCAP_ERROR_FRAME_CAPTURE_TIMEOUT => CcapError::Timeout,
            CcapErrorCode_CCAP_ERROR_UNSUPPORTED_PIXEL_FORMAT => CcapError::NotSupported,
            CcapErrorCode_CCAP_ERROR_UNSUPPORTED_RESOLUTION => CcapError::NotSupported,
            CcapErrorCode_CCAP_ERROR_PROPERTY_SET_FAILED => {
                CcapError::InvalidParameter("".to_string())
            }
            CcapErrorCode_CCAP_ERROR_MEMORY_ALLOCATION_FAILED => CcapError::Unknown { code },
            CcapErrorCode_CCAP_ERROR_INTERNAL_ERROR => CcapError::Unknown { code },
            _ => CcapError::Unknown { code },
        }
    }
}

/// Result type for ccap operations
pub type Result<T> = std::result::Result<T, CcapError>;