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
// Copyright (C) 2017 Sebastian Dröge <sebastian@centricular.com> // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. use ffi; use glib::object::IsA; use glib::translate::*; use glib_ffi; use gobject_ffi; use gst; use std::mem; use std::ptr; glib_wrapper! { /// Utility struct to help handling `gst::FlowReturn` combination. Useful for /// `gst::Element`<!-- -->s that have multiple source pads and need to combine /// the different `gst::FlowReturn` for those pads. /// /// `FlowCombiner` works by using the last `gst::FlowReturn` for all `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 `FlowCombiner` use `FlowCombiner::add_pad`. /// The new `gst::Pad` is stored with a default value of `gst::FlowReturn::Ok`. /// /// In case you want a `gst::Pad` to be removed, use `FlowCombiner::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 `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 `gst::FlowReturn` combination. /// These rules are: /// /// * `gst::FlowReturn::Eos`: only if all returns are EOS too /// * `gst::FlowReturn::NotLinked`: only if all returns are NOT_LINKED too /// * `gst::FlowReturn::Error` or below: if at least one returns an error return /// * `gst::FlowReturn::NotNegotiated`: if at least one returns a not-negotiated return /// * `gst::FlowReturn::Flushing`: if at least one returns flushing /// * `gst::FlowReturn::Ok`: otherwise /// /// `gst::FlowReturn::Error` or below, GST_FLOW_NOT_NEGOTIATED and GST_FLOW_FLUSHING are /// returned immediatelly from the `FlowCombiner::update_flow` function. pub struct FlowCombiner(Shared<ffi::GstFlowCombiner>); match fn { ref => |ptr| { gobject_ffi::g_boxed_copy(ffi::gst_flow_combiner_get_type(), ptr as *mut _) }, unref => |ptr| { gobject_ffi::g_boxed_free(ffi::gst_flow_combiner_get_type(), ptr as *mut _) }, get_type => || ffi::gst_flow_combiner_get_type(), } } impl FlowCombiner { /// Creates a new `FlowCombiner`, use `FlowCombiner::free` to free it. /// /// # Returns /// /// A new `FlowCombiner` pub fn new() -> FlowCombiner { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gst_flow_combiner_new()) } } /// Adds a new `gst::Pad` to the `FlowCombiner`. /// ## `pad` /// the `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.to_glib_none().0); } } /// Removes all pads from a `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 `gst::Pad` from the `FlowCombiner`. /// ## `pad` /// the `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.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 `gst::FlowReturn` parameter should be the last flow return update for a pad /// in this `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 `gst::FlowReturn`. /// ## `fret` /// the latest `gst::FlowReturn` received for a pad in this `FlowCombiner` /// /// # Returns /// /// The combined `gst::FlowReturn` pub fn update_flow(&self, fret: gst::FlowReturn) -> gst::FlowReturn { unsafe { from_glib(ffi::gst_flow_combiner_update_flow( self.to_glib_none().0, fret.to_glib(), )) } } /// Sets the provided pad's last flow return to provided value and computes /// the combined flow return for the pads in it. /// /// The `gst::FlowReturn` parameter should be the last flow return update for a pad /// in this `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 `gst::FlowReturn`. /// ## `pad` /// the `gst::Pad` whose `gst::FlowReturn` to update /// ## `fret` /// the latest `gst::FlowReturn` received for a pad in this `FlowCombiner` /// /// # Returns /// /// The combined `gst::FlowReturn` pub fn update_pad_flow<P: IsA<gst::Pad>>( &self, pad: &P, fret: gst::FlowReturn, ) -> gst::FlowReturn { unsafe { from_glib(ffi::gst_flow_combiner_update_pad_flow( self.to_glib_none().0, pad.to_glib_none().0, fret.to_glib(), )) } } } impl Default for FlowCombiner { fn default() -> Self { Self::new() } }