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

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
// DO NOT EDIT

use bitflags::bitflags;
use glib::translate::*;
use glib::value::FromValue;
use glib::value::ToValue;
use glib::StaticType;
use glib::Type;
use std::ffi::CStr;
use std::fmt;

bitflags! {
    /// The various modes a [`crate::Pipeline`] can be configured to.
    pub struct PipelineFlags: u32 {
        /// Output the [`crate::Pipeline:timeline`]'s
        /// audio to the soundcard
        const AUDIO_PREVIEW = 1;
        /// Output the [`crate::Pipeline:timeline`]'s
        /// video to the screen
        const VIDEO_PREVIEW = 2;
        /// Output both the [`crate::Pipeline:timeline`]'s
        /// audio and video to the soundcard and screen (default)
        const FULL_PREVIEW = 3;
        /// Render the [`crate::Pipeline:timeline`] with
        /// forced decoding (the underlying `encodebin` has its
        /// `encodebin:avoid-reencoding` property set to [`false`])
        const RENDER = 4;
        /// Render the [`crate::Pipeline:timeline`],
        /// avoiding decoding/reencoding (the underlying `encodebin` has its
        /// `encodebin:avoid-reencoding` property set to [`true`]).
        /// > NOTE: Smart rendering can not work in tracks where [`crate::Track:mixing`]
        /// > is enabled.
        const SMART_RENDER = 8;
    }
}

#[doc(hidden)]
impl IntoGlib for PipelineFlags {
    type GlibType = ffi::GESPipelineFlags;

    fn into_glib(self) -> ffi::GESPipelineFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GESPipelineFlags> for PipelineFlags {
    unsafe fn from_glib(value: ffi::GESPipelineFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for PipelineFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::ges_pipeline_flags_get_type()) }
    }
}

impl glib::value::ValueType for PipelineFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for PipelineFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for PipelineFlags {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    /// Types of content handled by a track. If the content is not one of
    /// [`Self::Audio`], [`Self::Video`] or [`Self::Text`],
    /// the user of the [`crate::Track`] must set the type to [`Self::Custom`].
    ///
    /// [`Self::Unknown`] is for internal purposes and should not be used
    /// by users
    pub struct TrackType: u32 {
        /// A track of unknown type (i.e. invalid)
        const UNKNOWN = 1;
        /// An audio track
        const AUDIO = 2;
        /// A video track
        const VIDEO = 4;
        /// A text (subtitle) track
        const TEXT = 8;
        /// A custom-content track
        const CUSTOM = 16;
    }
}

impl TrackType {
    pub fn name<'a>(self) -> &'a str {
        unsafe {
            CStr::from_ptr(
                ffi::ges_track_type_name(self.into_glib())
                    .as_ref()
                    .expect("ges_track_type_name returned NULL"),
            )
            .to_str()
            .expect("ges_track_type_name returned an invalid string")
        }
    }
}

impl fmt::Display for TrackType {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.name())
    }
}

#[doc(hidden)]
impl IntoGlib for TrackType {
    type GlibType = ffi::GESTrackType;

    fn into_glib(self) -> ffi::GESTrackType {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GESTrackType> for TrackType {
    unsafe fn from_glib(value: ffi::GESTrackType) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for TrackType {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::ges_track_type_get_type()) }
    }
}

impl glib::value::ValueType for TrackType {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for TrackType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for TrackType {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}