kornia-io 0.2.0

Image and Video IO library in Rust for computer vision
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

//! Pixel format definitions for V4L2 cameras
use std::str::FromStr;
use v4l::FourCC;

/// Supported camera pixel formats
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum PixelFormat {
    /// YUYV 4:2:2 format (uncompressed, good quality, high bandwidth)
    #[default]
    YUYV,
    /// UYVY 4:2:2 format (uncompressed, good quality, high bandwidth)
    UYVY,
    /// Motion JPEG (compressed, excellent quality, lower bandwidth)
    MJPG,
    /// Custom format specified by FourCC bytes
    Custom([u8; 4]),
}

impl PixelFormat {
    /// Convert to V4L2 FourCC
    pub fn to_fourcc(&self) -> FourCC {
        match self {
            Self::YUYV => FourCC::new(b"YUYV"),
            Self::UYVY => FourCC::new(b"UYVY"),
            Self::MJPG => FourCC::new(b"MJPG"),
            Self::Custom(bytes) => FourCC::new(bytes),
        }
    }

    /// Create PixelFormat from V4L2 FourCC
    pub fn from_fourcc(fourcc: FourCC) -> Self {
        match fourcc.str() {
            Ok("YUYV") => Self::YUYV,
            Ok("UYVY") => Self::UYVY,
            Ok("MJPG") => Self::MJPG,
            _ => {
                let bytes = [
                    fourcc.repr[0],
                    fourcc.repr[1],
                    fourcc.repr[2],
                    fourcc.repr[3],
                ];
                Self::Custom(bytes)
            }
        }
    }

    /// Get the bytes per pixel for uncompressed formats
    pub fn bytes_per_pixel(&self) -> Option<usize> {
        match self {
            Self::YUYV => Some(2),   // 4:2:2 format, 2 bytes per pixel average
            Self::UYVY => Some(2),   // 4:2:2 format, 2 bytes per pixel average
            Self::MJPG => None,      // Variable compression
            Self::Custom(_) => None, // Unknown
        }
    }

    /// Get the format as a string
    pub fn as_str(&self) -> &str {
        match self {
            Self::YUYV => "YUYV",
            Self::UYVY => "UYVY",
            Self::MJPG => "MJPG",
            Self::Custom(_) => "custom",
        }
    }
}

impl std::fmt::Display for PixelFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::YUYV => write!(f, "YUYV"),
            Self::UYVY => write!(f, "UYVY"),
            Self::MJPG => write!(f, "MJPG"),
            Self::Custom(bytes) => {
                let fourcc_str = std::str::from_utf8(bytes).unwrap_or("????");
                write!(f, "{fourcc_str}")
            }
        }
    }
}

impl FromStr for PixelFormat {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "YUYV" => Ok(Self::YUYV),
            "UYVY" => Ok(Self::UYVY),
            "MJPG" => Ok(Self::MJPG),
            _ => Err(format!("Invalid pixel format: {s}")),
        }
    }
}