gstreamer_analytics/
classification.rs

Help
1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use glib::translate::*;
4
5use crate::{ffi, relation_meta::*};
6
7#[derive(Debug)]
8pub enum AnalyticsClassificationMtd {}
9
10mod sealed {
11    pub trait Sealed {}
12    impl<T: super::AnalyticsRelationMetaClassificationExt> Sealed for T {}
13}
14
15pub trait AnalyticsRelationMetaClassificationExt: sealed::Sealed {
16    fn add_one_cls_mtd(
17        &mut self,
18        confidence_level: f32,
19        class_quark: glib::Quark,
20    ) -> Result<AnalyticsMtdRef<AnalyticsClassificationMtd>, glib::BoolError>;
21
22    fn add_cls_mtd(
23        &mut self,
24        confidence_levels: &[f32],
25        class_quarks: &[glib::Quark],
26    ) -> Result<AnalyticsMtdRef<AnalyticsClassificationMtd>, glib::BoolError>;
27}
28
29impl<'a> AnalyticsRelationMetaClassificationExt
30    for gst::MetaRefMut<'a, AnalyticsRelationMeta, gst::meta::Standalone>
31{
32    #[doc(alias = "gst_analytics_relation_meta_add_one_cls_mtd")]
33    fn add_one_cls_mtd(
34        &mut self,
35        confidence_level: f32,
36        class_quark: glib::Quark,
37    ) -> Result<AnalyticsMtdRef<'a, AnalyticsClassificationMtd>, glib::BoolError> {
38        unsafe {
39            let mut mtd = std::mem::MaybeUninit::uninit();
40            let ret = from_glib(ffi::gst_analytics_relation_meta_add_one_cls_mtd(
41                self.as_mut_ptr(),
42                confidence_level,
43                class_quark.into_glib(),
44                mtd.as_mut_ptr(),
45            ));
46            let id = mtd.assume_init().id;
47
48            if ret {
49                Ok(AnalyticsMtdRef::from_meta(self.as_ref(), id))
50            } else {
51                Err(glib::bool_error!("Couldn't add more data"))
52            }
53        }
54    }
55
56    #[doc(alias = "gst_analytics_relation_meta_add_cls_mtd")]
57    fn add_cls_mtd(
58        &mut self,
59        confidence_levels: &[f32],
60        class_quarks: &[glib::Quark],
61    ) -> Result<AnalyticsMtdRef<'a, AnalyticsClassificationMtd>, glib::BoolError> {
62        let length = std::cmp::min(confidence_levels.len(), class_quarks.len());
63        unsafe {
64            let mut mtd = std::mem::MaybeUninit::uninit();
65            let ret = from_glib(ffi::gst_analytics_relation_meta_add_cls_mtd(
66                self.as_mut_ptr(),
67                length,
68                mut_override(confidence_levels.as_ptr()),
69                class_quarks.as_ptr() as *mut _,
70                mtd.as_mut_ptr(),
71            ));
72            let id = mtd.assume_init().id;
73
74            if ret {
75                Ok(AnalyticsMtdRef::from_meta(self.as_ref(), id))
76            } else {
77                Err(glib::bool_error!("Couldn't add more data"))
78            }
79        }
80    }
81}
82
83unsafe impl AnalyticsMtd for AnalyticsClassificationMtd {
84    #[doc(alias = "gst_analytics_cls_mtd_get_mtd_type")]
85    fn mtd_type() -> ffi::GstAnalyticsMtdType {
86        unsafe { ffi::gst_analytics_cls_mtd_get_mtd_type() }
87    }
88}
89
90unsafe fn from(t: ffi::GstAnalyticsMtd) -> ffi::GstAnalyticsClsMtd {
91    std::mem::transmute(t)
92}
93
94impl AnalyticsMtdRef<'_, AnalyticsClassificationMtd> {
95    #[doc(alias = "gst_analytics_cls_mtd_get_length")]
96    pub fn len(&self) -> usize {
97        unsafe {
98            let mtd = from(ffi::GstAnalyticsMtd::unsafe_from(self));
99            ffi::gst_analytics_cls_mtd_get_length(&mtd)
100        }
101    }
102
103    pub fn is_empty(&self) -> bool {
104        self.len() == 0
105    }
106
107    #[doc(alias = "gst_analytics_cls_mtd_get_level")]
108    pub fn level(&self, index: usize) -> f32 {
109        assert!(index < self.len());
110
111        unsafe {
112            let mtd = from(ffi::GstAnalyticsMtd::unsafe_from(self));
113            ffi::gst_analytics_cls_mtd_get_level(&mtd, index)
114        }
115    }
116
117    #[doc(alias = "gst_analytics_cls_mtd_get_quark")]
118    pub fn quark(&self, index: usize) -> glib::Quark {
119        assert!(index < self.len());
120
121        unsafe {
122            let mtd = from(ffi::GstAnalyticsMtd::unsafe_from(self));
123            from_glib(ffi::gst_analytics_cls_mtd_get_quark(&mtd, index))
124        }
125    }
126
127    pub fn iterate(&self) -> AnalyticsClassificationIterator {
128        AnalyticsClassificationIterator {
129            mtd: self,
130            index: 0,
131            length: self.len(),
132        }
133    }
134}
135
136#[must_use = "iterators are lazy and do nothing unless consumed"]
137pub struct AnalyticsClassificationIterator<'a> {
138    mtd: &'a AnalyticsMtdRef<'a, AnalyticsClassificationMtd>,
139    index: usize,
140    length: usize,
141}
142
143impl Iterator for AnalyticsClassificationIterator<'_> {
144    type Item = (glib::Quark, f32);
145
146    fn next(&mut self) -> Option<Self::Item> {
147        if self.index == self.length {
148            None
149        } else {
150            let ret = Some((self.mtd.quark(self.index), self.mtd.level(self.index)));
151            self.index += 1;
152            ret
153        }
154    }
155}
156
157#[cfg(test)]
158mod tests {
159    use crate::*;
160
161    #[test]
162    fn one_class() {
163        gst::init().unwrap();
164
165        assert_eq!(AnalyticsClassificationMtd::type_name(), "classification");
166
167        let mut buf = gst::Buffer::new();
168        let mut meta = AnalyticsRelationMeta::add(buf.make_mut());
169
170        assert!(meta.is_empty());
171
172        let cls = meta
173            .add_one_cls_mtd(0.7, glib::Quark::from_str("class1"))
174            .unwrap();
175
176        assert_eq!(cls.len(), 1);
177        assert_eq!(cls.level(0), 0.7);
178        assert_eq!(cls.quark(0), glib::Quark::from_str("class1"));
179    }
180
181    #[test]
182    fn many_classes() {
183        gst::init().unwrap();
184
185        assert_eq!(AnalyticsClassificationMtd::type_name(), "classification");
186
187        let mut buf = gst::Buffer::new();
188        let mut meta = AnalyticsRelationMeta::add(buf.make_mut());
189
190        assert!(meta.is_empty());
191
192        let classes = [
193            glib::Quark::from_str("a"),
194            glib::Quark::from_str("b"),
195            glib::Quark::from_str("c"),
196            glib::Quark::from_str("d"),
197        ];
198        let levels = [0.1, 0.2, 0.3, 0.4];
199
200        let cls = meta.add_cls_mtd(&levels, &classes).unwrap();
201
202        assert_eq!(cls.len(), 4);
203        for i in 0..4usize {
204            assert_eq!(cls.level(i), levels[i]);
205            assert_eq!(cls.quark(i), classes[i]);
206        }
207
208        for (i, (q, l)) in cls.iterate().enumerate() {
209            assert_eq!(l, levels[i]);
210            assert_eq!(q, classes[i]);
211        }
212    }
213}
gstreamer_analytics/classification.rs

gstreamer_analytics/
classification.rs
