mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 1
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-11-23 01:51:06 +00:00
Code Issues Projects Releases Wiki Activity

gstreamer: Add various missing doc aliases to event/message/query functions

Browse source 
This is going to make it easier to find them from the corresponding C
function names.
This commit is contained in:
Sebastian Dröge 2021-11-13 11:01:59 +02:00 committed by Sebastian Dröge
parent 2471150e72
commit ddf398e3da
3 changed files with 169 additions and 4 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

60
gstreamer/src/event.rs
View file

@ -81,22 +81,27 @@ impl GroupId {
} }
impl EventType { impl EventType {
#[doc(alias = "GST_EVENT_IS_UPSTREAM")]
pub fn is_upstream(self) -> bool { pub fn is_upstream(self) -> bool {
(self.into_glib() as u32) & ffi::GST_EVENT_TYPE_UPSTREAM != 0 (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_UPSTREAM != 0
} }
#[doc(alias = "GST_EVENT_IS_DOWNSTREAM")]
pub fn is_downstream(self) -> bool { pub fn is_downstream(self) -> bool {
(self.into_glib() as u32) & ffi::GST_EVENT_TYPE_DOWNSTREAM != 0 (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_DOWNSTREAM != 0
} }
#[doc(alias = "GST_EVENT_IS_SERIALIZED")]
pub fn is_serialized(self) -> bool { pub fn is_serialized(self) -> bool {
(self.into_glib() as u32) & ffi::GST_EVENT_TYPE_SERIALIZED != 0 (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_SERIALIZED != 0
} }
#[doc(alias = "GST_EVENT_IS_STICKY")]
pub fn is_sticky(self) -> bool { pub fn is_sticky(self) -> bool {
(self.into_glib() as u32) & ffi::GST_EVENT_TYPE_STICKY != 0 (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_STICKY != 0
} }
#[doc(alias = "GST_EVENT_IS_STICKY_MULTI")]
pub fn is_sticky_multi(self) -> bool { pub fn is_sticky_multi(self) -> bool {
(self.into_glib() as u32) & ffi::GST_EVENT_TYPE_STICKY_MULTI != 0 (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_STICKY_MULTI != 0
} }
@ -173,33 +178,40 @@ impl EventRef {
} }
} }
#[doc(alias = "gst_event_writable_structure")]
pub fn structure_mut(&mut self) -> &mut StructureRef { pub fn structure_mut(&mut self) -> &mut StructureRef {
unsafe { unsafe {
StructureRef::from_glib_borrow_mut(ffi::gst_event_writable_structure(self.as_mut_ptr())) StructureRef::from_glib_borrow_mut(ffi::gst_event_writable_structure(self.as_mut_ptr()))
} }
} }
#[doc(alias = "GST_EVENT_IS_UPSTREAM")]
pub fn is_upstream(&self) -> bool { pub fn is_upstream(&self) -> bool {
self.type_().is_upstream() self.type_().is_upstream()
} }
#[doc(alias = "GST_EVENT_IS_DOWNSTREAM")]
pub fn is_downstream(&self) -> bool { pub fn is_downstream(&self) -> bool {
self.type_().is_downstream() self.type_().is_downstream()
} }
#[doc(alias = "GST_EVENT_IS_SERIALIZED")]
pub fn is_serialized(&self) -> bool { pub fn is_serialized(&self) -> bool {
self.type_().is_serialized() self.type_().is_serialized()
} }
#[doc(alias = "GST_EVENT_IS_STICKY")]
pub fn is_sticky(&self) -> bool { pub fn is_sticky(&self) -> bool {
self.type_().is_sticky() self.type_().is_sticky()
} }
#[doc(alias = "GST_EVENT_IS_STICKY_MULTI")]
pub fn is_sticky_multi(&self) -> bool { pub fn is_sticky_multi(&self) -> bool {
self.type_().is_sticky_multi() self.type_().is_sticky_multi()
} }
#[doc(alias = "get_type")] #[doc(alias = "get_type")]
#[doc(alias = "GST_EVENT_TYPE")]
pub fn type_(&self) -> EventType { pub fn type_(&self) -> EventType {
unsafe { from_glib((*self.as_ptr()).type_) } unsafe { from_glib((*self.as_ptr()).type_) }
} }
@ -398,6 +410,7 @@ macro_rules! declare_concrete_event {
declare_concrete_event!(FlushStart, T); declare_concrete_event!(FlushStart, T);
impl FlushStart<Event> { impl FlushStart<Event> {
#[doc(alias = "gst_event_new_flush_start")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new() -> Event { pub fn new() -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -412,6 +425,7 @@ impl FlushStart<Event> {
declare_concrete_event!(FlushStop, T); declare_concrete_event!(FlushStop, T);
impl FlushStop<Event> { impl FlushStop<Event> {
#[doc(alias = "gst_event_new_flush_stop")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(reset_time: bool) -> Event { pub fn new(reset_time: bool) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -426,6 +440,7 @@ impl FlushStop<Event> {
impl<T: AsPtr> FlushStop<T> { impl<T: AsPtr> FlushStop<T> {
#[doc(alias = "get_reset_time")] #[doc(alias = "get_reset_time")]
#[doc(alias = "gst_event_parse_flush_stop")]
pub fn resets_time(&self) -> bool { pub fn resets_time(&self) -> bool {
unsafe { unsafe {
let mut reset_time = mem::MaybeUninit::uninit(); let mut reset_time = mem::MaybeUninit::uninit();
@ -439,6 +454,7 @@ impl<T: AsPtr> FlushStop<T> {
declare_concrete_event!(@sticky StreamStart, T); declare_concrete_event!(@sticky StreamStart, T);
impl StreamStart<Event> { impl StreamStart<Event> {
#[doc(alias = "gst_event_new_stream_start")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(stream_id: &str) -> Event { pub fn new(stream_id: &str) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -453,6 +469,7 @@ impl StreamStart<Event> {
impl<T: AsPtr> StreamStart<T> { impl<T: AsPtr> StreamStart<T> {
#[doc(alias = "get_stream_id")] #[doc(alias = "get_stream_id")]
#[doc(alias = "gst_event_parse_stream_start")]
pub fn stream_id(&self) -> &str { pub fn stream_id(&self) -> &str {
unsafe { unsafe {
let mut stream_id = ptr::null(); let mut stream_id = ptr::null();
@ -506,6 +523,7 @@ impl<T: AsPtr> StreamStart<T> {
declare_concrete_event!(@sticky Caps, T); declare_concrete_event!(@sticky Caps, T);
impl Caps<Event> { impl Caps<Event> {
#[doc(alias = "gst_event_new_caps")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(caps: &crate::Caps) -> Event { pub fn new(caps: &crate::Caps) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -531,6 +549,7 @@ impl<T: AsPtr> Caps<T> {
} }
#[doc(alias = "get_caps_owned")] #[doc(alias = "get_caps_owned")]
#[doc(alias = "gst_event_parse_caps")]
pub fn caps_owned(&self) -> crate::Caps { pub fn caps_owned(&self) -> crate::Caps {
unsafe { from_glib_none(self.caps().as_ptr()) } unsafe { from_glib_none(self.caps().as_ptr()) }
} }
@ -538,6 +557,7 @@ impl<T: AsPtr> Caps<T> {
declare_concrete_event!(@sticky Segment, T); declare_concrete_event!(@sticky Segment, T);
impl Segment<Event> { impl Segment<Event> {
#[doc(alias = "gst_event_new_segment")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<F: crate::FormattedValueIntrinsic>(segment: &crate::FormattedSegment<F>) -> Event { pub fn new<F: crate::FormattedValueIntrinsic>(segment: &crate::FormattedSegment<F>) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -573,6 +593,7 @@ declare_concrete_event!(@sticky StreamCollection, T);
impl StreamCollection<Event> { impl StreamCollection<Event> {
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
#[doc(alias = "gst_event_new_stream_collection")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(stream_collection: &crate::StreamCollection) -> Event { pub fn new(stream_collection: &crate::StreamCollection) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -606,6 +627,7 @@ impl<T: AsPtr> StreamCollection<T> {
declare_concrete_event!(@sticky Tag, T); declare_concrete_event!(@sticky Tag, T);
impl Tag<Event> { impl Tag<Event> {
#[doc(alias = "gst_event_new_tag")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(tags: crate::TagList) -> Event { pub fn new(tags: crate::TagList) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -631,6 +653,7 @@ impl<T: AsPtr> Tag<T> {
} }
#[doc(alias = "get_tag_owned")] #[doc(alias = "get_tag_owned")]
#[doc(alias = "gst_event_parse_tag")]
pub fn tag_owned(&self) -> crate::TagList { pub fn tag_owned(&self) -> crate::TagList {
unsafe { from_glib_none(self.tag().as_ptr()) } unsafe { from_glib_none(self.tag().as_ptr()) }
} }
@ -638,6 +661,7 @@ impl<T: AsPtr> Tag<T> {
declare_concrete_event!(@sticky Buffersize, T); declare_concrete_event!(@sticky Buffersize, T);
impl Buffersize<Event> { impl Buffersize<Event> {
#[doc(alias = "gst_event_new_buffer_size")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<V: Into<GenericFormattedValue>>(minsize: V, maxsize: V, r#async: bool) -> Event { pub fn new<V: Into<GenericFormattedValue>>(minsize: V, maxsize: V, r#async: bool) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -659,6 +683,7 @@ impl Buffersize<Event> {
} }
impl<T: AsPtr> Buffersize<T> { impl<T: AsPtr> Buffersize<T> {
#[doc(alias = "gst_event_parse_buffer_size")]
pub fn get(&self) -> (GenericFormattedValue, GenericFormattedValue, bool) { pub fn get(&self) -> (GenericFormattedValue, GenericFormattedValue, bool) {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -684,6 +709,7 @@ impl<T: AsPtr> Buffersize<T> {
declare_concrete_event!(@sticky SinkMessage, T); declare_concrete_event!(@sticky SinkMessage, T);
impl SinkMessage<Event> { impl SinkMessage<Event> {
#[doc(alias = "gst_event_new_sink_message")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(name: &str, msg: &crate::Message) -> Event { pub fn new(name: &str, msg: &crate::Message) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -717,6 +743,7 @@ declare_concrete_event!(@sticky StreamGroupDone, T);
impl StreamGroupDone<Event> { impl StreamGroupDone<Event> {
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
#[doc(alias = "gst_event_new_stream_group_done")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(group_id: GroupId) -> Event { pub fn new(group_id: GroupId) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -737,6 +764,7 @@ impl<T: AsPtr> StreamGroupDone<T> {
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
#[doc(alias = "get_group_id")] #[doc(alias = "get_group_id")]
#[doc(alias = "gst_event_parse_stream_group_done")]
pub fn group_id(&self) -> GroupId { pub fn group_id(&self) -> GroupId {
unsafe { unsafe {
let mut group_id = mem::MaybeUninit::uninit(); let mut group_id = mem::MaybeUninit::uninit();
@ -752,6 +780,7 @@ impl<T: AsPtr> StreamGroupDone<T> {
declare_concrete_event!(@sticky Eos, T); declare_concrete_event!(@sticky Eos, T);
impl Eos<Event> { impl Eos<Event> {
#[doc(alias = "gst_event_new_eos")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new() -> Event { pub fn new() -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -768,6 +797,7 @@ declare_concrete_event!(@sticky Toc, T);
impl Toc<Event> { impl Toc<Event> {
// FIXME could use false for updated as default // FIXME could use false for updated as default
// Even better: use an enum for updated so that it is more explicit than true / false // Even better: use an enum for updated so that it is more explicit than true / false
#[doc(alias = "gst_event_new_toc")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(toc: &crate::Toc, updated: bool) -> Event { pub fn new(toc: &crate::Toc, updated: bool) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -797,6 +827,7 @@ impl<T: AsPtr> Toc<T> {
} }
#[doc(alias = "get_toc_owned")] #[doc(alias = "get_toc_owned")]
#[doc(alias = "gst_event_parse_toc")]
pub fn toc_owned(&self) -> (crate::Toc, bool) { pub fn toc_owned(&self) -> (crate::Toc, bool) {
unsafe { unsafe {
let (toc, updated) = self.toc(); let (toc, updated) = self.toc();
@ -807,6 +838,7 @@ impl<T: AsPtr> Toc<T> {
declare_concrete_event!(@sticky Protection, T); declare_concrete_event!(@sticky Protection, T);
impl Protection<Event> { impl Protection<Event> {
#[doc(alias = "gst_event_new_protection")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(system_id: &str, data: &crate::Buffer) -> Event { pub fn new(system_id: &str, data: &crate::Buffer) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -820,6 +852,7 @@ impl Protection<Event> {
} }
impl<T: AsPtr> Protection<T> { impl<T: AsPtr> Protection<T> {
#[doc(alias = "gst_event_parse_protection")]
pub fn get(&self) -> (&str, &crate::BufferRef, Option<&str>) { pub fn get(&self) -> (&str, &crate::BufferRef, Option<&str>) {
unsafe { unsafe {
let mut system_id = ptr::null(); let mut system_id = ptr::null();
@ -845,6 +878,7 @@ impl<T: AsPtr> Protection<T> {
} }
} }
#[doc(alias = "gst_event_parse_protection")]
pub fn get_owned(&self) -> (&str, crate::Buffer, Option<&str>) { pub fn get_owned(&self) -> (&str, crate::Buffer, Option<&str>) {
unsafe { unsafe {
let (system_id, buffer, origin) = self.get(); let (system_id, buffer, origin) = self.get();
@ -855,6 +889,7 @@ impl<T: AsPtr> Protection<T> {
declare_concrete_event!(SegmentDone, T); declare_concrete_event!(SegmentDone, T);
impl SegmentDone<Event> { impl SegmentDone<Event> {
#[doc(alias = "gst_event_new_segment_done")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<V: Into<GenericFormattedValue>>(position: V) -> Event { pub fn new<V: Into<GenericFormattedValue>>(position: V) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -869,6 +904,7 @@ impl SegmentDone<Event> {
} }
impl<T: AsPtr> SegmentDone<T> { impl<T: AsPtr> SegmentDone<T> {
#[doc(alias = "gst_event_parse_segment_done")]
pub fn get(&self) -> GenericFormattedValue { pub fn get(&self) -> GenericFormattedValue {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -887,6 +923,7 @@ impl<T: AsPtr> SegmentDone<T> {
declare_concrete_event!(Gap, T); declare_concrete_event!(Gap, T);
impl Gap<Event> { impl Gap<Event> {
#[doc(alias = "gst_event_new_gap")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(timestamp: ClockTime, duration: impl Into<Option<ClockTime>>) -> Event { pub fn new(timestamp: ClockTime, duration: impl Into<Option<ClockTime>>) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -900,6 +937,7 @@ impl Gap<Event> {
} }
impl<T: AsPtr> Gap<T> { impl<T: AsPtr> Gap<T> {
#[doc(alias = "gst_event_parse_gap")]
pub fn get(&self) -> (ClockTime, Option<ClockTime>) { pub fn get(&self) -> (ClockTime, Option<ClockTime>) {
unsafe { unsafe {
let mut timestamp = mem::MaybeUninit::uninit(); let mut timestamp = mem::MaybeUninit::uninit();
@ -936,6 +974,7 @@ declare_concrete_event!(@sticky InstantRateChange, T);
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
impl InstantRateChange<Event> { impl InstantRateChange<Event> {
#[doc(alias = "gst_event_new_instant_rate_change")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(multiplier: f64, new_flags: crate::SegmentFlags) -> Event { pub fn new(multiplier: f64, new_flags: crate::SegmentFlags) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -954,6 +993,7 @@ impl InstantRateChange<Event> {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
impl<T: AsPtr> InstantRateChange<T> { impl<T: AsPtr> InstantRateChange<T> {
#[doc(alias = "gst_event_parse_instant_rate_change")]
pub fn get(&self) -> (f64, crate::SegmentFlags) { pub fn get(&self) -> (f64, crate::SegmentFlags) {
unsafe { unsafe {
let mut multiplier = mem::MaybeUninit::uninit(); let mut multiplier = mem::MaybeUninit::uninit();
@ -972,6 +1012,7 @@ impl<T: AsPtr> InstantRateChange<T> {
declare_concrete_event!(Qos, T); declare_concrete_event!(Qos, T);
impl Qos<Event> { impl Qos<Event> {
#[doc(alias = "gst_event_new_qos")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new( pub fn new(
type_: crate::QOSType, type_: crate::QOSType,
@ -992,6 +1033,7 @@ impl Qos<Event> {
} }
impl<T: AsPtr> Qos<T> { impl<T: AsPtr> Qos<T> {
#[doc(alias = "gst_event_parse_qos")]
pub fn get(&self) -> (crate::QOSType, f64, i64, Option<ClockTime>) { pub fn get(&self) -> (crate::QOSType, f64, i64, Option<ClockTime>) {
unsafe { unsafe {
let mut type_ = mem::MaybeUninit::uninit(); let mut type_ = mem::MaybeUninit::uninit();
@ -1019,6 +1061,7 @@ impl<T: AsPtr> Qos<T> {
declare_concrete_event!(Seek, T); declare_concrete_event!(Seek, T);
impl Seek<Event> { impl Seek<Event> {
#[doc(alias = "gst_event_new_seek")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<V: Into<GenericFormattedValue>>( pub fn new<V: Into<GenericFormattedValue>>(
rate: f64, rate: f64,
@ -1050,6 +1093,7 @@ impl Seek<Event> {
} }
impl<T: AsPtr> Seek<T> { impl<T: AsPtr> Seek<T> {
#[doc(alias = "gst_event_parse_seek")]
pub fn get( pub fn get(
&self, &self,
) -> ( ) -> (
@ -1111,6 +1155,7 @@ impl<T: AsPtr> Seek<T> {
declare_concrete_event!(Navigation, T); declare_concrete_event!(Navigation, T);
impl Navigation<Event> { impl Navigation<Event> {
#[doc(alias = "gst_event_new_navigation")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(structure: crate::Structure) -> Event { pub fn new(structure: crate::Structure) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1125,6 +1170,7 @@ impl Navigation<Event> {
declare_concrete_event!(Latency, T); declare_concrete_event!(Latency, T);
impl Latency<Event> { impl Latency<Event> {
#[doc(alias = "gst_event_new_latency")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(latency: ClockTime) -> Event { pub fn new(latency: ClockTime) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1153,6 +1199,7 @@ impl<T: AsPtr> Latency<T> {
declare_concrete_event!(Step, T); declare_concrete_event!(Step, T);
impl Step<Event> { impl Step<Event> {
#[doc(alias = "gst_event_new_step")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<V: Into<GenericFormattedValue>>( pub fn new<V: Into<GenericFormattedValue>>(
amount: V, amount: V,
@ -1176,6 +1223,7 @@ impl Step<Event> {
} }
impl<T: AsPtr> Step<T> { impl<T: AsPtr> Step<T> {
#[doc(alias = "gst_event_parse_step")]
pub fn get(&self) -> (GenericFormattedValue, f64, bool, bool) { pub fn get(&self) -> (GenericFormattedValue, f64, bool, bool) {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -1208,6 +1256,7 @@ impl<T: AsPtr> Step<T> {
declare_concrete_event!(Reconfigure, T); declare_concrete_event!(Reconfigure, T);
impl Reconfigure<Event> { impl Reconfigure<Event> {
#[doc(alias = "gst_event_new_reconfigure")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new() -> Event { pub fn new() -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1222,6 +1271,7 @@ impl Reconfigure<Event> {
declare_concrete_event!(TocSelect, T); declare_concrete_event!(TocSelect, T);
impl TocSelect<Event> { impl TocSelect<Event> {
#[doc(alias = "gst_event_new_toc_select")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(uid: &str) -> Event { pub fn new(uid: &str) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1255,6 +1305,7 @@ declare_concrete_event!(SelectStreams, T);
impl SelectStreams<Event> { impl SelectStreams<Event> {
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
#[doc(alias = "gst_event_new_select_streams")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(streams: &[&str]) -> Event { pub fn new(streams: &[&str]) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1295,6 +1346,7 @@ declare_concrete_event!(InstantRateSyncTime, T);
impl InstantRateSyncTime<Event> { impl InstantRateSyncTime<Event> {
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
#[doc(alias = "gst_event_new_instant_rate_sync_time")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new( pub fn new(
rate_multiplier: f64, rate_multiplier: f64,
@ -1348,6 +1400,7 @@ impl<T: AsPtr> InstantRateSyncTime<T> {
declare_concrete_event!(CustomUpstream, T); declare_concrete_event!(CustomUpstream, T);
impl CustomUpstream<Event> { impl CustomUpstream<Event> {
#[doc(alias = "gst_event_new_custom")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(structure: crate::Structure) -> Event { pub fn new(structure: crate::Structure) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1362,6 +1415,7 @@ impl CustomUpstream<Event> {
declare_concrete_event!(CustomDownstream, T); declare_concrete_event!(CustomDownstream, T);
impl CustomDownstream<Event> { impl CustomDownstream<Event> {
#[doc(alias = "gst_event_new_custom")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(structure: crate::Structure) -> Event { pub fn new(structure: crate::Structure) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1376,6 +1430,7 @@ impl CustomDownstream<Event> {
declare_concrete_event!(CustomDownstreamOob, T); declare_concrete_event!(CustomDownstreamOob, T);
impl CustomDownstreamOob<Event> { impl CustomDownstreamOob<Event> {
#[doc(alias = "gst_event_new_custom")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(structure: crate::Structure) -> Event { pub fn new(structure: crate::Structure) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1390,6 +1445,7 @@ impl CustomDownstreamOob<Event> {
declare_concrete_event!(@sticky CustomDownstreamSticky, T); declare_concrete_event!(@sticky CustomDownstreamSticky, T);
impl CustomDownstreamSticky<Event> { impl CustomDownstreamSticky<Event> {
#[doc(alias = "gst_event_new_custom")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(structure: crate::Structure) -> Event { pub fn new(structure: crate::Structure) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1404,6 +1460,7 @@ impl CustomDownstreamSticky<Event> {
declare_concrete_event!(CustomBoth, T); declare_concrete_event!(CustomBoth, T);
impl CustomBoth<Event> { impl CustomBoth<Event> {
#[doc(alias = "gst_event_new_custom")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(structure: crate::Structure) -> Event { pub fn new(structure: crate::Structure) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1418,6 +1475,7 @@ impl CustomBoth<Event> {
declare_concrete_event!(CustomBothOob, T); declare_concrete_event!(CustomBothOob, T);
impl CustomBothOob<Event> { impl CustomBothOob<Event> {
#[doc(alias = "gst_event_new_custom")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(structure: crate::Structure) -> Event { pub fn new(structure: crate::Structure) -> Event {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1476,6 +1534,7 @@ impl<'a> EventBuilder<'a> {
macro_rules! event_builder_generic_impl { macro_rules! event_builder_generic_impl {
($new_fn:expr) => { ($new_fn:expr) => {
#[doc(alias = "gst_event_set_seqnum")]
#[allow(clippy::needless_update)] #[allow(clippy::needless_update)]
pub fn seqnum(self, seqnum: Seqnum) -> Self { pub fn seqnum(self, seqnum: Seqnum) -> Self {
Self { Self {
@ -1484,6 +1543,7 @@ macro_rules! event_builder_generic_impl {
} }
} }
#[doc(alias = "gst_event_set_running_time_offset")]
#[allow(clippy::needless_update)] #[allow(clippy::needless_update)]
pub fn running_time_offset(self, running_time_offset: i64) -> Self { pub fn running_time_offset(self, running_time_offset: i64) -> Self {
Self { Self {

73
gstreamer/src/message.rs
View file

@ -249,6 +249,7 @@ macro_rules! declare_concrete_message(
declare_concrete_message!(Eos); declare_concrete_message!(Eos);
impl<'a> Eos<'a> { impl<'a> Eos<'a> {
#[doc(alias = "gst_message_new_eos")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new() -> Message { pub fn new() -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -263,6 +264,7 @@ impl<'a> Eos<'a> {
declare_concrete_message!(Error); declare_concrete_message!(Error);
impl<'a> Error<'a> { impl<'a> Error<'a> {
#[doc(alias = "gst_message_new_error")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message { pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -287,6 +289,7 @@ impl<'a> Error<'a> {
} }
#[doc(alias = "get_debug")] #[doc(alias = "get_debug")]
#[doc(alias = "gst_message_parse_error")]
pub fn debug(&self) -> Option<String> { pub fn debug(&self) -> Option<String> {
unsafe { unsafe {
let mut debug = ptr::null_mut(); let mut debug = ptr::null_mut();
@ -318,6 +321,7 @@ impl<'a> Error<'a> {
declare_concrete_message!(Warning); declare_concrete_message!(Warning);
impl<'a> Warning<'a> { impl<'a> Warning<'a> {
#[doc(alias = "gst_message_new_warning")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message { pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -330,6 +334,7 @@ impl<'a> Warning<'a> {
} }
#[doc(alias = "get_error")] #[doc(alias = "get_error")]
#[doc(alias = "gst_message_parse_warning")]
pub fn error(&self) -> glib::Error { pub fn error(&self) -> glib::Error {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
@ -341,6 +346,7 @@ impl<'a> Warning<'a> {
} }
#[doc(alias = "get_debug")] #[doc(alias = "get_debug")]
#[doc(alias = "gst_message_parse_warning")]
pub fn debug(&self) -> Option<String> { pub fn debug(&self) -> Option<String> {
unsafe { unsafe {
let mut debug = ptr::null_mut(); let mut debug = ptr::null_mut();
@ -354,12 +360,12 @@ impl<'a> Warning<'a> {
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
#[doc(alias = "get_details")] #[doc(alias = "get_details")]
#[doc(alias = "gst_message_parse_error_details")] #[doc(alias = "gst_message_parse_warning_details")]
pub fn details(&self) -> Option<&StructureRef> { pub fn details(&self) -> Option<&StructureRef> {
unsafe { unsafe {
let mut details = ptr::null(); let mut details = ptr::null();
ffi::gst_message_parse_error_details(self.as_mut_ptr(), &mut details); ffi::gst_message_parse_warning_details(self.as_mut_ptr(), &mut details);
if details.is_null() { if details.is_null() {
None None
@ -372,6 +378,7 @@ impl<'a> Warning<'a> {
declare_concrete_message!(Info); declare_concrete_message!(Info);
impl<'a> Info<'a> { impl<'a> Info<'a> {
#[doc(alias = "gst_message_new_info")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message { pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -384,6 +391,7 @@ impl<'a> Info<'a> {
} }
#[doc(alias = "get_error")] #[doc(alias = "get_error")]
#[doc(alias = "gst_message_parse_info")]
pub fn error(&self) -> glib::Error { pub fn error(&self) -> glib::Error {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
@ -395,6 +403,7 @@ impl<'a> Info<'a> {
} }
#[doc(alias = "get_debug")] #[doc(alias = "get_debug")]
#[doc(alias = "gst_message_parse_info")]
pub fn debug(&self) -> Option<String> { pub fn debug(&self) -> Option<String> {
unsafe { unsafe {
let mut debug = ptr::null_mut(); let mut debug = ptr::null_mut();
@ -408,12 +417,12 @@ impl<'a> Info<'a> {
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
#[doc(alias = "get_details")] #[doc(alias = "get_details")]
#[doc(alias = "gst_message_parse_error_details")] #[doc(alias = "gst_message_parse_info_details")]
pub fn details(&self) -> Option<&StructureRef> { pub fn details(&self) -> Option<&StructureRef> {
unsafe { unsafe {
let mut details = ptr::null(); let mut details = ptr::null();
ffi::gst_message_parse_error_details(self.as_mut_ptr(), &mut details); ffi::gst_message_parse_info_details(self.as_mut_ptr(), &mut details);
if details.is_null() { if details.is_null() {
None None
@ -426,6 +435,7 @@ impl<'a> Info<'a> {
declare_concrete_message!(Tag); declare_concrete_message!(Tag);
impl<'a> Tag<'a> { impl<'a> Tag<'a> {
#[doc(alias = "gst_message_new_tag")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(tags: &TagList) -> Message { pub fn new(tags: &TagList) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -438,6 +448,7 @@ impl<'a> Tag<'a> {
} }
#[doc(alias = "get_tags")] #[doc(alias = "get_tags")]
#[doc(alias = "gst_message_parse_tag")]
pub fn tags(&self) -> TagList { pub fn tags(&self) -> TagList {
unsafe { unsafe {
let mut tags = ptr::null_mut(); let mut tags = ptr::null_mut();
@ -449,6 +460,7 @@ impl<'a> Tag<'a> {
declare_concrete_message!(Buffering); declare_concrete_message!(Buffering);
impl<'a> Buffering<'a> { impl<'a> Buffering<'a> {
#[doc(alias = "gst_message_new_buffering")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(percent: i32) -> Message { pub fn new(percent: i32) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -461,6 +473,7 @@ impl<'a> Buffering<'a> {
} }
#[doc(alias = "get_percent")] #[doc(alias = "get_percent")]
#[doc(alias = "gst_message_parse_buffering")]
pub fn percent(&self) -> i32 { pub fn percent(&self) -> i32 {
unsafe { unsafe {
let mut p = mem::MaybeUninit::uninit(); let mut p = mem::MaybeUninit::uninit();
@ -498,6 +511,7 @@ impl<'a> Buffering<'a> {
declare_concrete_message!(StateChanged); declare_concrete_message!(StateChanged);
impl<'a> StateChanged<'a> { impl<'a> StateChanged<'a> {
#[doc(alias = "gst_message_new_state_changed")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(old: crate::State, new: crate::State, pending: crate::State) -> Message { pub fn new(old: crate::State, new: crate::State, pending: crate::State) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -514,6 +528,7 @@ impl<'a> StateChanged<'a> {
} }
#[doc(alias = "get_old")] #[doc(alias = "get_old")]
#[doc(alias = "gst_message_parse_state_changed")]
pub fn old(&self) -> crate::State { pub fn old(&self) -> crate::State {
unsafe { unsafe {
let mut state = mem::MaybeUninit::uninit(); let mut state = mem::MaybeUninit::uninit();
@ -530,6 +545,7 @@ impl<'a> StateChanged<'a> {
} }
#[doc(alias = "get_current")] #[doc(alias = "get_current")]
#[doc(alias = "gst_message_parse_state_changed")]
pub fn current(&self) -> crate::State { pub fn current(&self) -> crate::State {
unsafe { unsafe {
let mut state = mem::MaybeUninit::uninit(); let mut state = mem::MaybeUninit::uninit();
@ -546,6 +562,7 @@ impl<'a> StateChanged<'a> {
} }
#[doc(alias = "get_pending")] #[doc(alias = "get_pending")]
#[doc(alias = "gst_message_parse_state_changed")]
pub fn pending(&self) -> crate::State { pub fn pending(&self) -> crate::State {
unsafe { unsafe {
let mut state = mem::MaybeUninit::uninit(); let mut state = mem::MaybeUninit::uninit();
@ -564,6 +581,7 @@ impl<'a> StateChanged<'a> {
declare_concrete_message!(StateDirty); declare_concrete_message!(StateDirty);
impl<'a> StateDirty<'a> { impl<'a> StateDirty<'a> {
#[doc(alias = "gst_message_new_state_dirty")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new() -> Message { pub fn new() -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -578,6 +596,7 @@ impl<'a> StateDirty<'a> {
declare_concrete_message!(StepDone); declare_concrete_message!(StepDone);
impl<'a> StepDone<'a> { impl<'a> StepDone<'a> {
#[doc(alias = "gst_message_new_step_done")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<V: Into<GenericFormattedValue>>( pub fn new<V: Into<GenericFormattedValue>>(
amount: V, amount: V,
@ -618,6 +637,7 @@ impl<'a> StepDone<'a> {
) )
} }
#[doc(alias = "gst_message_parse_step_done")]
pub fn get( pub fn get(
&self, &self,
) -> ( ) -> (
@ -668,6 +688,7 @@ impl<'a> StepDone<'a> {
declare_concrete_message!(ClockProvide); declare_concrete_message!(ClockProvide);
impl<'a> ClockProvide<'a> { impl<'a> ClockProvide<'a> {
#[doc(alias = "gst_message_new_clock_provide")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(clock: &crate::Clock, ready: bool) -> Message { pub fn new(clock: &crate::Clock, ready: bool) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -692,6 +713,7 @@ impl<'a> ClockProvide<'a> {
} }
#[doc(alias = "get_ready")] #[doc(alias = "get_ready")]
#[doc(alias = "gst_message_parse_clock_provide")]
pub fn is_ready(&self) -> bool { pub fn is_ready(&self) -> bool {
unsafe { unsafe {
let mut ready = mem::MaybeUninit::uninit(); let mut ready = mem::MaybeUninit::uninit();
@ -709,6 +731,7 @@ impl<'a> ClockProvide<'a> {
declare_concrete_message!(ClockLost); declare_concrete_message!(ClockLost);
impl<'a> ClockLost<'a> { impl<'a> ClockLost<'a> {
#[doc(alias = "gst_message_new_clock_lost")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(clock: &crate::Clock) -> Message { pub fn new(clock: &crate::Clock) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -735,6 +758,7 @@ impl<'a> ClockLost<'a> {
declare_concrete_message!(NewClock); declare_concrete_message!(NewClock);
impl<'a> NewClock<'a> { impl<'a> NewClock<'a> {
#[doc(alias = "gst_message_new_new_clock")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(clock: &crate::Clock) -> Message { pub fn new(clock: &crate::Clock) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -761,6 +785,7 @@ impl<'a> NewClock<'a> {
declare_concrete_message!(StructureChange); declare_concrete_message!(StructureChange);
impl<'a> StructureChange<'a> { impl<'a> StructureChange<'a> {
#[doc(alias = "gst_message_new_structure_change")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(type_: crate::StructureChangeType, owner: &crate::Element, busy: bool) -> Message { pub fn new(type_: crate::StructureChangeType, owner: &crate::Element, busy: bool) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -776,6 +801,7 @@ impl<'a> StructureChange<'a> {
StructureChangeBuilder::new(type_, owner, busy) StructureChangeBuilder::new(type_, owner, busy)
} }
#[doc(alias = "gst_message_parse_structure_change")]
pub fn get(&self) -> (crate::StructureChangeType, crate::Element, bool) { pub fn get(&self) -> (crate::StructureChangeType, crate::Element, bool) {
unsafe { unsafe {
let mut type_ = mem::MaybeUninit::uninit(); let mut type_ = mem::MaybeUninit::uninit();
@ -800,6 +826,7 @@ impl<'a> StructureChange<'a> {
declare_concrete_message!(StreamStatus); declare_concrete_message!(StreamStatus);
impl<'a> StreamStatus<'a> { impl<'a> StreamStatus<'a> {
#[doc(alias = "gst_message_new_stream_status")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(type_: crate::StreamStatusType, owner: &crate::Element) -> Message { pub fn new(type_: crate::StreamStatusType, owner: &crate::Element) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -811,6 +838,7 @@ impl<'a> StreamStatus<'a> {
StreamStatusBuilder::new(type_, owner) StreamStatusBuilder::new(type_, owner)
} }
#[doc(alias = "gst_message_parse_stream_status")]
pub fn get(&self) -> (crate::StreamStatusType, crate::Element) { pub fn get(&self) -> (crate::StreamStatusType, crate::Element) {
unsafe { unsafe {
let mut type_ = mem::MaybeUninit::uninit(); let mut type_ = mem::MaybeUninit::uninit();
@ -835,6 +863,7 @@ impl<'a> StreamStatus<'a> {
declare_concrete_message!(Application); declare_concrete_message!(Application);
impl<'a> Application<'a> { impl<'a> Application<'a> {
#[doc(alias = "gst_message_new_application")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(structure: crate::Structure) -> Message { pub fn new(structure: crate::Structure) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -849,6 +878,7 @@ impl<'a> Application<'a> {
declare_concrete_message!(Element); declare_concrete_message!(Element);
impl<'a> Element<'a> { impl<'a> Element<'a> {
#[doc(alias = "gst_message_new_element")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(structure: crate::Structure) -> Message { pub fn new(structure: crate::Structure) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -863,6 +893,7 @@ impl<'a> Element<'a> {
declare_concrete_message!(SegmentStart); declare_concrete_message!(SegmentStart);
impl<'a> SegmentStart<'a> { impl<'a> SegmentStart<'a> {
#[doc(alias = "gst_message_new_segment_start")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<V: Into<GenericFormattedValue>>(position: V) -> Message { pub fn new<V: Into<GenericFormattedValue>>(position: V) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -875,6 +906,7 @@ impl<'a> SegmentStart<'a> {
SegmentStartBuilder::new(position) SegmentStartBuilder::new(position)
} }
#[doc(alias = "gst_message_parse_segment_start")]
pub fn get(&self) -> GenericFormattedValue { pub fn get(&self) -> GenericFormattedValue {
unsafe { unsafe {
let mut format = mem::MaybeUninit::uninit(); let mut format = mem::MaybeUninit::uninit();
@ -893,6 +925,7 @@ impl<'a> SegmentStart<'a> {
declare_concrete_message!(SegmentDone); declare_concrete_message!(SegmentDone);
impl<'a> SegmentDone<'a> { impl<'a> SegmentDone<'a> {
#[doc(alias = "gst_message_new_segment_done")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<V: Into<GenericFormattedValue>>(position: V) -> Message { pub fn new<V: Into<GenericFormattedValue>>(position: V) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -905,6 +938,7 @@ impl<'a> SegmentDone<'a> {
SegmentDoneBuilder::new(position) SegmentDoneBuilder::new(position)
} }
#[doc(alias = "gst_message_parse_segment_done")]
pub fn get(&self) -> GenericFormattedValue { pub fn get(&self) -> GenericFormattedValue {
unsafe { unsafe {
let mut format = mem::MaybeUninit::uninit(); let mut format = mem::MaybeUninit::uninit();
@ -923,6 +957,7 @@ impl<'a> SegmentDone<'a> {
declare_concrete_message!(DurationChanged); declare_concrete_message!(DurationChanged);
impl<'a> DurationChanged<'a> { impl<'a> DurationChanged<'a> {
#[doc(alias = "gst_message_new_duration_changed")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new() -> Message { pub fn new() -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -937,6 +972,7 @@ impl<'a> DurationChanged<'a> {
declare_concrete_message!(Latency); declare_concrete_message!(Latency);
impl<'a> Latency<'a> { impl<'a> Latency<'a> {
#[doc(alias = "gst_message_new_latency")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new() -> Message { pub fn new() -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -951,6 +987,7 @@ impl<'a> Latency<'a> {
declare_concrete_message!(AsyncStart); declare_concrete_message!(AsyncStart);
impl<'a> AsyncStart<'a> { impl<'a> AsyncStart<'a> {
#[doc(alias = "gst_message_new_async_start")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new() -> Message { pub fn new() -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -965,6 +1002,7 @@ impl<'a> AsyncStart<'a> {
declare_concrete_message!(AsyncDone); declare_concrete_message!(AsyncDone);
impl<'a> AsyncDone<'a> { impl<'a> AsyncDone<'a> {
#[doc(alias = "gst_message_new_async_done")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(running_time: impl Into<Option<crate::ClockTime>>) -> Message { pub fn new(running_time: impl Into<Option<crate::ClockTime>>) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -977,6 +1015,7 @@ impl<'a> AsyncDone<'a> {
} }
#[doc(alias = "get_running_time")] #[doc(alias = "get_running_time")]
#[doc(alias = "gst_message_parse_async_done")]
pub fn running_time(&self) -> Option<crate::ClockTime> { pub fn running_time(&self) -> Option<crate::ClockTime> {
unsafe { unsafe {
let mut running_time = mem::MaybeUninit::uninit(); let mut running_time = mem::MaybeUninit::uninit();
@ -990,6 +1029,7 @@ impl<'a> AsyncDone<'a> {
declare_concrete_message!(RequestState); declare_concrete_message!(RequestState);
impl<'a> RequestState<'a> { impl<'a> RequestState<'a> {
#[doc(alias = "gst_message_new_request_state")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(state: crate::State) -> Message { pub fn new(state: crate::State) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1002,6 +1042,7 @@ impl<'a> RequestState<'a> {
} }
#[doc(alias = "get_requested_state")] #[doc(alias = "get_requested_state")]
#[doc(alias = "gst_message_parse_request_state")]
pub fn requested_state(&self) -> crate::State { pub fn requested_state(&self) -> crate::State {
unsafe { unsafe {
let mut state = mem::MaybeUninit::uninit(); let mut state = mem::MaybeUninit::uninit();
@ -1015,6 +1056,7 @@ impl<'a> RequestState<'a> {
declare_concrete_message!(StepStart); declare_concrete_message!(StepStart);
impl<'a> StepStart<'a> { impl<'a> StepStart<'a> {
#[doc(alias = "gst_message_new_step_start")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new<V: Into<GenericFormattedValue>>( pub fn new<V: Into<GenericFormattedValue>>(
active: bool, active: bool,
@ -1038,6 +1080,7 @@ impl<'a> StepStart<'a> {
StepStartBuilder::new(active, amount.into(), rate, flush, intermediate) StepStartBuilder::new(active, amount.into(), rate, flush, intermediate)
} }
#[doc(alias = "gst_message_parse_step_start")]
pub fn get(&self) -> (bool, GenericFormattedValue, f64, bool, bool) { pub fn get(&self) -> (bool, GenericFormattedValue, f64, bool, bool) {
unsafe { unsafe {
let mut active = mem::MaybeUninit::uninit(); let mut active = mem::MaybeUninit::uninit();
@ -1073,6 +1116,7 @@ impl<'a> StepStart<'a> {
declare_concrete_message!(Qos); declare_concrete_message!(Qos);
impl<'a> Qos<'a> { impl<'a> Qos<'a> {
#[doc(alias = "gst_message_new_qos")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new( pub fn new(
live: bool, live: bool,
@ -1095,6 +1139,7 @@ impl<'a> Qos<'a> {
QosBuilder::new(live) QosBuilder::new(live)
} }
#[doc(alias = "gst_message_parse_qos")]
pub fn get( pub fn get(
&self, &self,
) -> ( ) -> (
@ -1184,6 +1229,7 @@ impl<'a> Qos<'a> {
declare_concrete_message!(Progress); declare_concrete_message!(Progress);
impl<'a> Progress<'a> { impl<'a> Progress<'a> {
#[doc(alias = "gst_message_new_progress")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(type_: crate::ProgressType, code: &'a str, text: &'a str) -> Message { pub fn new(type_: crate::ProgressType, code: &'a str, text: &'a str) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1199,6 +1245,7 @@ impl<'a> Progress<'a> {
ProgressBuilder::new(type_, code, text) ProgressBuilder::new(type_, code, text)
} }
#[doc(alias = "gst_message_parse_progress")]
pub fn get(&self) -> (crate::ProgressType, &'a str, &'a str) { pub fn get(&self) -> (crate::ProgressType, &'a str, &'a str) {
unsafe { unsafe {
let mut type_ = mem::MaybeUninit::uninit(); let mut type_ = mem::MaybeUninit::uninit();
@ -1224,6 +1271,7 @@ declare_concrete_message!(Toc);
impl<'a> Toc<'a> { impl<'a> Toc<'a> {
// FIXME could use false for updated as default // FIXME could use false for updated as default
// Even better: use an enum for updated so that it is more explicit than true / false // Even better: use an enum for updated so that it is more explicit than true / false
#[doc(alias = "gst_message_new_toc")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(toc: &crate::Toc, updated: bool) -> Message { pub fn new(toc: &crate::Toc, updated: bool) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1249,6 +1297,7 @@ impl<'a> Toc<'a> {
declare_concrete_message!(ResetTime); declare_concrete_message!(ResetTime);
impl<'a> ResetTime<'a> { impl<'a> ResetTime<'a> {
#[doc(alias = "gst_message_new_reset_time")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(running_time: crate::ClockTime) -> Message { pub fn new(running_time: crate::ClockTime) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1261,6 +1310,7 @@ impl<'a> ResetTime<'a> {
} }
#[doc(alias = "get_running_time")] #[doc(alias = "get_running_time")]
#[doc(alias = "gst_message_parse_reset_time")]
pub fn running_time(&self) -> crate::ClockTime { pub fn running_time(&self) -> crate::ClockTime {
unsafe { unsafe {
let mut running_time = mem::MaybeUninit::uninit(); let mut running_time = mem::MaybeUninit::uninit();
@ -1274,6 +1324,7 @@ impl<'a> ResetTime<'a> {
declare_concrete_message!(StreamStart); declare_concrete_message!(StreamStart);
impl<'a> StreamStart<'a> { impl<'a> StreamStart<'a> {
#[doc(alias = "gst_message_new_stream_start")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new() -> Message { pub fn new() -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1310,6 +1361,7 @@ impl<'a> StreamStart<'a> {
declare_concrete_message!(NeedContext); declare_concrete_message!(NeedContext);
impl<'a> NeedContext<'a> { impl<'a> NeedContext<'a> {
#[doc(alias = "gst_message_new_need_context")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(context_type: &str) -> Message { pub fn new(context_type: &str) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1336,6 +1388,7 @@ impl<'a> NeedContext<'a> {
declare_concrete_message!(HaveContext); declare_concrete_message!(HaveContext);
impl<'a> HaveContext<'a> { impl<'a> HaveContext<'a> {
#[doc(alias = "gst_message_new_have_context")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(context: crate::Context) -> Message { pub fn new(context: crate::Context) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1360,6 +1413,7 @@ impl<'a> HaveContext<'a> {
declare_concrete_message!(DeviceAdded); declare_concrete_message!(DeviceAdded);
impl<'a> DeviceAdded<'a> { impl<'a> DeviceAdded<'a> {
#[doc(alias = "gst_message_new_device_added")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(device: &crate::Device) -> Message { pub fn new(device: &crate::Device) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1386,6 +1440,7 @@ impl<'a> DeviceAdded<'a> {
declare_concrete_message!(DeviceRemoved); declare_concrete_message!(DeviceRemoved);
impl<'a> DeviceRemoved<'a> { impl<'a> DeviceRemoved<'a> {
#[doc(alias = "gst_message_new_device_removed")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(device: &crate::Device) -> Message { pub fn new(device: &crate::Device) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1416,6 +1471,7 @@ declare_concrete_message!(PropertyNotify);
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
impl<'a> PropertyNotify<'a> { impl<'a> PropertyNotify<'a> {
#[doc(alias = "gst_message_new_property_notify")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(property_name: &str) -> Message { pub fn new(property_name: &str) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1427,6 +1483,7 @@ impl<'a> PropertyNotify<'a> {
PropertyNotifyBuilder::new(property_name) PropertyNotifyBuilder::new(property_name)
} }
#[doc(alias = "gst_message_parse_property_notify")]
pub fn get(&self) -> (Object, &str, Option<&'a glib::Value>) { pub fn get(&self) -> (Object, &str, Option<&'a glib::Value>) {
unsafe { unsafe {
let mut object = ptr::null_mut(); let mut object = ptr::null_mut();
@ -1459,6 +1516,7 @@ declare_concrete_message!(StreamCollection);
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
impl<'a> StreamCollection<'a> { impl<'a> StreamCollection<'a> {
#[doc(alias = "gst_message_new_stream_collection")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(collection: &crate::StreamCollection) -> Message { pub fn new(collection: &crate::StreamCollection) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1489,6 +1547,7 @@ declare_concrete_message!(StreamsSelected);
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
impl<'a> StreamsSelected<'a> { impl<'a> StreamsSelected<'a> {
#[doc(alias = "gst_message_new_streams_selected")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(collection: &crate::StreamCollection) -> Message { pub fn new(collection: &crate::StreamCollection) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1501,6 +1560,7 @@ impl<'a> StreamsSelected<'a> {
} }
#[doc(alias = "get_stream_collection")] #[doc(alias = "get_stream_collection")]
#[doc(alias = "gst_message_parse_streams_selected")]
pub fn stream_collection(&self) -> crate::StreamCollection { pub fn stream_collection(&self) -> crate::StreamCollection {
unsafe { unsafe {
let mut collection = ptr::null_mut(); let mut collection = ptr::null_mut();
@ -1536,6 +1596,7 @@ declare_concrete_message!(Redirect);
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))]
impl<'a> Redirect<'a> { impl<'a> Redirect<'a> {
#[doc(alias = "gst_message_new_redirect")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(location: &str) -> Message { pub fn new(location: &str) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1549,6 +1610,7 @@ impl<'a> Redirect<'a> {
#[doc(alias = "get_entries")] #[doc(alias = "get_entries")]
#[doc(alias = "gst_message_get_num_redirect_entries")] #[doc(alias = "gst_message_get_num_redirect_entries")]
#[doc(alias = "gst_message_parse_redirect_entry")]
pub fn entries(&self) -> Vec<(&str, Option<TagList>, Option<&StructureRef>)> { pub fn entries(&self) -> Vec<(&str, Option<TagList>, Option<&StructureRef>)> {
unsafe { unsafe {
let n = ffi::gst_message_get_num_redirect_entries(self.as_mut_ptr()); let n = ffi::gst_message_get_num_redirect_entries(self.as_mut_ptr());
@ -1590,6 +1652,7 @@ declare_concrete_message!(DeviceChanged);
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
impl<'a> DeviceChanged<'a> { impl<'a> DeviceChanged<'a> {
#[doc(alias = "gst_message_new_device_changed")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(device: &'a crate::Device, changed_device: &'a crate::Device) -> Message { pub fn new(device: &'a crate::Device, changed_device: &'a crate::Device) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1628,6 +1691,7 @@ declare_concrete_message!(InstantRateRequest);
#[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
impl<'a> InstantRateRequest<'a> { impl<'a> InstantRateRequest<'a> {
#[doc(alias = "gst_message_new_instant_rate_request")]
#[allow(clippy::new_ret_no_self)] #[allow(clippy::new_ret_no_self)]
pub fn new(rate_multiplier: f64) -> Message { pub fn new(rate_multiplier: f64) -> Message {
skip_assert_initialized!(); skip_assert_initialized!();
@ -1710,6 +1774,7 @@ macro_rules! message_builder_generic_impl {
} }
} }
#[doc(alias = "gst_message_set_seqnum")]
#[allow(clippy::needless_update)] #[allow(clippy::needless_update)]
pub fn seqnum(self, seqnum: Seqnum) -> Self { pub fn seqnum(self, seqnum: Seqnum) -> Self {
Self { Self {

40
gstreamer/src/query.rs
View file

@ -31,6 +31,7 @@ impl QueryRef {
} }
#[doc(alias = "get_mut_structure")] #[doc(alias = "get_mut_structure")]
#[doc(alias = "gst_query_writable_structure")]
pub fn structure_mut(&mut self) -> &mut StructureRef { pub fn structure_mut(&mut self) -> &mut StructureRef {
unsafe { unsafe {
let structure = ffi::gst_query_writable_structure(self.as_mut_ptr()); let structure = ffi::gst_query_writable_structure(self.as_mut_ptr());
@ -38,14 +39,17 @@ impl QueryRef {
} }
} }
#[doc(alias = "GST_QUERY_IS_DOWNSTREAM")]
pub fn is_downstream(&self) -> bool { pub fn is_downstream(&self) -> bool {
unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_DOWNSTREAM != 0 } unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_DOWNSTREAM != 0 }
} }
#[doc(alias = "GST_QUERY_IS_UPSTREAM")]
pub fn is_upstream(&self) -> bool { pub fn is_upstream(&self) -> bool {
unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_UPSTREAM != 0 } unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_UPSTREAM != 0 }
} }
#[doc(alias = "GST_QUERY_IS_SERIALIZED")]
pub fn is_serialized(&self) -> bool { pub fn is_serialized(&self) -> bool {
unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_SERIALIZED != 0 } unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_SERIALIZED != 0 }
} }
@ -229,6 +233,7 @@ impl Position<Query> {
impl<T: AsPtr> Position<T> { impl<T: AsPtr> Position<T> {
#[doc(alias = "get_result")] #[doc(alias = "get_result")]
#[doc(alias = "gst_query_parse_position")]
pub fn result(&self) -> GenericFormattedValue { pub fn result(&self) -> GenericFormattedValue {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -241,6 +246,7 @@ impl<T: AsPtr> Position<T> {
} }
#[doc(alias = "get_format")] #[doc(alias = "get_format")]
#[doc(alias = "gst_query_parse_position")]
pub fn format(&self) -> crate::Format { pub fn format(&self) -> crate::Format {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -274,6 +280,7 @@ impl Duration<Query> {
impl<T: AsPtr> Duration<T> { impl<T: AsPtr> Duration<T> {
#[doc(alias = "get_result")] #[doc(alias = "get_result")]
#[doc(alias = "gst_query_parse_duration")]
pub fn result(&self) -> GenericFormattedValue { pub fn result(&self) -> GenericFormattedValue {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -286,6 +293,7 @@ impl<T: AsPtr> Duration<T> {
} }
#[doc(alias = "get_format")] #[doc(alias = "get_format")]
#[doc(alias = "gst_query_parse_duration")]
pub fn format(&self) -> crate::Format { pub fn format(&self) -> crate::Format {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -325,6 +333,7 @@ impl Default for Latency<Query> {
impl<T: AsPtr> Latency<T> { impl<T: AsPtr> Latency<T> {
#[doc(alias = "get_result")] #[doc(alias = "get_result")]
#[doc(alias = "gst_query_parse_latency")]
pub fn result(&self) -> (bool, crate::ClockTime, Option<crate::ClockTime>) { pub fn result(&self) -> (bool, crate::ClockTime, Option<crate::ClockTime>) {
unsafe { unsafe {
let mut live = mem::MaybeUninit::uninit(); let mut live = mem::MaybeUninit::uninit();
@ -377,6 +386,7 @@ impl Seeking<Query> {
impl<T: AsPtr> Seeking<T> { impl<T: AsPtr> Seeking<T> {
#[doc(alias = "get_result")] #[doc(alias = "get_result")]
#[doc(alias = "gst_query_parse_seeking")]
pub fn result(&self) -> (bool, GenericFormattedValue, GenericFormattedValue) { pub fn result(&self) -> (bool, GenericFormattedValue, GenericFormattedValue) {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -400,6 +410,7 @@ impl<T: AsPtr> Seeking<T> {
} }
#[doc(alias = "get_format")] #[doc(alias = "get_format")]
#[doc(alias = "gst_query_parse_seeking")]
pub fn format(&self) -> crate::Format { pub fn format(&self) -> crate::Format {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -448,6 +459,7 @@ impl Segment<Query> {
impl<T: AsPtr> Segment<T> { impl<T: AsPtr> Segment<T> {
#[doc(alias = "get_result")] #[doc(alias = "get_result")]
#[doc(alias = "gst_query_parse_segment")]
pub fn result(&self) -> (f64, GenericFormattedValue, GenericFormattedValue) { pub fn result(&self) -> (f64, GenericFormattedValue, GenericFormattedValue) {
unsafe { unsafe {
let mut rate = mem::MaybeUninit::uninit(); let mut rate = mem::MaybeUninit::uninit();
@ -471,6 +483,7 @@ impl<T: AsPtr> Segment<T> {
} }
#[doc(alias = "get_format")] #[doc(alias = "get_format")]
#[doc(alias = "gst_query_parse_segment")]
pub fn format(&self) -> crate::Format { pub fn format(&self) -> crate::Format {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -525,6 +538,7 @@ impl Convert<Query> {
impl<T: AsPtr> Convert<T> { impl<T: AsPtr> Convert<T> {
#[doc(alias = "get_result")] #[doc(alias = "get_result")]
#[doc(alias = "gst_query_parse_convert")]
pub fn result(&self) -> (GenericFormattedValue, GenericFormattedValue) { pub fn result(&self) -> (GenericFormattedValue, GenericFormattedValue) {
unsafe { unsafe {
let mut src_fmt = mem::MaybeUninit::uninit(); let mut src_fmt = mem::MaybeUninit::uninit();
@ -546,6 +560,7 @@ impl<T: AsPtr> Convert<T> {
} }
} }
#[doc(alias = "gst_query_parse_convert")]
pub fn get(&self) -> (GenericFormattedValue, crate::Format) { pub fn get(&self) -> (GenericFormattedValue, crate::Format) {
unsafe { unsafe {
let mut src_fmt = mem::MaybeUninit::uninit(); let mut src_fmt = mem::MaybeUninit::uninit();
@ -602,6 +617,8 @@ impl Default for Formats<Query> {
impl<T: AsPtr> Formats<T> { impl<T: AsPtr> Formats<T> {
#[doc(alias = "get_result")] #[doc(alias = "get_result")]
#[doc(alias = "gst_query_parse_n_formats")]
#[doc(alias = "gst_query_parse_nth_format")]
pub fn result(&self) -> Vec<crate::Format> { pub fn result(&self) -> Vec<crate::Format> {
unsafe { unsafe {
let mut n = mem::MaybeUninit::uninit(); let mut n = mem::MaybeUninit::uninit();
@ -621,6 +638,7 @@ impl<T: AsPtr> Formats<T> {
} }
impl<T: AsMutPtr> Formats<T> { impl<T: AsMutPtr> Formats<T> {
#[doc(alias = "gst_query_set_formats")]
#[doc(alias = "gst_query_set_formatsv")] #[doc(alias = "gst_query_set_formatsv")]
pub fn set(&mut self, formats: &[crate::Format]) { pub fn set(&mut self, formats: &[crate::Format]) {
unsafe { unsafe {
@ -645,6 +663,7 @@ impl Buffering<Query> {
impl<T: AsPtr> Buffering<T> { impl<T: AsPtr> Buffering<T> {
#[doc(alias = "get_format")] #[doc(alias = "get_format")]
#[doc(alias = "gst_query_parse_buffering_range")]
pub fn format(&self) -> crate::Format { pub fn format(&self) -> crate::Format {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -730,6 +749,7 @@ impl<T: AsPtr> Buffering<T> {
#[doc(alias = "get_ranges")] #[doc(alias = "get_ranges")]
#[doc(alias = "gst_query_get_n_buffering_ranges")] #[doc(alias = "gst_query_get_n_buffering_ranges")]
#[doc(alias = "gst_query_parse_nth_buffering_range")]
pub fn ranges(&self) -> Vec<(GenericFormattedValue, GenericFormattedValue)> { pub fn ranges(&self) -> Vec<(GenericFormattedValue, GenericFormattedValue)> {
unsafe { unsafe {
let mut fmt = mem::MaybeUninit::uninit(); let mut fmt = mem::MaybeUninit::uninit();
@ -767,12 +787,14 @@ impl<T: AsPtr> Buffering<T> {
} }
impl<T: AsMutPtr> Buffering<T> { impl<T: AsMutPtr> Buffering<T> {
#[doc(alias = "gst_query_set_buffering_percent")]
pub fn set_percent(&mut self, busy: bool, percent: i32) { pub fn set_percent(&mut self, busy: bool, percent: i32) {
unsafe { unsafe {
ffi::gst_query_set_buffering_percent(self.0.as_mut_ptr(), busy.into_glib(), percent); ffi::gst_query_set_buffering_percent(self.0.as_mut_ptr(), busy.into_glib(), percent);
} }
} }
#[doc(alias = "gst_query_set_buffering_range")]
pub fn set_range<V: Into<GenericFormattedValue>>( pub fn set_range<V: Into<GenericFormattedValue>>(
&mut self, &mut self,
start: V, start: V,
@ -796,6 +818,7 @@ impl<T: AsMutPtr> Buffering<T> {
} }
} }
#[doc(alias = "gst_query_set_buffering_stats")]
pub fn set_stats( pub fn set_stats(
&mut self, &mut self,
mode: crate::BufferingMode, mode: crate::BufferingMode,
@ -815,6 +838,7 @@ impl<T: AsMutPtr> Buffering<T> {
} }
} }
#[doc(alias = "gst_query_add_buffering_range")]
pub fn add_buffering_ranges<V: Into<GenericFormattedValue> + Copy>( pub fn add_buffering_ranges<V: Into<GenericFormattedValue> + Copy>(
&mut self, &mut self,
ranges: &[(V, V)], ranges: &[(V, V)],
@ -900,6 +924,8 @@ impl<T: AsMutPtr> Uri<T> {
} }
} }
#[doc(alias = "gst_query_set_uri_redirection")]
#[doc(alias = "gst_query_set_uri_redirection_permanent")]
pub fn set_redirection(&mut self, uri: &str, permanent: bool) { pub fn set_redirection(&mut self, uri: &str, permanent: bool) {
unsafe { unsafe {
ffi::gst_query_set_uri_redirection(self.0.as_mut_ptr(), uri.to_glib_none().0); ffi::gst_query_set_uri_redirection(self.0.as_mut_ptr(), uri.to_glib_none().0);
@ -926,6 +952,7 @@ impl Allocation<Query> {
} }
impl<T: AsPtr> Allocation<T> { impl<T: AsPtr> Allocation<T> {
#[doc(alias = "gst_query_parse_allocation")]
pub fn get(&self) -> (&crate::CapsRef, bool) { pub fn get(&self) -> (&crate::CapsRef, bool) {
unsafe { unsafe {
let mut caps = ptr::null_mut(); let mut caps = ptr::null_mut();
@ -939,6 +966,7 @@ impl<T: AsPtr> Allocation<T> {
} }
} }
#[doc(alias = "gst_query_parse_allocation")]
pub fn get_owned(&self) -> (crate::Caps, bool) { pub fn get_owned(&self) -> (crate::Caps, bool) {
unsafe { unsafe {
let (caps, need_pool) = self.get(); let (caps, need_pool) = self.get();
@ -948,6 +976,7 @@ impl<T: AsPtr> Allocation<T> {
#[doc(alias = "gst_allocation_params")] #[doc(alias = "gst_allocation_params")]
#[doc(alias = "gst_query_get_n_allocation_params")] #[doc(alias = "gst_query_get_n_allocation_params")]
#[doc(alias = "gst_query_parse_nth_allocation_param")]
pub fn allocation_params(&self) -> Vec<(Option<crate::Allocator>, crate::AllocationParams)> { pub fn allocation_params(&self) -> Vec<(Option<crate::Allocator>, crate::AllocationParams)> {
unsafe { unsafe {
let n = ffi::gst_query_get_n_allocation_params(self.0.as_ptr()); let n = ffi::gst_query_get_n_allocation_params(self.0.as_ptr());
@ -970,6 +999,7 @@ impl<T: AsPtr> Allocation<T> {
#[doc(alias = "get_allocation_pools")] #[doc(alias = "get_allocation_pools")]
#[doc(alias = "gst_query_get_n_allocation_pools")] #[doc(alias = "gst_query_get_n_allocation_pools")]
#[doc(alias = "gst_query_parse_nth_allocation_pool")]
pub fn allocation_pools(&self) -> Vec<(Option<crate::BufferPool>, u32, u32, u32)> { pub fn allocation_pools(&self) -> Vec<(Option<crate::BufferPool>, u32, u32, u32)> {
unsafe { unsafe {
let n = ffi::gst_query_get_n_allocation_pools(self.0.as_ptr()); let n = ffi::gst_query_get_n_allocation_pools(self.0.as_ptr());
@ -1002,6 +1032,7 @@ impl<T: AsPtr> Allocation<T> {
#[doc(alias = "get_allocation_metas")] #[doc(alias = "get_allocation_metas")]
#[doc(alias = "gst_query_get_n_allocation_metas")] #[doc(alias = "gst_query_get_n_allocation_metas")]
#[doc(alias = "gst_query_parse_nth_allocation_meta")]
pub fn allocation_metas(&self) -> Vec<(glib::Type, Option<&crate::StructureRef>)> { pub fn allocation_metas(&self) -> Vec<(glib::Type, Option<&crate::StructureRef>)> {
unsafe { unsafe {
let n = ffi::gst_query_get_n_allocation_metas(self.0.as_ptr()); let n = ffi::gst_query_get_n_allocation_metas(self.0.as_ptr());
@ -1226,6 +1257,7 @@ impl<T: AsPtr> Scheduling<T> {
} }
#[doc(alias = "get_result")] #[doc(alias = "get_result")]
#[doc(alias = "gst_query_parse_scheduling")]
pub fn result(&self) -> (crate::SchedulingFlags, i32, i32, i32) { pub fn result(&self) -> (crate::SchedulingFlags, i32, i32, i32) {
unsafe { unsafe {
let mut flags = mem::MaybeUninit::uninit(); let mut flags = mem::MaybeUninit::uninit();
@ -1252,6 +1284,7 @@ impl<T: AsPtr> Scheduling<T> {
} }
impl<T: AsMutPtr> Scheduling<T> { impl<T: AsMutPtr> Scheduling<T> {
#[doc(alias = "gst_query_add_scheduling_mode")]
pub fn add_scheduling_modes(&mut self, modes: &[crate::PadMode]) { pub fn add_scheduling_modes(&mut self, modes: &[crate::PadMode]) {
unsafe { unsafe {
for mode in modes { for mode in modes {
@ -1299,6 +1332,7 @@ impl<T: AsPtr> AcceptCaps<T> {
} }
#[doc(alias = "get_caps_owned")] #[doc(alias = "get_caps_owned")]
#[doc(alias = "gst_query_parse_accept_caps")]
pub fn caps_owned(&self) -> crate::Caps { pub fn caps_owned(&self) -> crate::Caps {
unsafe { from_glib_none(self.caps().as_ptr()) } unsafe { from_glib_none(self.caps().as_ptr()) }
} }
@ -1315,6 +1349,7 @@ impl<T: AsPtr> AcceptCaps<T> {
} }
impl<T: AsMutPtr> AcceptCaps<T> { impl<T: AsMutPtr> AcceptCaps<T> {
#[doc(alias = "gst_query_set_accept_caps_result")]
pub fn set_result(&mut self, accepted: bool) { pub fn set_result(&mut self, accepted: bool) {
unsafe { unsafe {
ffi::gst_query_set_accept_caps_result(self.0.as_mut_ptr(), accepted.into_glib()); ffi::gst_query_set_accept_caps_result(self.0.as_mut_ptr(), accepted.into_glib());
@ -1337,6 +1372,7 @@ impl Caps<Query> {
impl<T: AsPtr> Caps<T> { impl<T: AsPtr> Caps<T> {
#[doc(alias = "get_filter")] #[doc(alias = "get_filter")]
#[doc(alias = "gst_query_parse_caps")]
pub fn filter(&self) -> Option<&crate::CapsRef> { pub fn filter(&self) -> Option<&crate::CapsRef> {
unsafe { unsafe {
let mut caps = ptr::null_mut(); let mut caps = ptr::null_mut();
@ -1350,6 +1386,7 @@ impl<T: AsPtr> Caps<T> {
} }
#[doc(alias = "get_filter_owned")] #[doc(alias = "get_filter_owned")]
#[doc(alias = "gst_query_parse_caps")]
pub fn filter_owned(&self) -> Option<crate::Caps> { pub fn filter_owned(&self) -> Option<crate::Caps> {
unsafe { self.filter().map(|caps| from_glib_none(caps.as_ptr())) } unsafe { self.filter().map(|caps| from_glib_none(caps.as_ptr())) }
} }
@ -1369,12 +1406,14 @@ impl<T: AsPtr> Caps<T> {
} }
#[doc(alias = "get_result_owned")] #[doc(alias = "get_result_owned")]
#[doc(alias = "gst_query_parse_caps_result")]
pub fn result_owned(&self) -> Option<crate::Caps> { pub fn result_owned(&self) -> Option<crate::Caps> {
unsafe { self.result().map(|caps| from_glib_none(caps.as_ptr())) } unsafe { self.result().map(|caps| from_glib_none(caps.as_ptr())) }
} }
} }
impl<T: AsMutPtr> Caps<T> { impl<T: AsMutPtr> Caps<T> {
#[doc(alias = "gst_query_set_caps_result")]
pub fn set_result(&mut self, caps: &crate::Caps) { pub fn set_result(&mut self, caps: &crate::Caps) {
unsafe { unsafe {
ffi::gst_query_set_caps_result(self.0.as_mut_ptr(), caps.as_mut_ptr()); ffi::gst_query_set_caps_result(self.0.as_mut_ptr(), caps.as_mut_ptr());
@ -1426,6 +1465,7 @@ impl<T: AsPtr> Context<T> {
} }
#[doc(alias = "get_context_owned")] #[doc(alias = "get_context_owned")]
#[doc(alias = "gst_query_parse_context")]
pub fn context_owned(&self) -> Option<crate::Context> { pub fn context_owned(&self) -> Option<crate::Context> {
unsafe { unsafe {
self.context() self.context()