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
136pub struct AnalyticsClassificationIterator<'a> {
137    mtd: &'a AnalyticsMtdRef<'a, AnalyticsClassificationMtd>,
138    index: usize,
139    length: usize,
140}
141
142impl Iterator for AnalyticsClassificationIterator<'_> {
143    type Item = (glib::Quark, f32);
144
145    fn next(&mut self) -> Option<Self::Item> {
146        if self.index == self.length {
147            None
148        } else {
149            let ret = Some((self.mtd.quark(self.index), self.mtd.level(self.index)));
150            self.index += 1;
151            ret
152        }
153    }
154}
155
156#[cfg(test)]
157mod tests {
158    use crate::*;
159
160    #[test]
161    fn one_class() {
162        gst::init().unwrap();
163
164        assert_eq!(AnalyticsClassificationMtd::type_name(), "classification");
165
166        let mut buf = gst::Buffer::new();
167        let mut meta = AnalyticsRelationMeta::add(buf.make_mut());
168
169        assert!(meta.is_empty());
170
171        let cls = meta
172            .add_one_cls_mtd(0.7, glib::Quark::from_str("class1"))
173            .unwrap();
174
175        assert_eq!(cls.len(), 1);
176        assert_eq!(cls.level(0), 0.7);
177        assert_eq!(cls.quark(0), glib::Quark::from_str("class1"));
178    }
179
180    #[test]
181    fn many_classes() {
182        gst::init().unwrap();
183
184        assert_eq!(AnalyticsClassificationMtd::type_name(), "classification");
185
186        let mut buf = gst::Buffer::new();
187        let mut meta = AnalyticsRelationMeta::add(buf.make_mut());
188
189        assert!(meta.is_empty());
190
191        let classes = [
192            glib::Quark::from_str("a"),
193            glib::Quark::from_str("b"),
194            glib::Quark::from_str("c"),
195            glib::Quark::from_str("d"),
196        ];
197        let levels = [0.1, 0.2, 0.3, 0.4];
198
199        let cls = meta.add_cls_mtd(&levels, &classes).unwrap();
200
201        assert_eq!(cls.len(), 4);
202        for i in 0..4usize {
203            assert_eq!(cls.level(i), levels[i]);
204            assert_eq!(cls.quark(i), classes[i]);
205        }
206
207        for (i, (q, l)) in cls.iterate().enumerate() {
208            assert_eq!(l, levels[i]);
209            assert_eq!(q, classes[i]);
210        }
211    }
212}
gstreamer_analytics/classification.rs

gstreamer_analytics/
classification.rs
