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
147
148
149
150

use bitflags::bitflags;
use std::str::FromStr;

bitflags! {
    /// Encoder capabilities
    #[derive(Debug, Eq, PartialEq, Hash, Copy, Clone)]
    pub struct Capabilities: u16 {
        const VIDEO = 1 << 1;
        const AUDIO = 1 << 2;
        const SUBTITLE = 1 << 3;
        const FRAME_LEVEL_MULTITHREADING = 1 << 4;
        const SLICE_LEVEL_MULTITHREADING = 1 << 5;
        const EXPERIMENTAL = 1 << 6;
        const DRAW_HORIZ_BAND = 1 << 7;
        const DIRECT_RENDERING_METHOD_1 = 1 << 8;
    }
}

/// An error that may occur while parsing capabilities from a string
#[derive(Debug, thiserror::Error)]
pub enum FromStrError {
    /// Missing a field
    #[error("missing field")]
    Missing,

    /// A field had an invalid value
    #[error("invalid field")]
    Invalid,

    /// A field was found when it was not expected
    #[error("unexpected field")]
    Unexpected,
}

impl FromStr for Capabilities {
    type Err = FromStrError;
    fn from_str(input: &str) -> Result<Self, Self::Err> {
        let mut flags = Self::empty();
        let mut iter = input.bytes();
        match iter.next().ok_or(FromStrError::Missing)? {
            b'V' => flags.insert(Capabilities::VIDEO),
            b'A' => flags.insert(Capabilities::AUDIO),
            b'S' => flags.insert(Capabilities::SUBTITLE),
            _ => {
                return Err(FromStrError::Invalid);
            }
        }

        match iter.next().ok_or(FromStrError::Missing)? {
            b'F' => flags.insert(Capabilities::FRAME_LEVEL_MULTITHREADING),
            b'.' => {}
            _ => {
                return Err(FromStrError::Invalid);
            }
        }

        match iter.next().ok_or(FromStrError::Missing)? {
            b'S' => flags.insert(Capabilities::SLICE_LEVEL_MULTITHREADING),
            b'.' => {}
            _ => {
                return Err(FromStrError::Invalid);
            }
        }

        match iter.next().ok_or(FromStrError::Missing)? {
            b'X' => flags.insert(Capabilities::EXPERIMENTAL),
            b'.' => {}
            _ => {
                return Err(FromStrError::Invalid);
            }
        }

        match iter.next().ok_or(FromStrError::Missing)? {
            b'B' => flags.insert(Capabilities::DRAW_HORIZ_BAND),
            b'.' => {}
            _ => {
                return Err(FromStrError::Invalid);
            }
        }

        match iter.next().ok_or(FromStrError::Missing)? {
            b'D' => flags.insert(Capabilities::DIRECT_RENDERING_METHOD_1),
            b'.' => {}
            _ => {
                return Err(FromStrError::Invalid);
            }
        }

        if iter.next().is_some() {
            return Err(FromStrError::Unexpected);
        }

        Ok(flags)
    }
}

/// An error that occurs while parsing an Encoder from a line
#[derive(Debug, thiserror::Error)]
pub enum FromLineError {
    /// Missing the capabilities
    #[error("missing capabilities")]
    MissingCapabilities,

    /// Missing the name
    #[error("missing name")]
    MissingName,

    /// Missing the description
    #[error("missing description")]
    MissingDescription,

    /// Invalid Capabilities
    #[error("invalid capabilities")]
    InvalidCapabilities(#[from] FromStrError),
}

#[derive(Debug)]
pub struct Encoder {
    /// Encoder capabilities
    pub capabilities: Capabilities,

    /// The name
    pub name: Box<str>,

    /// The description
    pub description: Box<str>,
}

impl Encoder {
    /// Parse an encoder from an output line
    pub(crate) fn from_line(line: &str) -> Result<Self, FromLineError> {
        let mut iter = line.splitn(3, char::is_whitespace);
        let capabilities_str = iter.next().ok_or(FromLineError::MissingCapabilities)?;
        let name = iter.next().ok_or(FromLineError::MissingName)?;
        let description = iter.next().ok_or(FromLineError::MissingDescription)?.trim();

        let capabilities = capabilities_str.parse()?;

        Ok(Encoder {
            capabilities,
            name: name.into(),
            description: description.into(),
        })
    }

    /// Returns `true` if this is a video encoder
    pub fn is_video(&self) -> bool {
        self.capabilities.contains(Capabilities::VIDEO)
    }
}