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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216

// Take a look at the license at the top of the repository in the LICENSE file.

use glib::prelude::*;
use glib::translate::*;

glib::wrapper! {
    /// Utility struct to help handling [`crate::gst::FlowReturn`] combination. Useful for
    /// [`crate::gst::Element`]<!-- -->s that have multiple source pads and need to combine
    /// the different [`crate::gst::FlowReturn`] for those pads.
    ///
    /// [`crate::FlowCombiner`] works by using the last [`crate::gst::FlowReturn`] for all [`crate::gst::Pad`]
    /// it has in its list and computes the combined return value and provides
    /// it to the caller.
    ///
    /// To add a new pad to the [`crate::FlowCombiner`] use [`Self::add_pad()`].
    /// The new [`crate::gst::Pad`] is stored with a default value of [`crate::gst::FlowReturn::Ok`].
    ///
    /// In case you want a [`crate::gst::Pad`] to be removed, use [`Self::remove_pad()`].
    ///
    /// Please be aware that this struct isn't thread safe as its designed to be
    ///  used by demuxers, those usually will have a single thread operating it.
    ///
    /// These functions will take refs on the passed [`crate::gst::Pad`]<!-- -->s.
    ///
    /// Aside from reducing the user's code size, the main advantage of using this
    /// helper struct is to follow the standard rules for [`crate::gst::FlowReturn`] combination.
    /// These rules are:
    ///
    /// * [`crate::gst::FlowReturn::Eos`]: only if all returns are EOS too
    /// * [`crate::gst::FlowReturn::NotLinked`]: only if all returns are NOT_LINKED too
    /// * [`crate::gst::FlowReturn::Error`] or below: if at least one returns an error return
    /// * [`crate::gst::FlowReturn::NotNegotiated`]: if at least one returns a not-negotiated return
    /// * [`crate::gst::FlowReturn::Flushing`]: if at least one returns flushing
    /// * [`crate::gst::FlowReturn::Ok`]: otherwise
    ///
    /// [`crate::gst::FlowReturn::Error`] or below, GST_FLOW_NOT_NEGOTIATED and GST_FLOW_FLUSHING are
    /// returned immediately from the [`Self::update_flow()`] function.
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct FlowCombiner(Shared<ffi::GstFlowCombiner>);

    match fn {
        ref => |ptr| {
            // cfg_if emits code in blocks (curly braces) and `ref` handling inserts a
            // trailing semicolon to void an optionally returned value. The linter
            // requests the resulting { ..ref() }; to be simplified making it unsuitable.
            #[cfg(feature = "v1_12_1")]
            ffi::gst_flow_combiner_ref(ptr);
            #[cfg(not(feature = "v1_12_1"))]
            glib::gobject_ffi::g_boxed_copy(ffi::gst_flow_combiner_get_type(), ptr as *mut _);
        },
        unref => |ptr| {
            cfg_if::cfg_if! {
                if #[cfg(feature = "v1_12_1")] {
                    ffi::gst_flow_combiner_unref(ptr)
                } else {
                    glib::gobject_ffi::g_boxed_free(ffi::gst_flow_combiner_get_type(), ptr as *mut _)
                }
            }
        },
        type_ => || ffi::gst_flow_combiner_get_type(),
    }
}

impl FlowCombiner {
    /// Creates a new [`crate::FlowCombiner`], use [`Self::free()`] to free it.
    ///
    /// # Returns
    ///
    /// A new [`crate::FlowCombiner`]
    pub fn new() -> Self {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gst_flow_combiner_new()) }
    }

    /// Adds a new [`crate::gst::Pad`] to the [`crate::FlowCombiner`].
    /// ## `pad`
    /// the [`crate::gst::Pad`] that is being added
    pub fn add_pad<P: IsA<gst::Pad>>(&self, pad: &P) {
        unsafe {
            ffi::gst_flow_combiner_add_pad(self.to_glib_none().0, pad.as_ref().to_glib_none().0);
        }
    }

    /// Removes all pads from a [`crate::FlowCombiner`] and resets it to its initial state.
    pub fn clear(&self) {
        unsafe {
            ffi::gst_flow_combiner_clear(self.to_glib_none().0);
        }
    }

    /// Removes a [`crate::gst::Pad`] from the [`crate::FlowCombiner`].
    /// ## `pad`
    /// the [`crate::gst::Pad`] to remove
    pub fn remove_pad<P: IsA<gst::Pad>>(&self, pad: &P) {
        unsafe {
            ffi::gst_flow_combiner_remove_pad(self.to_glib_none().0, pad.as_ref().to_glib_none().0);
        }
    }

    /// Reset flow combiner and all pads to their initial state without removing pads.
    pub fn reset(&self) {
        unsafe {
            ffi::gst_flow_combiner_reset(self.to_glib_none().0);
        }
    }

    /// Computes the combined flow return for the pads in it.
    ///
    /// The [`crate::gst::FlowReturn`] parameter should be the last flow return update for a pad
    /// in this [`crate::FlowCombiner`]. It will use this value to be able to shortcut some
    /// combinations and avoid looking over all pads again. e.g. The last combined
    /// return is the same as the latest obtained [`crate::gst::FlowReturn`].
    /// ## `fret`
    /// the latest [`crate::gst::FlowReturn`] received for a pad in this [`crate::FlowCombiner`]
    ///
    /// # Returns
    ///
    /// The combined [`crate::gst::FlowReturn`]
    pub fn update_flow<FRet: Into<gst::FlowReturn>>(
        &self,
        fret: FRet,
    ) -> Result<gst::FlowSuccess, gst::FlowError> {
        let fret: gst::FlowReturn = fret.into();
        unsafe {
            gst::FlowSuccess::try_from_glib(ffi::gst_flow_combiner_update_flow(
                self.to_glib_none().0,
                fret.into_glib(),
            ))
        }
    }

    /// Sets the provided pad's last flow return to provided value and computes
    /// the combined flow return for the pads in it.
    ///
    /// The [`crate::gst::FlowReturn`] parameter should be the last flow return update for a pad
    /// in this [`crate::FlowCombiner`]. It will use this value to be able to shortcut some
    /// combinations and avoid looking over all pads again. e.g. The last combined
    /// return is the same as the latest obtained [`crate::gst::FlowReturn`].
    /// ## `pad`
    /// the [`crate::gst::Pad`] whose [`crate::gst::FlowReturn`] to update
    /// ## `fret`
    /// the latest [`crate::gst::FlowReturn`] received for a pad in this [`crate::FlowCombiner`]
    ///
    /// # Returns
    ///
    /// The combined [`crate::gst::FlowReturn`]
    pub fn update_pad_flow<P: IsA<gst::Pad>, FRet: Into<gst::FlowReturn>>(
        &self,
        pad: &P,
        fret: FRet,
    ) -> Result<gst::FlowSuccess, gst::FlowError> {
        let fret: gst::FlowReturn = fret.into();
        unsafe {
            gst::FlowSuccess::try_from_glib(ffi::gst_flow_combiner_update_pad_flow(
                self.to_glib_none().0,
                pad.as_ref().to_glib_none().0,
                fret.into_glib(),
            ))
        }
    }
}

impl Default for FlowCombiner {
    fn default() -> Self {
        Self::new()
    }
}

#[derive(Debug)]
pub struct UniqueFlowCombiner(FlowCombiner);

unsafe impl Sync for UniqueFlowCombiner {}
unsafe impl Send for UniqueFlowCombiner {}

impl UniqueFlowCombiner {
    pub fn new() -> Self {
        Self(FlowCombiner::new())
    }

    pub fn add_pad<P: IsA<gst::Pad>>(&mut self, pad: &P) {
        self.0.add_pad(pad);
    }

    pub fn clear(&mut self) {
        self.0.clear();
    }

    pub fn remove_pad<P: IsA<gst::Pad>>(&mut self, pad: &P) {
        self.0.remove_pad(pad);
    }

    pub fn reset(&mut self) {
        self.0.reset();
    }

    pub fn update_flow(
        &mut self,
        fret: Result<gst::FlowSuccess, gst::FlowError>,
    ) -> Result<gst::FlowSuccess, gst::FlowError> {
        self.0.update_flow(fret)
    }

    pub fn update_pad_flow<P: IsA<gst::Pad>>(
        &mut self,
        pad: &P,
        fret: Result<gst::FlowSuccess, gst::FlowError>,
    ) -> Result<gst::FlowSuccess, gst::FlowError> {
        self.0.update_pad_flow(pad, fret)
    }
}

impl Default for UniqueFlowCombiner {
    fn default() -> Self {
        Self::new()
    }
}