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 glib::object::IsA;
use glib::translate::*;

glib::wrapper! {
    /// Base structure for information concerning a media stream. Depending on the
    /// stream type, one can find more media-specific information in
    /// [`crate::DiscovererAudioInfo`], [`crate::DiscovererVideoInfo`], and
    /// [`crate::DiscovererContainerInfo`].
    ///
    /// The [`crate::DiscovererStreamInfo`] represents the topology of the stream. Siblings
    /// can be iterated over with [`crate::prelude::DiscovererStreamInfoExt::get_next()`] and
    /// [`crate::prelude::DiscovererStreamInfoExt::get_previous()`]. Children (sub-streams) of a
    /// stream can be accessed using the [`crate::DiscovererContainerInfo`] API.
    ///
    /// As a simple example, if you run [`crate::Discoverer`] on an AVI file with one audio
    /// and one video stream, you will get a [`crate::DiscovererContainerInfo`]
    /// corresponding to the AVI container, which in turn will have a
    /// [`crate::DiscovererAudioInfo`] sub-stream and a [`crate::DiscovererVideoInfo`] sub-stream
    /// for the audio and video streams respectively.
    ///
    /// # Implements
    ///
    /// [`trait@crate::prelude::DiscovererStreamInfoExt`], [`trait@glib::object::ObjectExt`]
    pub struct DiscovererStreamInfo(Object<ffi::GstDiscovererStreamInfo>);

    match fn {
        type_ => || ffi::gst_discoverer_stream_info_get_type(),
    }
}

unsafe impl Send for DiscovererStreamInfo {}
unsafe impl Sync for DiscovererStreamInfo {}

pub const NONE_DISCOVERER_STREAM_INFO: Option<&DiscovererStreamInfo> = None;

/// Trait containing all `DiscovererStreamInfo` methods.
///
/// # Implementors
///
/// [`struct@crate::DiscovererAudioInfo`], [`struct@crate::DiscovererContainerInfo`], [`struct@crate::DiscovererStreamInfo`], [`struct@crate::DiscovererSubtitleInfo`], [`struct@crate::DiscovererVideoInfo`]
pub trait DiscovererStreamInfoExt: 'static {
    ///
    /// # Returns
    ///
    /// the [`crate::gst::Caps`] of the stream. Unref with
    /// `gst_caps_unref` after usage.
    #[doc(alias = "gst_discoverer_stream_info_get_caps")]
    #[doc(alias = "get_caps")]
    fn caps(&self) -> Option<gst::Caps>;

    ///
    /// # Deprecated
    ///
    /// This functions is deprecated since version 1.4, use
    /// [`crate::DiscovererInfo::get_missing_elements_installer_details`]
    ///
    /// # Returns
    ///
    /// additional information regarding the stream (for
    /// example codec version, profile, etc..). If you wish to use the [`crate::gst::Structure`]
    /// after the life-time of `self` you will need to copy it.
    #[doc(alias = "gst_discoverer_stream_info_get_misc")]
    #[doc(alias = "get_misc")]
    fn misc(&self) -> Option<gst::Structure>;

    ///
    /// # Returns
    ///
    /// the next [`crate::DiscovererStreamInfo`] in a chain. [`None`]
    /// for final streams.
    /// Unref with `gst_discoverer_stream_info_unref` after usage.
    #[doc(alias = "gst_discoverer_stream_info_get_next")]
    #[doc(alias = "get_next")]
    fn next(&self) -> Option<DiscovererStreamInfo>;

    ///
    /// # Returns
    ///
    /// the previous [`crate::DiscovererStreamInfo`] in a chain.
    /// [`None`] for starting points. Unref with `gst_discoverer_stream_info_unref`
    /// after usage.
    #[doc(alias = "gst_discoverer_stream_info_get_previous")]
    #[doc(alias = "get_previous")]
    fn previous(&self) -> Option<DiscovererStreamInfo>;

    ///
    /// # Returns
    ///
    /// the stream ID of this stream. If you wish to
    /// use the stream ID after the life-time of `self` you will need to copy it.
    #[doc(alias = "gst_discoverer_stream_info_get_stream_id")]
    #[doc(alias = "get_stream_id")]
    fn stream_id(&self) -> Option<glib::GString>;

    ///
    /// # Returns
    ///
    /// a human readable name for the stream type of the given `self` (ex : "audio",
    /// "container",...).
    #[doc(alias = "gst_discoverer_stream_info_get_stream_type_nick")]
    #[doc(alias = "get_stream_type_nick")]
    fn stream_type_nick(&self) -> glib::GString;

    ///
    /// # Returns
    ///
    /// the tags contained in this stream. If you wish to
    /// use the tags after the life-time of `self` you will need to copy them.
    #[doc(alias = "gst_discoverer_stream_info_get_tags")]
    #[doc(alias = "get_tags")]
    fn tags(&self) -> Option<gst::TagList>;

    ///
    /// # Returns
    ///
    /// the TOC contained in this stream. If you wish to
    /// use the TOC after the life-time of `self` you will need to copy it.
    #[doc(alias = "gst_discoverer_stream_info_get_toc")]
    #[doc(alias = "get_toc")]
    fn toc(&self) -> Option<gst::Toc>;
}

impl<O: IsA<DiscovererStreamInfo>> DiscovererStreamInfoExt for O {
    fn caps(&self) -> Option<gst::Caps> {
        unsafe {
            from_glib_full(ffi::gst_discoverer_stream_info_get_caps(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn misc(&self) -> Option<gst::Structure> {
        unsafe {
            from_glib_none(ffi::gst_discoverer_stream_info_get_misc(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn next(&self) -> Option<DiscovererStreamInfo> {
        unsafe {
            from_glib_full(ffi::gst_discoverer_stream_info_get_next(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn previous(&self) -> Option<DiscovererStreamInfo> {
        unsafe {
            from_glib_full(ffi::gst_discoverer_stream_info_get_previous(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn stream_id(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gst_discoverer_stream_info_get_stream_id(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn stream_type_nick(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::gst_discoverer_stream_info_get_stream_type_nick(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn tags(&self) -> Option<gst::TagList> {
        unsafe {
            from_glib_none(ffi::gst_discoverer_stream_info_get_tags(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn toc(&self) -> Option<gst::Toc> {
        unsafe {
            from_glib_none(ffi::gst_discoverer_stream_info_get_toc(
                self.as_ref().to_glib_none().0,
            ))
        }
    }
}