Skip to main content

rskit_media/filter/
model.rs

1//! Filter data model: filters, targets, and typed parameters.
2
3use std::collections::HashMap;
4
5use serde::{Deserialize, Serialize};
6
7/// A named filter operation with typed parameters.
8///
9/// # Examples
10///
11/// ```rust
12/// use rskit_media::filter::filters;
13///
14/// let denoise = filters::denoise(3);
15/// let sharpen = filters::sharpen(1.5);
16/// let grayscale = filters::grayscale();
17/// let custom = filters::custom_video("chromakey=0x00FF00:0.1:0.2");
18/// ```
19#[derive(Debug, Clone, Serialize, Deserialize)]
20pub struct Filter {
21    /// Filter name (maps to backend filter name).
22    pub name: String,
23    /// Whether this filter targets video or audio.
24    pub target: FilterTarget,
25    /// Filter parameters.
26    pub params: Params,
27}
28
29/// Which stream type a filter targets.
30#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
31pub enum FilterTarget {
32    /// Video stream filter.
33    Video,
34    /// Audio stream filter.
35    Audio,
36}
37
38/// Type-safe parameter map for filters.
39#[derive(Debug, Clone, Default, Serialize, Deserialize)]
40pub struct Params(HashMap<String, ParamValue>);
41
42impl Params {
43    /// Create an empty parameter map.
44    pub fn new() -> Self {
45        Self(HashMap::new())
46    }
47
48    /// Set a parameter value (builder pattern).
49    #[must_use]
50    pub fn set(mut self, key: impl Into<String>, val: impl Into<ParamValue>) -> Self {
51        self.0.insert(key.into(), val.into());
52        self
53    }
54
55    /// Get a parameter value.
56    pub fn get(&self, key: &str) -> Option<&ParamValue> {
57        self.0.get(key)
58    }
59
60    /// Iterate over parameters.
61    pub fn iter(&self) -> impl Iterator<Item = (&str, &ParamValue)> {
62        self.0.iter().map(|(k, v)| (k.as_str(), v))
63    }
64}
65
66/// A filter parameter value.
67#[derive(Debug, Clone, Serialize, Deserialize)]
68pub enum ParamValue {
69    /// Integer value.
70    Int(i64),
71    /// Floating-point value.
72    Float(f64),
73    /// String value.
74    Str(String),
75    /// Boolean value.
76    Bool(bool),
77}
78
79impl From<i64> for ParamValue {
80    fn from(v: i64) -> Self {
81        Self::Int(v)
82    }
83}
84
85impl From<f64> for ParamValue {
86    fn from(v: f64) -> Self {
87        Self::Float(v)
88    }
89}
90
91impl From<String> for ParamValue {
92    fn from(v: String) -> Self {
93        Self::Str(v)
94    }
95}
96
97impl From<&str> for ParamValue {
98    fn from(v: &str) -> Self {
99        Self::Str(v.to_string())
100    }
101}
102
103impl From<bool> for ParamValue {
104    fn from(v: bool) -> Self {
105        Self::Bool(v)
106    }
107}