1 // Copyright (C) 2016-2017 Sebastian Dröge <sebastian@centricular.com> 2 // 3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or 4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license 5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your 6 // option. This file may not be copied, modified, or distributed 7 // except according to those terms. 8 9 use gst_sys; 10 use miniobject::*; 11 use structure::*; 12 use GenericFormattedValue; 13 use GroupId; 14 use GstObjectExt; 15 use MessageType; 16 use Object; 17 use Seqnum; 18 use TagList; 19 20 use std::ffi::CStr; 21 use std::fmt; 22 use std::mem; 23 use std::ops::Deref; 24 use std::ptr; 25 26 use glib; 27 use glib::translate::{from_glib, from_glib_full, from_glib_none, mut_override, ToGlib, ToGlibPtr}; 28 use glib::value::ToSendValue; 29 use glib::Cast; 30 use glib::IsA; 31 32 gst_define_mini_object_wrapper!(Message, MessageRef, gst_sys::GstMessage, [Debug,], || { 33 gst_sys::gst_message_get_type() 34 }); 35 36 impl MessageRef { get_src(&self) -> Option<Object>37 pub fn get_src(&self) -> Option<Object> { 38 unsafe { from_glib_none((*self.as_ptr()).src) } 39 } 40 get_seqnum(&self) -> Seqnum41 pub fn get_seqnum(&self) -> Seqnum { 42 unsafe { from_glib(gst_sys::gst_message_get_seqnum(self.as_mut_ptr())) } 43 } 44 get_structure(&self) -> Option<&StructureRef>45 pub fn get_structure(&self) -> Option<&StructureRef> { 46 unsafe { 47 let structure = gst_sys::gst_message_get_structure(self.as_mut_ptr()); 48 if structure.is_null() { 49 None 50 } else { 51 Some(StructureRef::from_glib_borrow(structure)) 52 } 53 } 54 } 55 view(&self) -> MessageView56 pub fn view(&self) -> MessageView { 57 let type_ = unsafe { (*self.as_ptr()).type_ }; 58 59 match type_ { 60 gst_sys::GST_MESSAGE_EOS => MessageView::Eos(Eos(self)), 61 gst_sys::GST_MESSAGE_ERROR => MessageView::Error(Error(self)), 62 gst_sys::GST_MESSAGE_WARNING => MessageView::Warning(Warning(self)), 63 gst_sys::GST_MESSAGE_INFO => MessageView::Info(Info(self)), 64 gst_sys::GST_MESSAGE_TAG => MessageView::Tag(Tag(self)), 65 gst_sys::GST_MESSAGE_BUFFERING => MessageView::Buffering(Buffering(self)), 66 gst_sys::GST_MESSAGE_STATE_CHANGED => MessageView::StateChanged(StateChanged(self)), 67 gst_sys::GST_MESSAGE_STATE_DIRTY => MessageView::StateDirty(StateDirty(self)), 68 gst_sys::GST_MESSAGE_STEP_DONE => MessageView::StepDone(StepDone(self)), 69 gst_sys::GST_MESSAGE_CLOCK_PROVIDE => MessageView::ClockProvide(ClockProvide(self)), 70 gst_sys::GST_MESSAGE_CLOCK_LOST => MessageView::ClockLost(ClockLost(self)), 71 gst_sys::GST_MESSAGE_NEW_CLOCK => MessageView::NewClock(NewClock(self)), 72 gst_sys::GST_MESSAGE_STRUCTURE_CHANGE => { 73 MessageView::StructureChange(StructureChange(self)) 74 } 75 gst_sys::GST_MESSAGE_STREAM_STATUS => MessageView::StreamStatus(StreamStatus(self)), 76 gst_sys::GST_MESSAGE_APPLICATION => MessageView::Application(Application(self)), 77 gst_sys::GST_MESSAGE_ELEMENT => MessageView::Element(Element(self)), 78 gst_sys::GST_MESSAGE_SEGMENT_START => MessageView::SegmentStart(SegmentStart(self)), 79 gst_sys::GST_MESSAGE_SEGMENT_DONE => MessageView::SegmentDone(SegmentDone(self)), 80 gst_sys::GST_MESSAGE_DURATION_CHANGED => { 81 MessageView::DurationChanged(DurationChanged(self)) 82 } 83 gst_sys::GST_MESSAGE_LATENCY => MessageView::Latency(Latency(self)), 84 gst_sys::GST_MESSAGE_ASYNC_START => MessageView::AsyncStart(AsyncStart(self)), 85 gst_sys::GST_MESSAGE_ASYNC_DONE => MessageView::AsyncDone(AsyncDone(self)), 86 gst_sys::GST_MESSAGE_REQUEST_STATE => MessageView::RequestState(RequestState(self)), 87 gst_sys::GST_MESSAGE_STEP_START => MessageView::StepStart(StepStart(self)), 88 gst_sys::GST_MESSAGE_QOS => MessageView::Qos(Qos(self)), 89 gst_sys::GST_MESSAGE_PROGRESS => MessageView::Progress(Progress(self)), 90 gst_sys::GST_MESSAGE_TOC => MessageView::Toc(Toc(self)), 91 gst_sys::GST_MESSAGE_RESET_TIME => MessageView::ResetTime(ResetTime(self)), 92 gst_sys::GST_MESSAGE_STREAM_START => MessageView::StreamStart(StreamStart(self)), 93 gst_sys::GST_MESSAGE_NEED_CONTEXT => MessageView::NeedContext(NeedContext(self)), 94 gst_sys::GST_MESSAGE_HAVE_CONTEXT => MessageView::HaveContext(HaveContext(self)), 95 gst_sys::GST_MESSAGE_DEVICE_ADDED => MessageView::DeviceAdded(DeviceAdded(self)), 96 gst_sys::GST_MESSAGE_DEVICE_REMOVED => MessageView::DeviceRemoved(DeviceRemoved(self)), 97 gst_sys::GST_MESSAGE_PROPERTY_NOTIFY => { 98 MessageView::PropertyNotify(PropertyNotify(self)) 99 } 100 gst_sys::GST_MESSAGE_STREAM_COLLECTION => { 101 MessageView::StreamCollection(StreamCollection(self)) 102 } 103 gst_sys::GST_MESSAGE_STREAMS_SELECTED => { 104 MessageView::StreamsSelected(StreamsSelected(self)) 105 } 106 gst_sys::GST_MESSAGE_DEVICE_CHANGED => MessageView::DeviceChanged(DeviceChanged(self)), 107 _ => MessageView::Other, 108 } 109 } 110 get_type(&self) -> MessageType111 pub fn get_type(&self) -> MessageType { 112 unsafe { from_glib((*self.as_ptr()).type_) } 113 } 114 } 115 116 impl Message { new_eos<'a>() -> EosBuilder<'a>117 pub fn new_eos<'a>() -> EosBuilder<'a> { 118 assert_initialized_main_thread!(); 119 EosBuilder::new() 120 } 121 new_error<T: MessageErrorDomain>(error: T, message: &str) -> ErrorBuilder<T>122 pub fn new_error<T: MessageErrorDomain>(error: T, message: &str) -> ErrorBuilder<T> { 123 assert_initialized_main_thread!(); 124 ErrorBuilder::new(error, message) 125 } 126 new_warning<T: MessageErrorDomain>(error: T, message: &str) -> WarningBuilder<T>127 pub fn new_warning<T: MessageErrorDomain>(error: T, message: &str) -> WarningBuilder<T> { 128 assert_initialized_main_thread!(); 129 WarningBuilder::new(error, message) 130 } 131 new_info<T: MessageErrorDomain>(error: T, message: &str) -> InfoBuilder<T>132 pub fn new_info<T: MessageErrorDomain>(error: T, message: &str) -> InfoBuilder<T> { 133 assert_initialized_main_thread!(); 134 InfoBuilder::new(error, message) 135 } 136 new_tag(tags: &TagList) -> TagBuilder137 pub fn new_tag(tags: &TagList) -> TagBuilder { 138 assert_initialized_main_thread!(); 139 TagBuilder::new(tags) 140 } 141 new_buffering<'a>(percent: i32) -> BufferingBuilder<'a>142 pub fn new_buffering<'a>(percent: i32) -> BufferingBuilder<'a> { 143 assert_initialized_main_thread!(); 144 BufferingBuilder::new(percent) 145 } 146 new_state_changed<'a>( old: ::State, new: ::State, pending: ::State, ) -> StateChangedBuilder<'a>147 pub fn new_state_changed<'a>( 148 old: ::State, 149 new: ::State, 150 pending: ::State, 151 ) -> StateChangedBuilder<'a> { 152 assert_initialized_main_thread!(); 153 StateChangedBuilder::new(old, new, pending) 154 } 155 new_state_dirty<'a>() -> StateDirtyBuilder<'a>156 pub fn new_state_dirty<'a>() -> StateDirtyBuilder<'a> { 157 assert_initialized_main_thread!(); 158 StateDirtyBuilder::new() 159 } 160 new_step_done<'a, V: Into<GenericFormattedValue>>( amount: V, rate: f64, flush: bool, intermediate: bool, duration: V, eos: bool, ) -> StepDoneBuilder<'a>161 pub fn new_step_done<'a, V: Into<GenericFormattedValue>>( 162 amount: V, 163 rate: f64, 164 flush: bool, 165 intermediate: bool, 166 duration: V, 167 eos: bool, 168 ) -> StepDoneBuilder<'a> { 169 assert_initialized_main_thread!(); 170 StepDoneBuilder::new( 171 amount.into(), 172 rate, 173 flush, 174 intermediate, 175 duration.into(), 176 eos, 177 ) 178 } 179 new_clock_provide(clock: &::Clock, ready: bool) -> ClockProvideBuilder180 pub fn new_clock_provide(clock: &::Clock, ready: bool) -> ClockProvideBuilder { 181 assert_initialized_main_thread!(); 182 ClockProvideBuilder::new(clock, ready) 183 } 184 new_clock_lost(clock: &::Clock) -> ClockLostBuilder185 pub fn new_clock_lost(clock: &::Clock) -> ClockLostBuilder { 186 assert_initialized_main_thread!(); 187 ClockLostBuilder::new(clock) 188 } 189 new_new_clock(clock: &::Clock) -> NewClockBuilder190 pub fn new_new_clock(clock: &::Clock) -> NewClockBuilder { 191 assert_initialized_main_thread!(); 192 NewClockBuilder::new(clock) 193 } 194 new_structure_change( type_: ::StructureChangeType, owner: &::Element, busy: bool, ) -> StructureChangeBuilder195 pub fn new_structure_change( 196 type_: ::StructureChangeType, 197 owner: &::Element, 198 busy: bool, 199 ) -> StructureChangeBuilder { 200 assert_initialized_main_thread!(); 201 StructureChangeBuilder::new(type_, owner, busy) 202 } 203 new_stream_status(type_: ::StreamStatusType, owner: &::Element) -> StreamStatusBuilder204 pub fn new_stream_status(type_: ::StreamStatusType, owner: &::Element) -> StreamStatusBuilder { 205 assert_initialized_main_thread!(); 206 StreamStatusBuilder::new(type_, owner) 207 } 208 new_application<'a>(structure: ::Structure) -> ApplicationBuilder<'a>209 pub fn new_application<'a>(structure: ::Structure) -> ApplicationBuilder<'a> { 210 assert_initialized_main_thread!(); 211 ApplicationBuilder::new(structure) 212 } 213 new_element<'a>(structure: ::Structure) -> ElementBuilder<'a>214 pub fn new_element<'a>(structure: ::Structure) -> ElementBuilder<'a> { 215 assert_initialized_main_thread!(); 216 ElementBuilder::new(structure) 217 } 218 new_segment_start<'a, V: Into<GenericFormattedValue>>( position: V, ) -> SegmentStartBuilder<'a>219 pub fn new_segment_start<'a, V: Into<GenericFormattedValue>>( 220 position: V, 221 ) -> SegmentStartBuilder<'a> { 222 assert_initialized_main_thread!(); 223 let position = position.into(); 224 SegmentStartBuilder::new(position) 225 } 226 new_segment_done<'a, V: Into<GenericFormattedValue>>( position: V, ) -> SegmentDoneBuilder<'a>227 pub fn new_segment_done<'a, V: Into<GenericFormattedValue>>( 228 position: V, 229 ) -> SegmentDoneBuilder<'a> { 230 assert_initialized_main_thread!(); 231 let position = position.into(); 232 SegmentDoneBuilder::new(position) 233 } 234 new_duration_changed<'a>() -> DurationChangedBuilder<'a>235 pub fn new_duration_changed<'a>() -> DurationChangedBuilder<'a> { 236 assert_initialized_main_thread!(); 237 DurationChangedBuilder::new() 238 } 239 new_latency<'a>() -> LatencyBuilder<'a>240 pub fn new_latency<'a>() -> LatencyBuilder<'a> { 241 assert_initialized_main_thread!(); 242 LatencyBuilder::new() 243 } 244 new_async_start<'a>() -> AsyncStartBuilder<'a>245 pub fn new_async_start<'a>() -> AsyncStartBuilder<'a> { 246 assert_initialized_main_thread!(); 247 AsyncStartBuilder::new() 248 } 249 new_async_done<'a>(running_time: ::ClockTime) -> AsyncDoneBuilder<'a>250 pub fn new_async_done<'a>(running_time: ::ClockTime) -> AsyncDoneBuilder<'a> { 251 assert_initialized_main_thread!(); 252 AsyncDoneBuilder::new(running_time) 253 } 254 new_request_state<'a>(state: ::State) -> RequestStateBuilder<'a>255 pub fn new_request_state<'a>(state: ::State) -> RequestStateBuilder<'a> { 256 assert_initialized_main_thread!(); 257 RequestStateBuilder::new(state) 258 } 259 new_step_start<'a, V: Into<GenericFormattedValue>>( active: bool, amount: V, rate: f64, flush: bool, intermediate: bool, ) -> StepStartBuilder<'a>260 pub fn new_step_start<'a, V: Into<GenericFormattedValue>>( 261 active: bool, 262 amount: V, 263 rate: f64, 264 flush: bool, 265 intermediate: bool, 266 ) -> StepStartBuilder<'a> { 267 assert_initialized_main_thread!(); 268 StepStartBuilder::new(active, amount.into(), rate, flush, intermediate) 269 } 270 new_qos_builder<'a>( live: bool, running_time: ::ClockTime, stream_time: ::ClockTime, timestamp: ::ClockTime, duration: ::ClockTime, ) -> QosBuilder<'a>271 pub fn new_qos_builder<'a>( 272 live: bool, 273 running_time: ::ClockTime, 274 stream_time: ::ClockTime, 275 timestamp: ::ClockTime, 276 duration: ::ClockTime, 277 ) -> QosBuilder<'a> { 278 assert_initialized_main_thread!(); 279 QosBuilder::new(live, running_time, stream_time, timestamp, duration) 280 } 281 new_progress<'a>( type_: ::ProgressType, code: &'a str, text: &'a str, ) -> ProgressBuilder<'a>282 pub fn new_progress<'a>( 283 type_: ::ProgressType, 284 code: &'a str, 285 text: &'a str, 286 ) -> ProgressBuilder<'a> { 287 assert_initialized_main_thread!(); 288 ProgressBuilder::new(type_, code, text) 289 } 290 new_toc(toc: &::Toc, updated: bool) -> TocBuilder291 pub fn new_toc(toc: &::Toc, updated: bool) -> TocBuilder { 292 assert_initialized_main_thread!(); 293 TocBuilder::new(toc, updated) 294 } 295 new_reset_time<'a>(running_time: ::ClockTime) -> ResetTimeBuilder<'a>296 pub fn new_reset_time<'a>(running_time: ::ClockTime) -> ResetTimeBuilder<'a> { 297 assert_initialized_main_thread!(); 298 ResetTimeBuilder::new(running_time) 299 } 300 new_stream_start<'a>() -> StreamStartBuilder<'a>301 pub fn new_stream_start<'a>() -> StreamStartBuilder<'a> { 302 assert_initialized_main_thread!(); 303 StreamStartBuilder::new() 304 } 305 new_need_context(context_type: &str) -> NeedContextBuilder306 pub fn new_need_context(context_type: &str) -> NeedContextBuilder { 307 assert_initialized_main_thread!(); 308 NeedContextBuilder::new(context_type) 309 } 310 new_have_context<'a>(context: ::Context) -> HaveContextBuilder<'a>311 pub fn new_have_context<'a>(context: ::Context) -> HaveContextBuilder<'a> { 312 assert_initialized_main_thread!(); 313 HaveContextBuilder::new(context) 314 } 315 new_device_added(device: &::Device) -> DeviceAddedBuilder316 pub fn new_device_added(device: &::Device) -> DeviceAddedBuilder { 317 assert_initialized_main_thread!(); 318 DeviceAddedBuilder::new(device) 319 } 320 new_device_removed(device: &::Device) -> DeviceRemovedBuilder321 pub fn new_device_removed(device: &::Device) -> DeviceRemovedBuilder { 322 assert_initialized_main_thread!(); 323 DeviceRemovedBuilder::new(device) 324 } 325 326 #[cfg(any(feature = "v1_10", feature = "dox"))] new_property_notify(property_name: &str) -> PropertyNotifyBuilder327 pub fn new_property_notify(property_name: &str) -> PropertyNotifyBuilder { 328 assert_initialized_main_thread!(); 329 PropertyNotifyBuilder::new(property_name) 330 } 331 332 #[cfg(any(feature = "v1_10", feature = "dox"))] new_stream_collection(collection: &::StreamCollection) -> StreamCollectionBuilder333 pub fn new_stream_collection(collection: &::StreamCollection) -> StreamCollectionBuilder { 334 assert_initialized_main_thread!(); 335 StreamCollectionBuilder::new(collection) 336 } 337 338 #[cfg(any(feature = "v1_10", feature = "dox"))] new_streams_selected(collection: &::StreamCollection) -> StreamsSelectedBuilder339 pub fn new_streams_selected(collection: &::StreamCollection) -> StreamsSelectedBuilder { 340 assert_initialized_main_thread!(); 341 StreamsSelectedBuilder::new(collection) 342 } 343 344 #[cfg(any(feature = "v1_10", feature = "dox"))] new_redirect(location: &str) -> RedirectBuilder345 pub fn new_redirect(location: &str) -> RedirectBuilder { 346 assert_initialized_main_thread!(); 347 RedirectBuilder::new(location) 348 } 349 350 #[cfg(any(feature = "v1_16", feature = "dox"))] new_device_changed<'a>( device: &'a ::Device, changed_device: &'a ::Device, ) -> DeviceChangedBuilder<'a>351 pub fn new_device_changed<'a>( 352 device: &'a ::Device, 353 changed_device: &'a ::Device, 354 ) -> DeviceChangedBuilder<'a> { 355 assert_initialized_main_thread!(); 356 DeviceChangedBuilder::new(device, changed_device) 357 } 358 } 359 360 impl fmt::Debug for MessageRef { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result361 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 362 f.debug_struct("Message") 363 .field("ptr", unsafe { &self.as_ptr() }) 364 .field("type", &unsafe { 365 let type_ = gst_sys::gst_message_type_get_name((*self.as_ptr()).type_); 366 CStr::from_ptr(type_).to_str().unwrap() 367 }) 368 .field("seqnum", &self.get_seqnum()) 369 .field("src", &self.get_src().map(|s| s.get_name())) 370 .field("structure", &self.get_structure()) 371 .finish() 372 } 373 } 374 375 #[derive(Debug)] 376 pub enum MessageView<'a> { 377 Eos(Eos<'a>), 378 Error(Error<'a>), 379 Warning(Warning<'a>), 380 Info(Info<'a>), 381 Tag(Tag<'a>), 382 Buffering(Buffering<'a>), 383 StateChanged(StateChanged<'a>), 384 StateDirty(StateDirty<'a>), 385 StepDone(StepDone<'a>), 386 ClockProvide(ClockProvide<'a>), 387 ClockLost(ClockLost<'a>), 388 NewClock(NewClock<'a>), 389 StructureChange(StructureChange<'a>), 390 StreamStatus(StreamStatus<'a>), 391 Application(Application<'a>), 392 Element(Element<'a>), 393 SegmentStart(SegmentStart<'a>), 394 SegmentDone(SegmentDone<'a>), 395 DurationChanged(DurationChanged<'a>), 396 Latency(Latency<'a>), 397 AsyncStart(AsyncStart<'a>), 398 AsyncDone(AsyncDone<'a>), 399 RequestState(RequestState<'a>), 400 StepStart(StepStart<'a>), 401 Qos(Qos<'a>), 402 Progress(Progress<'a>), 403 Toc(Toc<'a>), 404 ResetTime(ResetTime<'a>), 405 StreamStart(StreamStart<'a>), 406 NeedContext(NeedContext<'a>), 407 HaveContext(HaveContext<'a>), 408 DeviceAdded(DeviceAdded<'a>), 409 DeviceRemoved(DeviceRemoved<'a>), 410 PropertyNotify(PropertyNotify<'a>), 411 StreamCollection(StreamCollection<'a>), 412 StreamsSelected(StreamsSelected<'a>), 413 Redirect(Redirect<'a>), 414 DeviceChanged(DeviceChanged<'a>), 415 Other, 416 __NonExhaustive, 417 } 418 419 macro_rules! declare_concrete_message( 420 ($name:ident) => { 421 #[derive(Debug)] 422 pub struct $name<'a>(&'a MessageRef); 423 424 impl<'a> Deref for $name<'a> { 425 type Target = MessageRef; 426 427 fn deref(&self) -> &Self::Target { 428 self.0 429 } 430 } 431 } 432 ); 433 434 declare_concrete_message!(Eos); 435 436 declare_concrete_message!(Error); 437 impl<'a> Error<'a> { get_error(&self) -> glib::Error438 pub fn get_error(&self) -> glib::Error { 439 unsafe { 440 let mut error = ptr::null_mut(); 441 442 gst_sys::gst_message_parse_error(self.as_mut_ptr(), &mut error, ptr::null_mut()); 443 444 from_glib_full(error) 445 } 446 } 447 get_debug(&self) -> Option<String>448 pub fn get_debug(&self) -> Option<String> { 449 unsafe { 450 let mut debug = ptr::null_mut(); 451 452 gst_sys::gst_message_parse_error(self.as_mut_ptr(), ptr::null_mut(), &mut debug); 453 454 from_glib_full(debug) 455 } 456 } 457 458 #[cfg(any(feature = "v1_10", feature = "dox"))] get_details(&self) -> Option<&StructureRef>459 pub fn get_details(&self) -> Option<&StructureRef> { 460 unsafe { 461 let mut details = ptr::null(); 462 463 gst_sys::gst_message_parse_error_details(self.as_mut_ptr(), &mut details); 464 465 if details.is_null() { 466 None 467 } else { 468 Some(StructureRef::from_glib_borrow(details)) 469 } 470 } 471 } 472 } 473 474 declare_concrete_message!(Warning); 475 impl<'a> Warning<'a> { get_error(&self) -> glib::Error476 pub fn get_error(&self) -> glib::Error { 477 unsafe { 478 let mut error = ptr::null_mut(); 479 480 gst_sys::gst_message_parse_warning(self.as_mut_ptr(), &mut error, ptr::null_mut()); 481 482 from_glib_full(error) 483 } 484 } 485 get_debug(&self) -> Option<String>486 pub fn get_debug(&self) -> Option<String> { 487 unsafe { 488 let mut debug = ptr::null_mut(); 489 490 gst_sys::gst_message_parse_warning(self.as_mut_ptr(), ptr::null_mut(), &mut debug); 491 492 from_glib_full(debug) 493 } 494 } 495 496 #[cfg(any(feature = "v1_10", feature = "dox"))] get_details(&self) -> Option<&StructureRef>497 pub fn get_details(&self) -> Option<&StructureRef> { 498 unsafe { 499 let mut details = ptr::null(); 500 501 gst_sys::gst_message_parse_error_details(self.as_mut_ptr(), &mut details); 502 503 if details.is_null() { 504 None 505 } else { 506 Some(StructureRef::from_glib_borrow(details)) 507 } 508 } 509 } 510 } 511 512 declare_concrete_message!(Info); 513 impl<'a> Info<'a> { get_error(&self) -> glib::Error514 pub fn get_error(&self) -> glib::Error { 515 unsafe { 516 let mut error = ptr::null_mut(); 517 518 gst_sys::gst_message_parse_info(self.as_mut_ptr(), &mut error, ptr::null_mut()); 519 520 from_glib_full(error) 521 } 522 } 523 get_debug(&self) -> Option<String>524 pub fn get_debug(&self) -> Option<String> { 525 unsafe { 526 let mut debug = ptr::null_mut(); 527 528 gst_sys::gst_message_parse_info(self.as_mut_ptr(), ptr::null_mut(), &mut debug); 529 530 from_glib_full(debug) 531 } 532 } 533 534 #[cfg(any(feature = "v1_10", feature = "dox"))] get_details(&self) -> Option<&StructureRef>535 pub fn get_details(&self) -> Option<&StructureRef> { 536 unsafe { 537 let mut details = ptr::null(); 538 539 gst_sys::gst_message_parse_error_details(self.as_mut_ptr(), &mut details); 540 541 if details.is_null() { 542 None 543 } else { 544 Some(StructureRef::from_glib_borrow(details)) 545 } 546 } 547 } 548 } 549 550 declare_concrete_message!(Tag); 551 impl<'a> Tag<'a> { get_tags(&self) -> TagList552 pub fn get_tags(&self) -> TagList { 553 unsafe { 554 let mut tags = ptr::null_mut(); 555 gst_sys::gst_message_parse_tag(self.as_mut_ptr(), &mut tags); 556 from_glib_full(tags) 557 } 558 } 559 } 560 561 declare_concrete_message!(Buffering); 562 impl<'a> Buffering<'a> { get_percent(&self) -> i32563 pub fn get_percent(&self) -> i32 { 564 unsafe { 565 let mut p = mem::MaybeUninit::uninit(); 566 gst_sys::gst_message_parse_buffering(self.as_mut_ptr(), p.as_mut_ptr()); 567 p.assume_init() 568 } 569 } 570 get_buffering_stats(&self) -> (::BufferingMode, i32, i32, i64)571 pub fn get_buffering_stats(&self) -> (::BufferingMode, i32, i32, i64) { 572 unsafe { 573 let mut mode = mem::MaybeUninit::uninit(); 574 let mut avg_in = mem::MaybeUninit::uninit(); 575 let mut avg_out = mem::MaybeUninit::uninit(); 576 let mut buffering_left = mem::MaybeUninit::uninit(); 577 578 gst_sys::gst_message_parse_buffering_stats( 579 self.as_mut_ptr(), 580 mode.as_mut_ptr(), 581 avg_in.as_mut_ptr(), 582 avg_out.as_mut_ptr(), 583 buffering_left.as_mut_ptr(), 584 ); 585 586 ( 587 from_glib(mode.assume_init()), 588 avg_in.assume_init(), 589 avg_out.assume_init(), 590 buffering_left.assume_init(), 591 ) 592 } 593 } 594 } 595 596 declare_concrete_message!(StateChanged); 597 impl<'a> StateChanged<'a> { get_old(&self) -> ::State598 pub fn get_old(&self) -> ::State { 599 unsafe { 600 let mut state = mem::MaybeUninit::uninit(); 601 602 gst_sys::gst_message_parse_state_changed( 603 self.as_mut_ptr(), 604 state.as_mut_ptr(), 605 ptr::null_mut(), 606 ptr::null_mut(), 607 ); 608 609 from_glib(state.assume_init()) 610 } 611 } 612 get_current(&self) -> ::State613 pub fn get_current(&self) -> ::State { 614 unsafe { 615 let mut state = mem::MaybeUninit::uninit(); 616 617 gst_sys::gst_message_parse_state_changed( 618 self.as_mut_ptr(), 619 ptr::null_mut(), 620 state.as_mut_ptr(), 621 ptr::null_mut(), 622 ); 623 624 from_glib(state.assume_init()) 625 } 626 } 627 get_pending(&self) -> ::State628 pub fn get_pending(&self) -> ::State { 629 unsafe { 630 let mut state = mem::MaybeUninit::uninit(); 631 632 gst_sys::gst_message_parse_state_changed( 633 self.as_mut_ptr(), 634 ptr::null_mut(), 635 ptr::null_mut(), 636 state.as_mut_ptr(), 637 ); 638 639 from_glib(state.assume_init()) 640 } 641 } 642 } 643 644 declare_concrete_message!(StateDirty); 645 646 declare_concrete_message!(StepDone); 647 impl<'a> StepDone<'a> { get( &self, ) -> ( GenericFormattedValue, f64, bool, bool, GenericFormattedValue, bool, )648 pub fn get( 649 &self, 650 ) -> ( 651 GenericFormattedValue, 652 f64, 653 bool, 654 bool, 655 GenericFormattedValue, 656 bool, 657 ) { 658 unsafe { 659 let mut format = mem::MaybeUninit::uninit(); 660 let mut amount = mem::MaybeUninit::uninit(); 661 let mut rate = mem::MaybeUninit::uninit(); 662 let mut flush = mem::MaybeUninit::uninit(); 663 let mut intermediate = mem::MaybeUninit::uninit(); 664 let mut duration = mem::MaybeUninit::uninit(); 665 let mut eos = mem::MaybeUninit::uninit(); 666 667 gst_sys::gst_message_parse_step_done( 668 self.as_mut_ptr(), 669 format.as_mut_ptr(), 670 amount.as_mut_ptr(), 671 rate.as_mut_ptr(), 672 flush.as_mut_ptr(), 673 intermediate.as_mut_ptr(), 674 duration.as_mut_ptr(), 675 eos.as_mut_ptr(), 676 ); 677 678 ( 679 GenericFormattedValue::new( 680 from_glib(format.assume_init()), 681 amount.assume_init() as i64, 682 ), 683 rate.assume_init(), 684 from_glib(flush.assume_init()), 685 from_glib(intermediate.assume_init()), 686 GenericFormattedValue::new( 687 from_glib(format.assume_init()), 688 duration.assume_init() as i64, 689 ), 690 from_glib(eos.assume_init()), 691 ) 692 } 693 } 694 } 695 696 declare_concrete_message!(ClockProvide); 697 impl<'a> ClockProvide<'a> { get_clock(&self) -> Option<::Clock>698 pub fn get_clock(&self) -> Option<::Clock> { 699 let mut clock = ptr::null_mut(); 700 701 unsafe { 702 gst_sys::gst_message_parse_clock_provide( 703 self.as_mut_ptr(), 704 &mut clock, 705 ptr::null_mut(), 706 ); 707 708 from_glib_none(clock) 709 } 710 } 711 get_ready(&self) -> bool712 pub fn get_ready(&self) -> bool { 713 unsafe { 714 let mut ready = mem::MaybeUninit::uninit(); 715 716 gst_sys::gst_message_parse_clock_provide( 717 self.as_mut_ptr(), 718 ptr::null_mut(), 719 ready.as_mut_ptr(), 720 ); 721 722 from_glib(ready.assume_init()) 723 } 724 } 725 } 726 727 declare_concrete_message!(ClockLost); 728 impl<'a> ClockLost<'a> { get_clock(&self) -> Option<::Clock>729 pub fn get_clock(&self) -> Option<::Clock> { 730 let mut clock = ptr::null_mut(); 731 732 unsafe { 733 gst_sys::gst_message_parse_clock_lost(self.as_mut_ptr(), &mut clock); 734 735 from_glib_none(clock) 736 } 737 } 738 } 739 740 declare_concrete_message!(NewClock); 741 impl<'a> NewClock<'a> { get_clock(&self) -> Option<::Clock>742 pub fn get_clock(&self) -> Option<::Clock> { 743 let mut clock = ptr::null_mut(); 744 745 unsafe { 746 gst_sys::gst_message_parse_new_clock(self.as_mut_ptr(), &mut clock); 747 748 from_glib_none(clock) 749 } 750 } 751 } 752 753 declare_concrete_message!(StructureChange); 754 impl<'a> StructureChange<'a> { get(&self) -> (::StructureChangeType, ::Element, bool)755 pub fn get(&self) -> (::StructureChangeType, ::Element, bool) { 756 unsafe { 757 let mut type_ = mem::MaybeUninit::uninit(); 758 let mut owner = ptr::null_mut(); 759 let mut busy = mem::MaybeUninit::uninit(); 760 761 gst_sys::gst_message_parse_structure_change( 762 self.as_mut_ptr(), 763 type_.as_mut_ptr(), 764 &mut owner, 765 busy.as_mut_ptr(), 766 ); 767 768 ( 769 from_glib(type_.assume_init()), 770 from_glib_none(owner), 771 from_glib(busy.assume_init()), 772 ) 773 } 774 } 775 } 776 777 declare_concrete_message!(StreamStatus); 778 impl<'a> StreamStatus<'a> { get(&self) -> (::StreamStatusType, ::Element)779 pub fn get(&self) -> (::StreamStatusType, ::Element) { 780 unsafe { 781 let mut type_ = mem::MaybeUninit::uninit(); 782 let mut owner = ptr::null_mut(); 783 784 gst_sys::gst_message_parse_stream_status( 785 self.as_mut_ptr(), 786 type_.as_mut_ptr(), 787 &mut owner, 788 ); 789 790 (from_glib(type_.assume_init()), from_glib_none(owner)) 791 } 792 } 793 get_stream_status_object(&self) -> Option<glib::Value>794 pub fn get_stream_status_object(&self) -> Option<glib::Value> { 795 unsafe { 796 let value = gst_sys::gst_message_get_stream_status_object(self.as_mut_ptr()); 797 798 from_glib_none(value) 799 } 800 } 801 } 802 803 declare_concrete_message!(Application); 804 805 declare_concrete_message!(Element); 806 807 declare_concrete_message!(SegmentStart); 808 impl<'a> SegmentStart<'a> { get(&self) -> GenericFormattedValue809 pub fn get(&self) -> GenericFormattedValue { 810 unsafe { 811 let mut format = mem::MaybeUninit::uninit(); 812 let mut position = mem::MaybeUninit::uninit(); 813 814 gst_sys::gst_message_parse_segment_start( 815 self.as_mut_ptr(), 816 format.as_mut_ptr(), 817 position.as_mut_ptr(), 818 ); 819 820 GenericFormattedValue::new(from_glib(format.assume_init()), position.assume_init()) 821 } 822 } 823 } 824 825 declare_concrete_message!(SegmentDone); 826 impl<'a> SegmentDone<'a> { get(&self) -> GenericFormattedValue827 pub fn get(&self) -> GenericFormattedValue { 828 unsafe { 829 let mut format = mem::MaybeUninit::uninit(); 830 let mut position = mem::MaybeUninit::uninit(); 831 832 gst_sys::gst_message_parse_segment_done( 833 self.as_mut_ptr(), 834 format.as_mut_ptr(), 835 position.as_mut_ptr(), 836 ); 837 838 GenericFormattedValue::new(from_glib(format.assume_init()), position.assume_init()) 839 } 840 } 841 } 842 843 declare_concrete_message!(DurationChanged); 844 declare_concrete_message!(Latency); 845 declare_concrete_message!(AsyncStart); 846 847 declare_concrete_message!(AsyncDone); 848 impl<'a> AsyncDone<'a> { get_running_time(&self) -> ::ClockTime849 pub fn get_running_time(&self) -> ::ClockTime { 850 unsafe { 851 let mut running_time = mem::MaybeUninit::uninit(); 852 853 gst_sys::gst_message_parse_async_done(self.as_mut_ptr(), running_time.as_mut_ptr()); 854 855 from_glib(running_time.assume_init()) 856 } 857 } 858 } 859 860 declare_concrete_message!(RequestState); 861 impl<'a> RequestState<'a> { get_requested_state(&self) -> ::State862 pub fn get_requested_state(&self) -> ::State { 863 unsafe { 864 let mut state = mem::MaybeUninit::uninit(); 865 866 gst_sys::gst_message_parse_request_state(self.as_mut_ptr(), state.as_mut_ptr()); 867 868 from_glib(state.assume_init()) 869 } 870 } 871 } 872 873 declare_concrete_message!(StepStart); 874 impl<'a> StepStart<'a> { get(&self) -> (bool, GenericFormattedValue, f64, bool, bool)875 pub fn get(&self) -> (bool, GenericFormattedValue, f64, bool, bool) { 876 unsafe { 877 let mut active = mem::MaybeUninit::uninit(); 878 let mut format = mem::MaybeUninit::uninit(); 879 let mut amount = mem::MaybeUninit::uninit(); 880 let mut rate = mem::MaybeUninit::uninit(); 881 let mut flush = mem::MaybeUninit::uninit(); 882 let mut intermediate = mem::MaybeUninit::uninit(); 883 884 gst_sys::gst_message_parse_step_start( 885 self.as_mut_ptr(), 886 active.as_mut_ptr(), 887 format.as_mut_ptr(), 888 amount.as_mut_ptr(), 889 rate.as_mut_ptr(), 890 flush.as_mut_ptr(), 891 intermediate.as_mut_ptr(), 892 ); 893 894 ( 895 from_glib(active.assume_init()), 896 GenericFormattedValue::new( 897 from_glib(format.assume_init()), 898 amount.assume_init() as i64, 899 ), 900 rate.assume_init(), 901 from_glib(flush.assume_init()), 902 from_glib(intermediate.assume_init()), 903 ) 904 } 905 } 906 } 907 908 declare_concrete_message!(Qos); 909 impl<'a> Qos<'a> { get(&self) -> (bool, ::ClockTime, ::ClockTime, ::ClockTime, ::ClockTime)910 pub fn get(&self) -> (bool, ::ClockTime, ::ClockTime, ::ClockTime, ::ClockTime) { 911 unsafe { 912 let mut live = mem::MaybeUninit::uninit(); 913 let mut running_time = mem::MaybeUninit::uninit(); 914 let mut stream_time = mem::MaybeUninit::uninit(); 915 let mut timestamp = mem::MaybeUninit::uninit(); 916 let mut duration = mem::MaybeUninit::uninit(); 917 918 gst_sys::gst_message_parse_qos( 919 self.as_mut_ptr(), 920 live.as_mut_ptr(), 921 running_time.as_mut_ptr(), 922 stream_time.as_mut_ptr(), 923 timestamp.as_mut_ptr(), 924 duration.as_mut_ptr(), 925 ); 926 927 ( 928 from_glib(live.assume_init()), 929 from_glib(running_time.assume_init()), 930 from_glib(stream_time.assume_init()), 931 from_glib(timestamp.assume_init()), 932 from_glib(duration.assume_init()), 933 ) 934 } 935 } 936 get_values(&self) -> (i64, f64, i32)937 pub fn get_values(&self) -> (i64, f64, i32) { 938 unsafe { 939 let mut jitter = mem::MaybeUninit::uninit(); 940 let mut proportion = mem::MaybeUninit::uninit(); 941 let mut quality = mem::MaybeUninit::uninit(); 942 943 gst_sys::gst_message_parse_qos_values( 944 self.as_mut_ptr(), 945 jitter.as_mut_ptr(), 946 proportion.as_mut_ptr(), 947 quality.as_mut_ptr(), 948 ); 949 950 ( 951 jitter.assume_init(), 952 proportion.assume_init(), 953 quality.assume_init(), 954 ) 955 } 956 } 957 get_stats(&self) -> (GenericFormattedValue, GenericFormattedValue)958 pub fn get_stats(&self) -> (GenericFormattedValue, GenericFormattedValue) { 959 unsafe { 960 let mut format = mem::MaybeUninit::uninit(); 961 let mut processed = mem::MaybeUninit::uninit(); 962 let mut dropped = mem::MaybeUninit::uninit(); 963 964 gst_sys::gst_message_parse_qos_stats( 965 self.as_mut_ptr(), 966 format.as_mut_ptr(), 967 processed.as_mut_ptr(), 968 dropped.as_mut_ptr(), 969 ); 970 971 ( 972 GenericFormattedValue::new( 973 from_glib(format.assume_init()), 974 processed.assume_init() as i64, 975 ), 976 GenericFormattedValue::new( 977 from_glib(format.assume_init()), 978 dropped.assume_init() as i64, 979 ), 980 ) 981 } 982 } 983 } 984 985 declare_concrete_message!(Progress); 986 impl<'a> Progress<'a> { get(&self) -> (::ProgressType, &'a str, &'a str)987 pub fn get(&self) -> (::ProgressType, &'a str, &'a str) { 988 unsafe { 989 let mut type_ = mem::MaybeUninit::uninit(); 990 let mut code = ptr::null_mut(); 991 let mut text = ptr::null_mut(); 992 993 gst_sys::gst_message_parse_progress( 994 self.as_mut_ptr(), 995 type_.as_mut_ptr(), 996 &mut code, 997 &mut text, 998 ); 999 1000 let code = CStr::from_ptr(code).to_str().unwrap(); 1001 let text = CStr::from_ptr(text).to_str().unwrap(); 1002 1003 (from_glib(type_.assume_init()), code, text) 1004 } 1005 } 1006 } 1007 1008 declare_concrete_message!(Toc); 1009 impl<'a> Toc<'a> { get_toc(&self) -> (::Toc, bool)1010 pub fn get_toc(&self) -> (::Toc, bool) { 1011 unsafe { 1012 let mut toc = ptr::null_mut(); 1013 let mut updated = mem::MaybeUninit::uninit(); 1014 gst_sys::gst_message_parse_toc(self.as_mut_ptr(), &mut toc, updated.as_mut_ptr()); 1015 (from_glib_full(toc), from_glib(updated.assume_init())) 1016 } 1017 } 1018 } 1019 1020 declare_concrete_message!(ResetTime); 1021 impl<'a> ResetTime<'a> { get_running_time(&self) -> ::ClockTime1022 pub fn get_running_time(&self) -> ::ClockTime { 1023 unsafe { 1024 let mut running_time = mem::MaybeUninit::uninit(); 1025 1026 gst_sys::gst_message_parse_reset_time(self.as_mut_ptr(), running_time.as_mut_ptr()); 1027 1028 from_glib(running_time.assume_init()) 1029 } 1030 } 1031 } 1032 1033 declare_concrete_message!(StreamStart); 1034 impl<'a> StreamStart<'a> { get_group_id(&self) -> Option<GroupId>1035 pub fn get_group_id(&self) -> Option<GroupId> { 1036 unsafe { 1037 let mut group_id = mem::MaybeUninit::uninit(); 1038 1039 if from_glib(gst_sys::gst_message_parse_group_id( 1040 self.as_mut_ptr(), 1041 group_id.as_mut_ptr(), 1042 )) { 1043 Some(from_glib(group_id.assume_init())) 1044 } else { 1045 None 1046 } 1047 } 1048 } 1049 } 1050 1051 declare_concrete_message!(NeedContext); 1052 impl<'a> NeedContext<'a> { get_context_type(&self) -> &str1053 pub fn get_context_type(&self) -> &str { 1054 unsafe { 1055 let mut context_type = ptr::null(); 1056 1057 gst_sys::gst_message_parse_context_type(self.as_mut_ptr(), &mut context_type); 1058 1059 CStr::from_ptr(context_type).to_str().unwrap() 1060 } 1061 } 1062 } 1063 1064 declare_concrete_message!(HaveContext); 1065 impl<'a> HaveContext<'a> { get_context(&self) -> ::Context1066 pub fn get_context(&self) -> ::Context { 1067 unsafe { 1068 let mut context = ptr::null_mut(); 1069 gst_sys::gst_message_parse_have_context(self.as_mut_ptr(), &mut context); 1070 from_glib_full(context) 1071 } 1072 } 1073 } 1074 1075 declare_concrete_message!(DeviceAdded); 1076 impl<'a> DeviceAdded<'a> { get_device(&self) -> ::Device1077 pub fn get_device(&self) -> ::Device { 1078 unsafe { 1079 let mut device = ptr::null_mut(); 1080 1081 gst_sys::gst_message_parse_device_added(self.as_mut_ptr(), &mut device); 1082 1083 from_glib_full(device) 1084 } 1085 } 1086 } 1087 1088 declare_concrete_message!(DeviceRemoved); 1089 impl<'a> DeviceRemoved<'a> { get_device(&self) -> ::Device1090 pub fn get_device(&self) -> ::Device { 1091 unsafe { 1092 let mut device = ptr::null_mut(); 1093 1094 gst_sys::gst_message_parse_device_removed(self.as_mut_ptr(), &mut device); 1095 1096 from_glib_full(device) 1097 } 1098 } 1099 } 1100 1101 declare_concrete_message!(PropertyNotify); 1102 impl<'a> PropertyNotify<'a> { 1103 #[cfg(any(feature = "v1_10", feature = "dox"))] get(&self) -> (Object, &str, Option<&'a glib::Value>)1104 pub fn get(&self) -> (Object, &str, Option<&'a glib::Value>) { 1105 unsafe { 1106 let mut object = ptr::null_mut(); 1107 let mut property_name = ptr::null(); 1108 let mut value = ptr::null(); 1109 1110 gst_sys::gst_message_parse_property_notify( 1111 self.as_mut_ptr(), 1112 &mut object, 1113 &mut property_name, 1114 &mut value, 1115 ); 1116 1117 ( 1118 from_glib_none(object), 1119 CStr::from_ptr(property_name).to_str().unwrap(), 1120 if value.is_null() { 1121 None 1122 } else { 1123 Some(&*(value as *const glib::Value)) 1124 }, 1125 ) 1126 } 1127 } 1128 } 1129 1130 declare_concrete_message!(StreamCollection); 1131 impl<'a> StreamCollection<'a> { 1132 #[cfg(any(feature = "v1_10", feature = "dox"))] get_stream_collection(&self) -> ::StreamCollection1133 pub fn get_stream_collection(&self) -> ::StreamCollection { 1134 unsafe { 1135 let mut collection = ptr::null_mut(); 1136 1137 gst_sys::gst_message_parse_stream_collection(self.as_mut_ptr(), &mut collection); 1138 1139 from_glib_full(collection) 1140 } 1141 } 1142 } 1143 1144 declare_concrete_message!(StreamsSelected); 1145 impl<'a> StreamsSelected<'a> { 1146 #[cfg(any(feature = "v1_10", feature = "dox"))] get_stream_collection(&self) -> ::StreamCollection1147 pub fn get_stream_collection(&self) -> ::StreamCollection { 1148 unsafe { 1149 let mut collection = ptr::null_mut(); 1150 1151 gst_sys::gst_message_parse_streams_selected(self.as_mut_ptr(), &mut collection); 1152 1153 from_glib_full(collection) 1154 } 1155 } 1156 1157 #[cfg(any(feature = "v1_10", feature = "dox"))] get_streams(&self) -> Vec<::Stream>1158 pub fn get_streams(&self) -> Vec<::Stream> { 1159 unsafe { 1160 let n = gst_sys::gst_message_streams_selected_get_size(self.as_mut_ptr()); 1161 1162 (0..n) 1163 .map(|i| { 1164 from_glib_full(gst_sys::gst_message_streams_selected_get_stream( 1165 self.as_mut_ptr(), 1166 i, 1167 )) 1168 }) 1169 .collect() 1170 } 1171 } 1172 } 1173 1174 declare_concrete_message!(Redirect); 1175 impl<'a> Redirect<'a> { 1176 #[cfg(any(feature = "v1_10", feature = "dox"))] get_entries(&self) -> Vec<(&str, Option<TagList>, Option<&StructureRef>)>1177 pub fn get_entries(&self) -> Vec<(&str, Option<TagList>, Option<&StructureRef>)> { 1178 unsafe { 1179 let n = gst_sys::gst_message_get_num_redirect_entries(self.as_mut_ptr()); 1180 1181 (0..n) 1182 .map(|i| { 1183 let mut location = ptr::null(); 1184 let mut tags = ptr::null_mut(); 1185 let mut structure = ptr::null(); 1186 1187 gst_sys::gst_message_parse_redirect_entry( 1188 self.as_mut_ptr(), 1189 i, 1190 &mut location, 1191 &mut tags, 1192 &mut structure, 1193 ); 1194 1195 let structure = if structure.is_null() { 1196 None 1197 } else { 1198 Some(StructureRef::from_glib_borrow(structure)) 1199 }; 1200 1201 ( 1202 CStr::from_ptr(location).to_str().unwrap(), 1203 from_glib_none(tags), 1204 structure, 1205 ) 1206 }) 1207 .collect() 1208 } 1209 } 1210 } 1211 1212 declare_concrete_message!(DeviceChanged); 1213 impl<'a> DeviceChanged<'a> { 1214 #[cfg(any(feature = "v1_16", feature = "dox"))] get_device_changed(&self) -> (::Device, ::Device)1215 pub fn get_device_changed(&self) -> (::Device, ::Device) { 1216 unsafe { 1217 let mut device = ptr::null_mut(); 1218 let mut changed_device = ptr::null_mut(); 1219 1220 gst_sys::gst_message_parse_device_changed( 1221 self.as_mut_ptr(), 1222 &mut device, 1223 &mut changed_device, 1224 ); 1225 1226 (from_glib_full(device), from_glib_full(changed_device)) 1227 } 1228 } 1229 } 1230 1231 struct MessageBuilder<'a> { 1232 src: Option<Object>, 1233 seqnum: Option<Seqnum>, 1234 #[allow(unused)] 1235 other_fields: Vec<(&'a str, &'a dyn ToSendValue)>, 1236 } 1237 1238 impl<'a> MessageBuilder<'a> { new() -> Self1239 fn new() -> Self { 1240 Self { 1241 src: None, 1242 seqnum: None, 1243 other_fields: Vec::new(), 1244 } 1245 } 1246 src<O: IsA<Object> + Cast + Clone>(self, src: Option<&O>) -> Self1247 pub fn src<O: IsA<Object> + Cast + Clone>(self, src: Option<&O>) -> Self { 1248 Self { 1249 src: src.map(|o| { 1250 let o = (*o).clone(); 1251 o.upcast::<Object>() 1252 }), 1253 ..self 1254 } 1255 } 1256 seqnum(self, seqnum: Seqnum) -> Self1257 fn seqnum(self, seqnum: Seqnum) -> Self { 1258 Self { 1259 seqnum: Some(seqnum), 1260 ..self 1261 } 1262 } 1263 1264 #[cfg(any(feature = "v1_14", feature = "dox"))] other_fields(self, other_fields: &[(&'a str, &'a dyn ToSendValue)]) -> Self1265 fn other_fields(self, other_fields: &[(&'a str, &'a dyn ToSendValue)]) -> Self { 1266 Self { 1267 other_fields: self 1268 .other_fields 1269 .iter() 1270 .cloned() 1271 .chain(other_fields.iter().cloned()) 1272 .collect(), 1273 ..self 1274 } 1275 } 1276 } 1277 1278 macro_rules! message_builder_generic_impl { 1279 ($new_fn:expr) => { 1280 #[allow(clippy::needless_update)] 1281 pub fn src<O: IsA<Object> + Cast + Clone>(self, src: Option<&O>) -> Self { 1282 Self { 1283 builder: self.builder.src(src), 1284 ..self 1285 } 1286 } 1287 1288 #[allow(clippy::needless_update)] 1289 pub fn seqnum(self, seqnum: Seqnum) -> Self { 1290 Self { 1291 builder: self.builder.seqnum(seqnum), 1292 ..self 1293 } 1294 } 1295 1296 #[cfg(any(feature = "v1_14", feature = "dox"))] 1297 #[allow(clippy::needless_update)] 1298 pub fn other_fields(self, other_fields: &[(&'a str, &'a dyn ToSendValue)]) -> Self { 1299 Self { 1300 builder: self.builder.other_fields(other_fields), 1301 ..self 1302 } 1303 } 1304 1305 pub fn build(mut self) -> Message { 1306 assert_initialized_main_thread!(); 1307 unsafe { 1308 let src = self.builder.src.to_glib_none().0; 1309 let msg = $new_fn(&mut self, src); 1310 if let Some(seqnum) = self.builder.seqnum { 1311 gst_sys::gst_message_set_seqnum(msg, seqnum.to_glib()); 1312 } 1313 1314 #[cfg(any(feature = "v1_14", feature = "dox"))] 1315 { 1316 if !self.builder.other_fields.is_empty() { 1317 let structure = gst_sys::gst_message_writable_structure(msg); 1318 1319 if !structure.is_null() { 1320 let structure = StructureRef::from_glib_borrow_mut(structure as *mut _); 1321 1322 for (k, v) in self.builder.other_fields { 1323 structure.set_value(k, v.to_send_value()); 1324 } 1325 } 1326 } 1327 } 1328 1329 from_glib_full(msg) 1330 } 1331 } 1332 }; 1333 } 1334 1335 pub struct EosBuilder<'a> { 1336 builder: MessageBuilder<'a>, 1337 } 1338 impl<'a> EosBuilder<'a> { new() -> Self1339 fn new() -> Self { 1340 skip_assert_initialized!(); 1341 Self { 1342 builder: MessageBuilder::new(), 1343 } 1344 } 1345 1346 message_builder_generic_impl!(|_, src| gst_sys::gst_message_new_eos(src)); 1347 } 1348 1349 pub trait MessageErrorDomain: glib::error::ErrorDomain {} 1350 1351 impl MessageErrorDomain for ::CoreError {} 1352 impl MessageErrorDomain for ::ResourceError {} 1353 impl MessageErrorDomain for ::StreamError {} 1354 impl MessageErrorDomain for ::LibraryError {} 1355 1356 pub struct ErrorBuilder<'a, T> { 1357 builder: MessageBuilder<'a>, 1358 error: T, 1359 message: &'a str, 1360 debug: Option<&'a str>, 1361 #[allow(unused)] 1362 details: Option<Structure>, 1363 } 1364 impl<'a, T: MessageErrorDomain> ErrorBuilder<'a, T> { new(error: T, message: &'a str) -> Self1365 fn new(error: T, message: &'a str) -> Self { 1366 skip_assert_initialized!(); 1367 Self { 1368 builder: MessageBuilder::new(), 1369 error, 1370 message, 1371 debug: None, 1372 details: None, 1373 } 1374 } 1375 debug(self, debug: &'a str) -> Self1376 pub fn debug(self, debug: &'a str) -> Self { 1377 Self { 1378 debug: Some(debug), 1379 ..self 1380 } 1381 } 1382 1383 #[cfg(any(feature = "v1_10", feature = "dox"))] details(self, details: Structure) -> Self1384 pub fn details(self, details: Structure) -> Self { 1385 Self { 1386 details: Some(details), 1387 ..self 1388 } 1389 } 1390 1391 message_builder_generic_impl!(|s: &mut Self, src| { 1392 #[cfg(any(feature = "v1_10", feature = "dox"))] 1393 { 1394 let details = match s.details.take() { 1395 None => ptr::null_mut(), 1396 Some(details) => details.into_ptr(), 1397 }; 1398 1399 let error = glib::Error::new(s.error, s.message); 1400 1401 gst_sys::gst_message_new_error_with_details( 1402 src, 1403 mut_override(error.to_glib_none().0), 1404 s.debug.to_glib_none().0, 1405 details, 1406 ) 1407 } 1408 #[cfg(not(any(feature = "v1_10", feature = "dox")))] 1409 { 1410 let error = glib::Error::new(s.error, s.message); 1411 1412 gst_sys::gst_message_new_error( 1413 src, 1414 mut_override(error.to_glib_none().0), 1415 s.debug.to_glib_none().0, 1416 ) 1417 } 1418 }); 1419 } 1420 1421 pub struct WarningBuilder<'a, T> { 1422 builder: MessageBuilder<'a>, 1423 error: T, 1424 message: &'a str, 1425 debug: Option<&'a str>, 1426 #[allow(unused)] 1427 details: Option<Structure>, 1428 } 1429 impl<'a, T: MessageErrorDomain> WarningBuilder<'a, T> { new(error: T, message: &'a str) -> Self1430 fn new(error: T, message: &'a str) -> Self { 1431 skip_assert_initialized!(); 1432 Self { 1433 builder: MessageBuilder::new(), 1434 error, 1435 message, 1436 debug: None, 1437 details: None, 1438 } 1439 } 1440 debug(self, debug: &'a str) -> Self1441 pub fn debug(self, debug: &'a str) -> Self { 1442 Self { 1443 debug: Some(debug), 1444 ..self 1445 } 1446 } 1447 1448 #[cfg(any(feature = "v1_10", feature = "dox"))] details(self, details: Structure) -> Self1449 pub fn details(self, details: Structure) -> Self { 1450 Self { 1451 details: Some(details), 1452 ..self 1453 } 1454 } 1455 1456 message_builder_generic_impl!(|s: &mut Self, src| { 1457 #[cfg(any(feature = "v1_10", feature = "dox"))] 1458 { 1459 let details = match s.details.take() { 1460 None => ptr::null_mut(), 1461 Some(details) => details.into_ptr(), 1462 }; 1463 1464 let error = glib::Error::new(s.error, s.message); 1465 1466 gst_sys::gst_message_new_warning_with_details( 1467 src, 1468 mut_override(error.to_glib_none().0), 1469 s.debug.to_glib_none().0, 1470 details, 1471 ) 1472 } 1473 #[cfg(not(any(feature = "v1_10", feature = "dox")))] 1474 { 1475 let error = glib::Error::new(s.error, s.message); 1476 1477 gst_sys::gst_message_new_warning( 1478 src, 1479 mut_override(error.to_glib_none().0), 1480 s.debug.to_glib_none().0, 1481 ) 1482 } 1483 }); 1484 } 1485 1486 pub struct InfoBuilder<'a, T> { 1487 builder: MessageBuilder<'a>, 1488 error: T, 1489 message: &'a str, 1490 debug: Option<&'a str>, 1491 #[allow(unused)] 1492 details: Option<Structure>, 1493 } 1494 impl<'a, T: MessageErrorDomain> InfoBuilder<'a, T> { new(error: T, message: &'a str) -> Self1495 fn new(error: T, message: &'a str) -> Self { 1496 skip_assert_initialized!(); 1497 Self { 1498 builder: MessageBuilder::new(), 1499 error, 1500 message, 1501 debug: None, 1502 details: None, 1503 } 1504 } 1505 debug(self, debug: &'a str) -> Self1506 pub fn debug(self, debug: &'a str) -> Self { 1507 Self { 1508 debug: Some(debug), 1509 ..self 1510 } 1511 } 1512 1513 #[cfg(any(feature = "v1_10", feature = "dox"))] details(self, details: Structure) -> Self1514 pub fn details(self, details: Structure) -> Self { 1515 Self { 1516 details: Some(details), 1517 ..self 1518 } 1519 } 1520 1521 message_builder_generic_impl!(|s: &mut Self, src| { 1522 #[cfg(any(feature = "v1_10", feature = "dox"))] 1523 { 1524 let details = match s.details.take() { 1525 None => ptr::null_mut(), 1526 Some(details) => details.into_ptr(), 1527 }; 1528 1529 let error = glib::Error::new(s.error, s.message); 1530 1531 gst_sys::gst_message_new_info_with_details( 1532 src, 1533 mut_override(error.to_glib_none().0), 1534 s.debug.to_glib_none().0, 1535 details, 1536 ) 1537 } 1538 #[cfg(not(any(feature = "v1_10", feature = "dox")))] 1539 { 1540 let error = glib::Error::new(s.error, s.message); 1541 1542 gst_sys::gst_message_new_info( 1543 src, 1544 mut_override(error.to_glib_none().0), 1545 s.debug.to_glib_none().0, 1546 ) 1547 } 1548 }); 1549 } 1550 1551 pub struct TagBuilder<'a> { 1552 builder: MessageBuilder<'a>, 1553 tags: &'a TagList, 1554 } 1555 impl<'a> TagBuilder<'a> { new(tags: &'a TagList) -> Self1556 fn new(tags: &'a TagList) -> Self { 1557 skip_assert_initialized!(); 1558 Self { 1559 builder: MessageBuilder::new(), 1560 tags, 1561 } 1562 } 1563 1564 message_builder_generic_impl!(|s: &Self, src| gst_sys::gst_message_new_tag( 1565 src, 1566 s.tags.to_glib_full() 1567 )); 1568 } 1569 1570 pub struct BufferingBuilder<'a> { 1571 builder: MessageBuilder<'a>, 1572 percent: i32, 1573 stats: Option<(::BufferingMode, i32, i32, i64)>, 1574 } 1575 impl<'a> BufferingBuilder<'a> { new(percent: i32) -> Self1576 fn new(percent: i32) -> Self { 1577 skip_assert_initialized!(); 1578 Self { 1579 builder: MessageBuilder::new(), 1580 percent, 1581 stats: None, 1582 } 1583 } 1584 stats( self, mode: ::BufferingMode, avg_in: i32, avg_out: i32, buffering_left: i64, ) -> Self1585 pub fn stats( 1586 self, 1587 mode: ::BufferingMode, 1588 avg_in: i32, 1589 avg_out: i32, 1590 buffering_left: i64, 1591 ) -> Self { 1592 skip_assert_initialized!(); 1593 Self { 1594 stats: Some((mode, avg_in, avg_out, buffering_left)), 1595 ..self 1596 } 1597 } 1598 1599 message_builder_generic_impl!(|s: &mut Self, src| { 1600 let msg = gst_sys::gst_message_new_buffering(src, s.percent); 1601 1602 if let Some((mode, avg_in, avg_out, buffering_left)) = s.stats { 1603 gst_sys::gst_message_set_buffering_stats( 1604 msg, 1605 mode.to_glib(), 1606 avg_in, 1607 avg_out, 1608 buffering_left, 1609 ); 1610 } 1611 1612 msg 1613 }); 1614 } 1615 1616 pub struct StateChangedBuilder<'a> { 1617 builder: MessageBuilder<'a>, 1618 old: ::State, 1619 new: ::State, 1620 pending: ::State, 1621 } 1622 impl<'a> StateChangedBuilder<'a> { new(old: ::State, new: ::State, pending: ::State) -> Self1623 fn new(old: ::State, new: ::State, pending: ::State) -> Self { 1624 skip_assert_initialized!(); 1625 Self { 1626 builder: MessageBuilder::new(), 1627 old, 1628 new, 1629 pending, 1630 } 1631 } 1632 1633 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_state_changed( 1634 src, 1635 s.old.to_glib(), 1636 s.new.to_glib(), 1637 s.pending.to_glib(), 1638 )); 1639 } 1640 1641 pub struct StateDirtyBuilder<'a> { 1642 builder: MessageBuilder<'a>, 1643 } 1644 impl<'a> StateDirtyBuilder<'a> { new() -> Self1645 fn new() -> Self { 1646 skip_assert_initialized!(); 1647 Self { 1648 builder: MessageBuilder::new(), 1649 } 1650 } 1651 1652 message_builder_generic_impl!(|_, src| gst_sys::gst_message_new_state_dirty(src)); 1653 } 1654 1655 pub struct StepDoneBuilder<'a> { 1656 builder: MessageBuilder<'a>, 1657 amount: GenericFormattedValue, 1658 rate: f64, 1659 flush: bool, 1660 intermediate: bool, 1661 duration: GenericFormattedValue, 1662 eos: bool, 1663 } 1664 impl<'a> StepDoneBuilder<'a> { new( amount: GenericFormattedValue, rate: f64, flush: bool, intermediate: bool, duration: GenericFormattedValue, eos: bool, ) -> Self1665 fn new( 1666 amount: GenericFormattedValue, 1667 rate: f64, 1668 flush: bool, 1669 intermediate: bool, 1670 duration: GenericFormattedValue, 1671 eos: bool, 1672 ) -> Self { 1673 skip_assert_initialized!(); 1674 assert_eq!(amount.get_format(), duration.get_format()); 1675 Self { 1676 builder: MessageBuilder::new(), 1677 amount, 1678 rate, 1679 flush, 1680 intermediate, 1681 duration, 1682 eos, 1683 } 1684 } 1685 1686 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_step_done( 1687 src, 1688 s.amount.get_format().to_glib(), 1689 s.amount.get_value() as u64, 1690 s.rate, 1691 s.flush.to_glib(), 1692 s.intermediate.to_glib(), 1693 s.duration.get_value() as u64, 1694 s.eos.to_glib(), 1695 )); 1696 } 1697 1698 pub struct ClockProvideBuilder<'a> { 1699 builder: MessageBuilder<'a>, 1700 clock: &'a ::Clock, 1701 ready: bool, 1702 } 1703 impl<'a> ClockProvideBuilder<'a> { new(clock: &'a ::Clock, ready: bool) -> Self1704 fn new(clock: &'a ::Clock, ready: bool) -> Self { 1705 skip_assert_initialized!(); 1706 Self { 1707 builder: MessageBuilder::new(), 1708 clock, 1709 ready, 1710 } 1711 } 1712 1713 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_clock_provide( 1714 src, 1715 s.clock.to_glib_none().0, 1716 s.ready.to_glib() 1717 )); 1718 } 1719 1720 pub struct ClockLostBuilder<'a> { 1721 builder: MessageBuilder<'a>, 1722 clock: &'a ::Clock, 1723 } 1724 impl<'a> ClockLostBuilder<'a> { new(clock: &'a ::Clock) -> Self1725 fn new(clock: &'a ::Clock) -> Self { 1726 skip_assert_initialized!(); 1727 Self { 1728 builder: MessageBuilder::new(), 1729 clock, 1730 } 1731 } 1732 1733 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_clock_lost( 1734 src, 1735 s.clock.to_glib_none().0 1736 )); 1737 } 1738 1739 pub struct NewClockBuilder<'a> { 1740 builder: MessageBuilder<'a>, 1741 clock: &'a ::Clock, 1742 } 1743 impl<'a> NewClockBuilder<'a> { new(clock: &'a ::Clock) -> Self1744 fn new(clock: &'a ::Clock) -> Self { 1745 skip_assert_initialized!(); 1746 Self { 1747 builder: MessageBuilder::new(), 1748 clock, 1749 } 1750 } 1751 1752 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_new_clock( 1753 src, 1754 s.clock.to_glib_none().0 1755 )); 1756 } 1757 1758 pub struct StructureChangeBuilder<'a> { 1759 builder: MessageBuilder<'a>, 1760 type_: ::StructureChangeType, 1761 owner: &'a ::Element, 1762 busy: bool, 1763 } 1764 impl<'a> StructureChangeBuilder<'a> { new(type_: ::StructureChangeType, owner: &'a ::Element, busy: bool) -> Self1765 fn new(type_: ::StructureChangeType, owner: &'a ::Element, busy: bool) -> Self { 1766 skip_assert_initialized!(); 1767 Self { 1768 builder: MessageBuilder::new(), 1769 type_, 1770 owner, 1771 busy, 1772 } 1773 } 1774 1775 message_builder_generic_impl!( 1776 |s: &mut Self, src| gst_sys::gst_message_new_structure_change( 1777 src, 1778 s.type_.to_glib(), 1779 s.owner.to_glib_none().0, 1780 s.busy.to_glib(), 1781 ) 1782 ); 1783 } 1784 1785 pub struct StreamStatusBuilder<'a> { 1786 builder: MessageBuilder<'a>, 1787 type_: ::StreamStatusType, 1788 owner: &'a ::Element, 1789 status_object: Option<&'a dyn glib::ToSendValue>, 1790 } 1791 impl<'a> StreamStatusBuilder<'a> { new(type_: ::StreamStatusType, owner: &'a ::Element) -> Self1792 fn new(type_: ::StreamStatusType, owner: &'a ::Element) -> Self { 1793 skip_assert_initialized!(); 1794 Self { 1795 builder: MessageBuilder::new(), 1796 type_, 1797 owner, 1798 status_object: None, 1799 } 1800 } 1801 status_object(self, status_object: &'a dyn glib::ToSendValue) -> Self1802 pub fn status_object(self, status_object: &'a dyn glib::ToSendValue) -> Self { 1803 Self { 1804 status_object: Some(status_object), 1805 ..self 1806 } 1807 } 1808 1809 message_builder_generic_impl!(|s: &mut Self, src| { 1810 let msg = gst_sys::gst_message_new_stream_status( 1811 src, 1812 s.type_.to_glib(), 1813 s.owner.to_glib_none().0, 1814 ); 1815 if let Some(status_object) = s.status_object { 1816 gst_sys::gst_message_set_stream_status_object( 1817 msg, 1818 status_object.to_send_value().to_glib_none().0, 1819 ); 1820 } 1821 msg 1822 }); 1823 } 1824 1825 pub struct ApplicationBuilder<'a> { 1826 builder: MessageBuilder<'a>, 1827 structure: Option<::Structure>, 1828 } 1829 impl<'a> ApplicationBuilder<'a> { new(structure: ::Structure) -> Self1830 fn new(structure: ::Structure) -> Self { 1831 skip_assert_initialized!(); 1832 Self { 1833 builder: MessageBuilder::new(), 1834 structure: Some(structure), 1835 } 1836 } 1837 1838 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_application( 1839 src, 1840 s.structure.take().unwrap().into_ptr() 1841 )); 1842 } 1843 1844 pub struct ElementBuilder<'a> { 1845 builder: MessageBuilder<'a>, 1846 structure: Option<::Structure>, 1847 } 1848 impl<'a> ElementBuilder<'a> { new(structure: ::Structure) -> Self1849 fn new(structure: ::Structure) -> Self { 1850 skip_assert_initialized!(); 1851 Self { 1852 builder: MessageBuilder::new(), 1853 structure: Some(structure), 1854 } 1855 } 1856 1857 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_element( 1858 src, 1859 s.structure.take().unwrap().into_ptr() 1860 )); 1861 } 1862 1863 pub struct SegmentStartBuilder<'a> { 1864 builder: MessageBuilder<'a>, 1865 position: GenericFormattedValue, 1866 } 1867 impl<'a> SegmentStartBuilder<'a> { new(position: GenericFormattedValue) -> Self1868 fn new(position: GenericFormattedValue) -> Self { 1869 skip_assert_initialized!(); 1870 Self { 1871 builder: MessageBuilder::new(), 1872 position, 1873 } 1874 } 1875 1876 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_segment_start( 1877 src, 1878 s.position.get_format().to_glib(), 1879 s.position.get_value(), 1880 )); 1881 } 1882 1883 pub struct SegmentDoneBuilder<'a> { 1884 builder: MessageBuilder<'a>, 1885 position: GenericFormattedValue, 1886 } 1887 impl<'a> SegmentDoneBuilder<'a> { new(position: GenericFormattedValue) -> Self1888 fn new(position: GenericFormattedValue) -> Self { 1889 skip_assert_initialized!(); 1890 Self { 1891 builder: MessageBuilder::new(), 1892 position, 1893 } 1894 } 1895 1896 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_segment_done( 1897 src, 1898 s.position.get_format().to_glib(), 1899 s.position.get_value(), 1900 )); 1901 } 1902 1903 pub struct DurationChangedBuilder<'a> { 1904 builder: MessageBuilder<'a>, 1905 } 1906 impl<'a> DurationChangedBuilder<'a> { new() -> Self1907 fn new() -> Self { 1908 skip_assert_initialized!(); 1909 Self { 1910 builder: MessageBuilder::new(), 1911 } 1912 } 1913 1914 message_builder_generic_impl!(|_, src| gst_sys::gst_message_new_duration_changed(src)); 1915 } 1916 1917 pub struct LatencyBuilder<'a> { 1918 builder: MessageBuilder<'a>, 1919 } 1920 impl<'a> LatencyBuilder<'a> { new() -> Self1921 fn new() -> Self { 1922 skip_assert_initialized!(); 1923 Self { 1924 builder: MessageBuilder::new(), 1925 } 1926 } 1927 1928 message_builder_generic_impl!(|_, src| gst_sys::gst_message_new_latency(src)); 1929 } 1930 1931 pub struct AsyncStartBuilder<'a> { 1932 builder: MessageBuilder<'a>, 1933 } 1934 impl<'a> AsyncStartBuilder<'a> { new() -> Self1935 fn new() -> Self { 1936 skip_assert_initialized!(); 1937 Self { 1938 builder: MessageBuilder::new(), 1939 } 1940 } 1941 1942 message_builder_generic_impl!(|_, src| gst_sys::gst_message_new_async_start(src)); 1943 } 1944 1945 pub struct AsyncDoneBuilder<'a> { 1946 builder: MessageBuilder<'a>, 1947 running_time: ::ClockTime, 1948 } 1949 impl<'a> AsyncDoneBuilder<'a> { new(running_time: ::ClockTime) -> Self1950 fn new(running_time: ::ClockTime) -> Self { 1951 skip_assert_initialized!(); 1952 Self { 1953 builder: MessageBuilder::new(), 1954 running_time, 1955 } 1956 } 1957 1958 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_async_done( 1959 src, 1960 s.running_time.to_glib() 1961 )); 1962 } 1963 1964 pub struct RequestStateBuilder<'a> { 1965 builder: MessageBuilder<'a>, 1966 state: ::State, 1967 } 1968 impl<'a> RequestStateBuilder<'a> { new(state: ::State) -> Self1969 fn new(state: ::State) -> Self { 1970 skip_assert_initialized!(); 1971 Self { 1972 builder: MessageBuilder::new(), 1973 state, 1974 } 1975 } 1976 1977 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_request_state( 1978 src, 1979 s.state.to_glib() 1980 )); 1981 } 1982 1983 pub struct StepStartBuilder<'a> { 1984 builder: MessageBuilder<'a>, 1985 active: bool, 1986 amount: GenericFormattedValue, 1987 rate: f64, 1988 flush: bool, 1989 intermediate: bool, 1990 } 1991 impl<'a> StepStartBuilder<'a> { new( active: bool, amount: GenericFormattedValue, rate: f64, flush: bool, intermediate: bool, ) -> Self1992 fn new( 1993 active: bool, 1994 amount: GenericFormattedValue, 1995 rate: f64, 1996 flush: bool, 1997 intermediate: bool, 1998 ) -> Self { 1999 skip_assert_initialized!(); 2000 Self { 2001 builder: MessageBuilder::new(), 2002 active, 2003 amount, 2004 rate, 2005 flush, 2006 intermediate, 2007 } 2008 } 2009 2010 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_step_start( 2011 src, 2012 s.active.to_glib(), 2013 s.amount.get_format().to_glib(), 2014 s.amount.get_value() as u64, 2015 s.rate, 2016 s.flush.to_glib(), 2017 s.intermediate.to_glib(), 2018 )); 2019 } 2020 2021 pub struct QosBuilder<'a> { 2022 builder: MessageBuilder<'a>, 2023 live: bool, 2024 running_time: ::ClockTime, 2025 stream_time: ::ClockTime, 2026 timestamp: ::ClockTime, 2027 duration: ::ClockTime, 2028 values: Option<(i64, f64, i32)>, 2029 stats: Option<(GenericFormattedValue, GenericFormattedValue)>, 2030 } 2031 impl<'a> QosBuilder<'a> { new( live: bool, running_time: ::ClockTime, stream_time: ::ClockTime, timestamp: ::ClockTime, duration: ::ClockTime, ) -> Self2032 fn new( 2033 live: bool, 2034 running_time: ::ClockTime, 2035 stream_time: ::ClockTime, 2036 timestamp: ::ClockTime, 2037 duration: ::ClockTime, 2038 ) -> Self { 2039 skip_assert_initialized!(); 2040 Self { 2041 builder: MessageBuilder::new(), 2042 live, 2043 running_time, 2044 stream_time, 2045 timestamp, 2046 duration, 2047 values: None, 2048 stats: None, 2049 } 2050 } 2051 values(self, jitter: i64, proportion: f64, quality: i32) -> Self2052 pub fn values(self, jitter: i64, proportion: f64, quality: i32) -> Self { 2053 Self { 2054 values: Some((jitter, proportion, quality)), 2055 ..self 2056 } 2057 } 2058 stats<V: Into<GenericFormattedValue>>(self, processed: V, dropped: V) -> Self2059 pub fn stats<V: Into<GenericFormattedValue>>(self, processed: V, dropped: V) -> Self { 2060 let processed = processed.into(); 2061 let dropped = dropped.into(); 2062 assert_eq!(processed.get_format(), dropped.get_format()); 2063 Self { 2064 stats: Some((processed, dropped)), 2065 ..self 2066 } 2067 } 2068 2069 message_builder_generic_impl!(|s: &mut Self, src| { 2070 let msg = gst_sys::gst_message_new_qos( 2071 src, 2072 s.live.to_glib(), 2073 s.running_time.to_glib(), 2074 s.stream_time.to_glib(), 2075 s.timestamp.to_glib(), 2076 s.duration.to_glib(), 2077 ); 2078 if let Some((jitter, proportion, quality)) = s.values { 2079 gst_sys::gst_message_set_qos_values(msg, jitter, proportion, quality); 2080 } 2081 if let Some((processed, dropped)) = s.stats { 2082 gst_sys::gst_message_set_qos_stats( 2083 msg, 2084 processed.get_format().to_glib(), 2085 processed.get_value() as u64, 2086 dropped.get_value() as u64, 2087 ); 2088 } 2089 msg 2090 }); 2091 } 2092 2093 pub struct ProgressBuilder<'a> { 2094 builder: MessageBuilder<'a>, 2095 type_: ::ProgressType, 2096 code: &'a str, 2097 text: &'a str, 2098 } 2099 impl<'a> ProgressBuilder<'a> { new(type_: ::ProgressType, code: &'a str, text: &'a str) -> Self2100 fn new(type_: ::ProgressType, code: &'a str, text: &'a str) -> Self { 2101 skip_assert_initialized!(); 2102 Self { 2103 builder: MessageBuilder::new(), 2104 type_, 2105 code, 2106 text, 2107 } 2108 } 2109 2110 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_progress( 2111 src, 2112 s.type_.to_glib(), 2113 s.code.to_glib_none().0, 2114 s.text.to_glib_none().0, 2115 )); 2116 } 2117 2118 pub struct TocBuilder<'a> { 2119 builder: MessageBuilder<'a>, 2120 toc: &'a ::Toc, 2121 updated: bool, 2122 } 2123 impl<'a> TocBuilder<'a> { new(toc: &'a ::Toc, updated: bool) -> Self2124 fn new(toc: &'a ::Toc, updated: bool) -> Self { 2125 skip_assert_initialized!(); 2126 Self { 2127 builder: MessageBuilder::new(), 2128 toc, 2129 updated, 2130 } 2131 } 2132 2133 message_builder_generic_impl!(|s: &Self, src| gst_sys::gst_message_new_toc( 2134 src, 2135 s.toc.to_glib_none().0, 2136 s.updated.to_glib() 2137 )); 2138 } 2139 2140 pub struct ResetTimeBuilder<'a> { 2141 builder: MessageBuilder<'a>, 2142 running_time: ::ClockTime, 2143 } 2144 impl<'a> ResetTimeBuilder<'a> { new(running_time: ::ClockTime) -> Self2145 fn new(running_time: ::ClockTime) -> Self { 2146 skip_assert_initialized!(); 2147 Self { 2148 builder: MessageBuilder::new(), 2149 running_time, 2150 } 2151 } 2152 2153 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_reset_time( 2154 src, 2155 s.running_time.to_glib() 2156 )); 2157 } 2158 2159 pub struct StreamStartBuilder<'a> { 2160 builder: MessageBuilder<'a>, 2161 group_id: Option<GroupId>, 2162 } 2163 impl<'a> StreamStartBuilder<'a> { new() -> Self2164 fn new() -> Self { 2165 skip_assert_initialized!(); 2166 Self { 2167 builder: MessageBuilder::new(), 2168 group_id: None, 2169 } 2170 } 2171 group_id(self, group_id: GroupId) -> Self2172 pub fn group_id(self, group_id: GroupId) -> Self { 2173 Self { 2174 group_id: Some(group_id), 2175 ..self 2176 } 2177 } 2178 2179 message_builder_generic_impl!(|s: &mut Self, src| { 2180 let msg = gst_sys::gst_message_new_stream_start(src); 2181 if let Some(group_id) = s.group_id { 2182 gst_sys::gst_message_set_group_id(msg, group_id.to_glib()); 2183 } 2184 msg 2185 }); 2186 } 2187 2188 pub struct NeedContextBuilder<'a> { 2189 builder: MessageBuilder<'a>, 2190 context_type: &'a str, 2191 } 2192 impl<'a> NeedContextBuilder<'a> { new(context_type: &'a str) -> Self2193 fn new(context_type: &'a str) -> Self { 2194 skip_assert_initialized!(); 2195 Self { 2196 builder: MessageBuilder::new(), 2197 context_type, 2198 } 2199 } 2200 2201 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_need_context( 2202 src, 2203 s.context_type.to_glib_none().0 2204 )); 2205 } 2206 2207 pub struct HaveContextBuilder<'a> { 2208 builder: MessageBuilder<'a>, 2209 context: Option<::Context>, 2210 } 2211 impl<'a> HaveContextBuilder<'a> { new(context: ::Context) -> Self2212 fn new(context: ::Context) -> Self { 2213 skip_assert_initialized!(); 2214 Self { 2215 builder: MessageBuilder::new(), 2216 context: Some(context), 2217 } 2218 } 2219 2220 message_builder_generic_impl!(|s: &mut Self, src| { 2221 let context = s.context.take().unwrap(); 2222 gst_sys::gst_message_new_have_context(src, context.into_ptr()) 2223 }); 2224 } 2225 2226 pub struct DeviceAddedBuilder<'a> { 2227 builder: MessageBuilder<'a>, 2228 device: &'a ::Device, 2229 } 2230 impl<'a> DeviceAddedBuilder<'a> { new(device: &'a ::Device) -> Self2231 fn new(device: &'a ::Device) -> Self { 2232 skip_assert_initialized!(); 2233 Self { 2234 builder: MessageBuilder::new(), 2235 device, 2236 } 2237 } 2238 2239 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_device_added( 2240 src, 2241 s.device.to_glib_none().0 2242 )); 2243 } 2244 2245 pub struct DeviceRemovedBuilder<'a> { 2246 builder: MessageBuilder<'a>, 2247 device: &'a ::Device, 2248 } 2249 impl<'a> DeviceRemovedBuilder<'a> { new(device: &'a ::Device) -> Self2250 fn new(device: &'a ::Device) -> Self { 2251 skip_assert_initialized!(); 2252 Self { 2253 builder: MessageBuilder::new(), 2254 device, 2255 } 2256 } 2257 2258 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_device_removed( 2259 src, 2260 s.device.to_glib_none().0 2261 )); 2262 } 2263 2264 #[cfg(any(feature = "v1_10", feature = "dox"))] 2265 pub struct PropertyNotifyBuilder<'a> { 2266 builder: MessageBuilder<'a>, 2267 property_name: &'a str, 2268 value: Option<&'a dyn glib::ToSendValue>, 2269 } 2270 #[cfg(any(feature = "v1_10", feature = "dox"))] 2271 impl<'a> PropertyNotifyBuilder<'a> { new(property_name: &'a str) -> Self2272 fn new(property_name: &'a str) -> Self { 2273 skip_assert_initialized!(); 2274 Self { 2275 builder: MessageBuilder::new(), 2276 property_name, 2277 value: None, 2278 } 2279 } 2280 value(self, value: &'a dyn glib::ToSendValue) -> Self2281 pub fn value(self, value: &'a dyn glib::ToSendValue) -> Self { 2282 Self { 2283 value: Some(value), 2284 ..self 2285 } 2286 } 2287 2288 message_builder_generic_impl!(|s: &mut Self, src| { 2289 let val = s.value.map(|v| v.to_send_value()); 2290 gst_sys::gst_message_new_property_notify( 2291 src, 2292 s.property_name.to_glib_none().0, 2293 mut_override( 2294 val.as_ref() 2295 .map(|v| v.to_glib_none().0) 2296 .unwrap_or(ptr::null()), 2297 ), 2298 ) 2299 }); 2300 } 2301 2302 #[cfg(any(feature = "v1_10", feature = "dox"))] 2303 pub struct StreamCollectionBuilder<'a> { 2304 builder: MessageBuilder<'a>, 2305 collection: &'a ::StreamCollection, 2306 } 2307 #[cfg(any(feature = "v1_10", feature = "dox"))] 2308 impl<'a> StreamCollectionBuilder<'a> { new(collection: &'a ::StreamCollection) -> Self2309 fn new(collection: &'a ::StreamCollection) -> Self { 2310 skip_assert_initialized!(); 2311 Self { 2312 builder: MessageBuilder::new(), 2313 collection, 2314 } 2315 } 2316 2317 message_builder_generic_impl!( 2318 |s: &mut Self, src| gst_sys::gst_message_new_stream_collection( 2319 src, 2320 s.collection.to_glib_none().0 2321 ) 2322 ); 2323 } 2324 2325 #[cfg(any(feature = "v1_10", feature = "dox"))] 2326 pub struct StreamsSelectedBuilder<'a> { 2327 builder: MessageBuilder<'a>, 2328 #[cfg(any(feature = "v1_10", feature = "dox"))] 2329 collection: &'a ::StreamCollection, 2330 #[cfg(any(feature = "v1_10", feature = "dox"))] 2331 streams: Option<&'a [&'a ::Stream]>, 2332 } 2333 #[cfg(any(feature = "v1_10", feature = "dox"))] 2334 impl<'a> StreamsSelectedBuilder<'a> { new(collection: &'a ::StreamCollection) -> Self2335 fn new(collection: &'a ::StreamCollection) -> Self { 2336 skip_assert_initialized!(); 2337 Self { 2338 builder: MessageBuilder::new(), 2339 collection, 2340 streams: None, 2341 } 2342 } 2343 streams(self, streams: &'a [&'a ::Stream]) -> Self2344 pub fn streams(self, streams: &'a [&'a ::Stream]) -> Self { 2345 Self { 2346 streams: Some(streams), 2347 ..self 2348 } 2349 } 2350 2351 message_builder_generic_impl!(|s: &mut Self, src| { 2352 let msg = gst_sys::gst_message_new_streams_selected(src, s.collection.to_glib_none().0); 2353 if let Some(streams) = s.streams { 2354 for stream in streams { 2355 gst_sys::gst_message_streams_selected_add(msg, stream.to_glib_none().0); 2356 } 2357 } 2358 msg 2359 }); 2360 } 2361 2362 #[cfg(any(feature = "v1_10", feature = "dox"))] 2363 pub struct RedirectBuilder<'a> { 2364 builder: MessageBuilder<'a>, 2365 location: &'a str, 2366 tag_list: Option<&'a TagList>, 2367 entry_struct: Option<Structure>, 2368 #[allow(clippy::type_complexity)] 2369 entries: Option<&'a [(&'a str, Option<&'a TagList>, Option<&'a Structure>)]>, 2370 } 2371 #[cfg(any(feature = "v1_10", feature = "dox"))] 2372 impl<'a> RedirectBuilder<'a> { new(location: &'a str) -> Self2373 fn new(location: &'a str) -> Self { 2374 skip_assert_initialized!(); 2375 Self { 2376 builder: MessageBuilder::new(), 2377 location, 2378 tag_list: None, 2379 entry_struct: None, 2380 entries: None, 2381 } 2382 } 2383 tag_list(self, tag_list: &'a TagList) -> Self2384 pub fn tag_list(self, tag_list: &'a TagList) -> Self { 2385 Self { 2386 tag_list: Some(tag_list), 2387 ..self 2388 } 2389 } 2390 entry_struct(self, entry_struct: Structure) -> Self2391 pub fn entry_struct(self, entry_struct: Structure) -> Self { 2392 Self { 2393 entry_struct: Some(entry_struct), 2394 ..self 2395 } 2396 } 2397 entries( self, entries: &'a [(&'a str, Option<&'a TagList>, Option<&'a Structure>)], ) -> Self2398 pub fn entries( 2399 self, 2400 entries: &'a [(&'a str, Option<&'a TagList>, Option<&'a Structure>)], 2401 ) -> Self { 2402 skip_assert_initialized!(); 2403 Self { 2404 entries: Some(entries), 2405 ..self 2406 } 2407 } 2408 2409 message_builder_generic_impl!(|s: &mut Self, src| { 2410 let entry_struct = s.entry_struct.take(); 2411 let entry_struct_ptr = if let Some(entry_struct) = entry_struct { 2412 entry_struct.into_ptr() 2413 } else { 2414 ptr::null_mut() 2415 }; 2416 2417 let msg = gst_sys::gst_message_new_redirect( 2418 src, 2419 s.location.to_glib_none().0, 2420 s.tag_list.to_glib_full(), 2421 entry_struct_ptr, 2422 ); 2423 if let Some(entries) = s.entries { 2424 for &(location, tag_list, entry_struct) in entries { 2425 let entry_struct = entry_struct.cloned(); 2426 let entry_struct_ptr = if let Some(entry_struct) = entry_struct { 2427 entry_struct.into_ptr() 2428 } else { 2429 ptr::null_mut() 2430 }; 2431 gst_sys::gst_message_add_redirect_entry( 2432 msg, 2433 location.to_glib_none().0, 2434 tag_list.to_glib_full(), 2435 entry_struct_ptr, 2436 ); 2437 } 2438 } 2439 msg 2440 }); 2441 } 2442 2443 #[cfg(any(feature = "v1_16", feature = "dox"))] 2444 pub struct DeviceChangedBuilder<'a> { 2445 builder: MessageBuilder<'a>, 2446 device: &'a ::Device, 2447 changed_device: &'a ::Device, 2448 } 2449 #[cfg(any(feature = "v1_16", feature = "dox"))] 2450 impl<'a> DeviceChangedBuilder<'a> { new(device: &'a ::Device, changed_device: &'a ::Device) -> Self2451 fn new(device: &'a ::Device, changed_device: &'a ::Device) -> Self { 2452 skip_assert_initialized!(); 2453 Self { 2454 builder: MessageBuilder::new(), 2455 device, 2456 changed_device, 2457 } 2458 } 2459 2460 message_builder_generic_impl!(|s: &mut Self, src| gst_sys::gst_message_new_device_changed( 2461 src, 2462 s.device.to_glib_none().0, 2463 s.changed_device.to_glib_none().0, 2464 )); 2465 } 2466 2467 #[cfg(test)] 2468 mod tests { 2469 use super::*; 2470 2471 #[test] test_simple()2472 fn test_simple() { 2473 ::init().unwrap(); 2474 2475 // Message without arguments 2476 let eos_msg = Message::new_eos().seqnum(Seqnum(1)).build(); 2477 match eos_msg.view() { 2478 MessageView::Eos(eos_msg) => { 2479 assert_eq!(eos_msg.get_seqnum(), Seqnum(1)); 2480 assert!(eos_msg.get_structure().is_none()); 2481 } 2482 _ => panic!("eos_msg.view() is not a MessageView::Eos(_)"), 2483 } 2484 2485 // Message with arguments 2486 let buffering_msg = Message::new_buffering(42).build(); 2487 match buffering_msg.view() { 2488 MessageView::Buffering(buffering_msg) => { 2489 assert_eq!(buffering_msg.get_percent(), 42); 2490 } 2491 _ => panic!("buffering_msg.view() is not a MessageView::Buffering(_)"), 2492 } 2493 } 2494 2495 #[cfg(feature = "v1_14")] 2496 #[test] test_other_fields()2497 fn test_other_fields() { 2498 ::init().unwrap(); 2499 2500 let eos_msg = Message::new_eos() 2501 .other_fields(&[("extra-field", &true)]) 2502 .seqnum(Seqnum(1)) 2503 .build(); 2504 match eos_msg.view() { 2505 MessageView::Eos(eos_msg) => { 2506 assert_eq!(eos_msg.get_seqnum(), Seqnum(1)); 2507 if let Some(other_fields) = eos_msg.get_structure() { 2508 assert!(other_fields.has_field("extra-field")); 2509 } 2510 } 2511 _ => panic!("eos_msg.view() is not a MessageView::Eos(_)"), 2512 } 2513 2514 let buffering_msg = Message::new_buffering(42) 2515 .other_fields(&[("extra-field", &true)]) 2516 .build(); 2517 match buffering_msg.view() { 2518 MessageView::Buffering(buffering_msg) => { 2519 assert_eq!(buffering_msg.get_percent(), 42); 2520 if let Some(other_fields) = buffering_msg.get_structure() { 2521 assert!(other_fields.has_field("extra-field")); 2522 } 2523 } 2524 _ => panic!("buffering_msg.view() is not a MessageView::Buffering(_)"), 2525 } 2526 } 2527 } 2528