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

// 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 [`Pipeline`][crate::Pipeline] can be configured to.
    #[doc(alias = "GESPipelineFlags")]
    pub struct PipelineFlags: u32 {
        /// Output the `property::Pipeline::timeline`'s
        /// audio to the soundcard
        #[doc(alias = "GES_PIPELINE_MODE_PREVIEW_AUDIO")]
        const AUDIO_PREVIEW = ffi::GES_PIPELINE_MODE_PREVIEW_AUDIO as u32;
        /// Output the `property::Pipeline::timeline`'s
        /// video to the screen
        #[doc(alias = "GES_PIPELINE_MODE_PREVIEW_VIDEO")]
        const VIDEO_PREVIEW = ffi::GES_PIPELINE_MODE_PREVIEW_VIDEO as u32;
        /// Output both the `property::Pipeline::timeline`'s
        /// audio and video to the soundcard and screen (default)
        #[doc(alias = "GES_PIPELINE_MODE_PREVIEW")]
        const FULL_PREVIEW = ffi::GES_PIPELINE_MODE_PREVIEW as u32;
        /// Render the `property::Pipeline::timeline` with
        /// forced decoding (the underlying `encodebin` has its
        /// `encodebin:avoid-reencoding` property set to [`false`])
        #[doc(alias = "GES_PIPELINE_MODE_RENDER")]
        const RENDER = ffi::GES_PIPELINE_MODE_RENDER as u32;
        /// Render the `property::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 `property::Track::mixing`
        /// > is enabled.
        #[doc(alias = "GES_PIPELINE_MODE_SMART_RENDER")]
        const SMART_RENDER = ffi::GES_PIPELINE_MODE_SMART_RENDER as u32;
    }
}

#[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
    /// [`AUDIO`][Self::AUDIO], [`VIDEO`][Self::VIDEO] or [`TEXT`][Self::TEXT],
    /// the user of the [`Track`][crate::Track] must set the type to [`CUSTOM`][Self::CUSTOM].
    ///
    /// [`UNKNOWN`][Self::UNKNOWN] is for internal purposes and should not be used
    /// by users
    #[doc(alias = "GESTrackType")]
    pub struct TrackType: u32 {
        /// A track of unknown type (i.e. invalid)
        #[doc(alias = "GES_TRACK_TYPE_UNKNOWN")]
        const UNKNOWN = ffi::GES_TRACK_TYPE_UNKNOWN as u32;
        /// An audio track
        #[doc(alias = "GES_TRACK_TYPE_AUDIO")]
        const AUDIO = ffi::GES_TRACK_TYPE_AUDIO as u32;
        /// A video track
        #[doc(alias = "GES_TRACK_TYPE_VIDEO")]
        const VIDEO = ffi::GES_TRACK_TYPE_VIDEO as u32;
        /// A text (subtitle) track
        #[doc(alias = "GES_TRACK_TYPE_TEXT")]
        const TEXT = ffi::GES_TRACK_TYPE_TEXT as u32;
        /// A custom-content track
        #[doc(alias = "GES_TRACK_TYPE_CUSTOM")]
        const CUSTOM = ffi::GES_TRACK_TYPE_CUSTOM as u32;
    }
}

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()
    }
}