1 // This file was generated by gir (https://github.com/gtk-rs/gir @ d1e88f9) 2 // from gir-files (https://github.com/gtk-rs/gir-files @ 63dd366) 3 // DO NOT EDIT 4 5 #![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] 6 #![allow( 7 clippy::approx_constant, 8 clippy::type_complexity, 9 clippy::unreadable_literal 10 )] 11 12 extern crate glib_sys as glib; 13 extern crate gobject_sys as gobject; 14 extern crate gstreamer_sys as gst; 15 extern crate libc; 16 17 #[allow(unused_imports)] 18 use libc::{ 19 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void, 20 intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE, 21 }; 22 23 #[allow(unused_imports)] 24 use glib::{gboolean, gconstpointer, gpointer, GType}; 25 26 // Constants 27 pub const GST_BASE_PARSE_FLAG_DRAINING: c_int = 2; 28 pub const GST_BASE_PARSE_FLAG_LOST_SYNC: c_int = 1; 29 pub const GST_BASE_TRANSFORM_SINK_NAME: *const c_char = b"sink\0" as *const u8 as *const c_char; 30 pub const GST_BASE_TRANSFORM_SRC_NAME: *const c_char = b"src\0" as *const u8 as *const c_char; 31 32 // Flags 33 pub type GstBaseParseFrameFlags = c_uint; 34 pub const GST_BASE_PARSE_FRAME_FLAG_NONE: GstBaseParseFrameFlags = 0; 35 pub const GST_BASE_PARSE_FRAME_FLAG_NEW_FRAME: GstBaseParseFrameFlags = 1; 36 pub const GST_BASE_PARSE_FRAME_FLAG_NO_FRAME: GstBaseParseFrameFlags = 2; 37 pub const GST_BASE_PARSE_FRAME_FLAG_CLIP: GstBaseParseFrameFlags = 4; 38 pub const GST_BASE_PARSE_FRAME_FLAG_DROP: GstBaseParseFrameFlags = 8; 39 pub const GST_BASE_PARSE_FRAME_FLAG_QUEUE: GstBaseParseFrameFlags = 16; 40 41 pub type GstBaseSrcFlags = c_uint; 42 pub const GST_BASE_SRC_FLAG_STARTING: GstBaseSrcFlags = 16384; 43 pub const GST_BASE_SRC_FLAG_STARTED: GstBaseSrcFlags = 32768; 44 pub const GST_BASE_SRC_FLAG_LAST: GstBaseSrcFlags = 1048576; 45 46 pub type GstCollectPadsStateFlags = c_uint; 47 pub const GST_COLLECT_PADS_STATE_EOS: GstCollectPadsStateFlags = 1; 48 pub const GST_COLLECT_PADS_STATE_FLUSHING: GstCollectPadsStateFlags = 2; 49 pub const GST_COLLECT_PADS_STATE_NEW_SEGMENT: GstCollectPadsStateFlags = 4; 50 pub const GST_COLLECT_PADS_STATE_WAITING: GstCollectPadsStateFlags = 8; 51 pub const GST_COLLECT_PADS_STATE_LOCKED: GstCollectPadsStateFlags = 16; 52 53 // Unions 54 #[repr(C)] 55 #[derive(Copy, Clone)] 56 pub union GstCollectData_ABI { 57 pub abi: GstCollectData_ABI_abi, 58 pub _gst_reserved: [gpointer; 4], 59 } 60 61 impl ::std::fmt::Debug for GstCollectData_ABI { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result62 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 63 f.debug_struct(&format!("GstCollectData_ABI @ {:?}", self as *const _)) 64 .field("abi", unsafe { &self.abi }) 65 .finish() 66 } 67 } 68 69 // Callbacks 70 pub type GstCollectDataDestroyNotify = Option<unsafe extern "C" fn(*mut GstCollectData)>; 71 pub type GstCollectPadsBufferFunction = Option< 72 unsafe extern "C" fn( 73 *mut GstCollectPads, 74 *mut GstCollectData, 75 *mut gst::GstBuffer, 76 gpointer, 77 ) -> gst::GstFlowReturn, 78 >; 79 pub type GstCollectPadsClipFunction = Option< 80 unsafe extern "C" fn( 81 *mut GstCollectPads, 82 *mut GstCollectData, 83 *mut gst::GstBuffer, 84 *mut *mut gst::GstBuffer, 85 gpointer, 86 ) -> gst::GstFlowReturn, 87 >; 88 pub type GstCollectPadsCompareFunction = Option< 89 unsafe extern "C" fn( 90 *mut GstCollectPads, 91 *mut GstCollectData, 92 gst::GstClockTime, 93 *mut GstCollectData, 94 gst::GstClockTime, 95 gpointer, 96 ) -> c_int, 97 >; 98 pub type GstCollectPadsEventFunction = Option< 99 unsafe extern "C" fn( 100 *mut GstCollectPads, 101 *mut GstCollectData, 102 *mut gst::GstEvent, 103 gpointer, 104 ) -> gboolean, 105 >; 106 pub type GstCollectPadsFlushFunction = Option<unsafe extern "C" fn(*mut GstCollectPads, gpointer)>; 107 pub type GstCollectPadsFunction = 108 Option<unsafe extern "C" fn(*mut GstCollectPads, gpointer) -> gst::GstFlowReturn>; 109 pub type GstCollectPadsQueryFunction = Option< 110 unsafe extern "C" fn( 111 *mut GstCollectPads, 112 *mut GstCollectData, 113 *mut gst::GstQuery, 114 gpointer, 115 ) -> gboolean, 116 >; 117 pub type GstDataQueueCheckFullFunction = 118 Option<unsafe extern "C" fn(*mut GstDataQueue, c_uint, c_uint, u64, gpointer) -> gboolean>; 119 pub type GstDataQueueEmptyCallback = Option<unsafe extern "C" fn(*mut GstDataQueue, gpointer)>; 120 pub type GstDataQueueFullCallback = Option<unsafe extern "C" fn(*mut GstDataQueue, gpointer)>; 121 pub type GstTypeFindHelperGetRangeFunction = Option< 122 unsafe extern "C" fn( 123 *mut gst::GstObject, 124 *mut gst::GstObject, 125 u64, 126 c_uint, 127 *mut *mut gst::GstBuffer, 128 ) -> gst::GstFlowReturn, 129 >; 130 131 // Records 132 #[repr(C)] 133 pub struct _GstAdapterClass(c_void); 134 135 pub type GstAdapterClass = *mut _GstAdapterClass; 136 137 #[repr(C)] 138 #[derive(Copy, Clone)] 139 pub struct GstAggregatorClass { 140 pub parent_class: gst::GstElementClass, 141 pub flush: Option<unsafe extern "C" fn(*mut GstAggregator) -> gst::GstFlowReturn>, 142 pub clip: Option< 143 unsafe extern "C" fn( 144 *mut GstAggregator, 145 *mut GstAggregatorPad, 146 *mut gst::GstBuffer, 147 ) -> *mut gst::GstBuffer, 148 >, 149 pub finish_buffer: 150 Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstBuffer) -> gst::GstFlowReturn>, 151 pub sink_event: Option< 152 unsafe extern "C" fn( 153 *mut GstAggregator, 154 *mut GstAggregatorPad, 155 *mut gst::GstEvent, 156 ) -> gboolean, 157 >, 158 pub sink_query: Option< 159 unsafe extern "C" fn( 160 *mut GstAggregator, 161 *mut GstAggregatorPad, 162 *mut gst::GstQuery, 163 ) -> gboolean, 164 >, 165 pub src_event: Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstEvent) -> gboolean>, 166 pub src_query: Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstQuery) -> gboolean>, 167 pub src_activate: 168 Option<unsafe extern "C" fn(*mut GstAggregator, gst::GstPadMode, gboolean) -> gboolean>, 169 pub aggregate: Option<unsafe extern "C" fn(*mut GstAggregator, gboolean) -> gst::GstFlowReturn>, 170 pub stop: Option<unsafe extern "C" fn(*mut GstAggregator) -> gboolean>, 171 pub start: Option<unsafe extern "C" fn(*mut GstAggregator) -> gboolean>, 172 pub get_next_time: Option<unsafe extern "C" fn(*mut GstAggregator) -> gst::GstClockTime>, 173 pub create_new_pad: Option< 174 unsafe extern "C" fn( 175 *mut GstAggregator, 176 *mut gst::GstPadTemplate, 177 *const c_char, 178 *const gst::GstCaps, 179 ) -> *mut GstAggregatorPad, 180 >, 181 pub update_src_caps: Option< 182 unsafe extern "C" fn( 183 *mut GstAggregator, 184 *mut gst::GstCaps, 185 *mut *mut gst::GstCaps, 186 ) -> gst::GstFlowReturn, 187 >, 188 pub fixate_src_caps: 189 Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstCaps) -> *mut gst::GstCaps>, 190 pub negotiated_src_caps: 191 Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstCaps) -> gboolean>, 192 pub decide_allocation: 193 Option<unsafe extern "C" fn(*mut GstAggregator, *mut gst::GstQuery) -> gboolean>, 194 pub propose_allocation: Option< 195 unsafe extern "C" fn( 196 *mut GstAggregator, 197 *mut GstAggregatorPad, 198 *mut gst::GstQuery, 199 *mut gst::GstQuery, 200 ) -> gboolean, 201 >, 202 pub _gst_reserved: [gpointer; 20], 203 } 204 205 impl ::std::fmt::Debug for GstAggregatorClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result206 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 207 f.debug_struct(&format!("GstAggregatorClass @ {:?}", self as *const _)) 208 .field("parent_class", &self.parent_class) 209 .field("flush", &self.flush) 210 .field("clip", &self.clip) 211 .field("finish_buffer", &self.finish_buffer) 212 .field("sink_event", &self.sink_event) 213 .field("sink_query", &self.sink_query) 214 .field("src_event", &self.src_event) 215 .field("src_query", &self.src_query) 216 .field("src_activate", &self.src_activate) 217 .field("aggregate", &self.aggregate) 218 .field("stop", &self.stop) 219 .field("start", &self.start) 220 .field("get_next_time", &self.get_next_time) 221 .field("create_new_pad", &self.create_new_pad) 222 .field("update_src_caps", &self.update_src_caps) 223 .field("fixate_src_caps", &self.fixate_src_caps) 224 .field("negotiated_src_caps", &self.negotiated_src_caps) 225 .field("decide_allocation", &self.decide_allocation) 226 .field("propose_allocation", &self.propose_allocation) 227 .finish() 228 } 229 } 230 231 #[repr(C)] 232 #[derive(Copy, Clone)] 233 pub struct GstAggregatorPadClass { 234 pub parent_class: gst::GstPadClass, 235 pub flush: Option< 236 unsafe extern "C" fn(*mut GstAggregatorPad, *mut GstAggregator) -> gst::GstFlowReturn, 237 >, 238 pub skip_buffer: Option< 239 unsafe extern "C" fn( 240 *mut GstAggregatorPad, 241 *mut GstAggregator, 242 *mut gst::GstBuffer, 243 ) -> gboolean, 244 >, 245 pub _gst_reserved: [gpointer; 20], 246 } 247 248 impl ::std::fmt::Debug for GstAggregatorPadClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result249 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 250 f.debug_struct(&format!("GstAggregatorPadClass @ {:?}", self as *const _)) 251 .field("parent_class", &self.parent_class) 252 .field("flush", &self.flush) 253 .field("skip_buffer", &self.skip_buffer) 254 .finish() 255 } 256 } 257 258 #[repr(C)] 259 pub struct _GstAggregatorPadPrivate(c_void); 260 261 pub type GstAggregatorPadPrivate = *mut _GstAggregatorPadPrivate; 262 263 #[repr(C)] 264 pub struct _GstAggregatorPrivate(c_void); 265 266 pub type GstAggregatorPrivate = *mut _GstAggregatorPrivate; 267 268 #[repr(C)] 269 #[derive(Copy, Clone)] 270 pub struct GstBaseParseClass { 271 pub parent_class: gst::GstElementClass, 272 pub start: Option<unsafe extern "C" fn(*mut GstBaseParse) -> gboolean>, 273 pub stop: Option<unsafe extern "C" fn(*mut GstBaseParse) -> gboolean>, 274 pub set_sink_caps: 275 Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstCaps) -> gboolean>, 276 pub handle_frame: Option< 277 unsafe extern "C" fn( 278 *mut GstBaseParse, 279 *mut GstBaseParseFrame, 280 *mut c_int, 281 ) -> gst::GstFlowReturn, 282 >, 283 pub pre_push_frame: Option< 284 unsafe extern "C" fn(*mut GstBaseParse, *mut GstBaseParseFrame) -> gst::GstFlowReturn, 285 >, 286 pub convert: Option< 287 unsafe extern "C" fn( 288 *mut GstBaseParse, 289 gst::GstFormat, 290 i64, 291 gst::GstFormat, 292 *mut i64, 293 ) -> gboolean, 294 >, 295 pub sink_event: Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstEvent) -> gboolean>, 296 pub src_event: Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstEvent) -> gboolean>, 297 pub get_sink_caps: 298 Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstCaps) -> *mut gst::GstCaps>, 299 pub detect: 300 Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstBuffer) -> gst::GstFlowReturn>, 301 pub sink_query: Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstQuery) -> gboolean>, 302 pub src_query: Option<unsafe extern "C" fn(*mut GstBaseParse, *mut gst::GstQuery) -> gboolean>, 303 pub _gst_reserved: [gpointer; 18], 304 } 305 306 impl ::std::fmt::Debug for GstBaseParseClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result307 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 308 f.debug_struct(&format!("GstBaseParseClass @ {:?}", self as *const _)) 309 .field("parent_class", &self.parent_class) 310 .field("start", &self.start) 311 .field("stop", &self.stop) 312 .field("set_sink_caps", &self.set_sink_caps) 313 .field("handle_frame", &self.handle_frame) 314 .field("pre_push_frame", &self.pre_push_frame) 315 .field("convert", &self.convert) 316 .field("sink_event", &self.sink_event) 317 .field("src_event", &self.src_event) 318 .field("get_sink_caps", &self.get_sink_caps) 319 .field("detect", &self.detect) 320 .field("sink_query", &self.sink_query) 321 .field("src_query", &self.src_query) 322 .finish() 323 } 324 } 325 326 #[repr(C)] 327 #[derive(Copy, Clone)] 328 pub struct GstBaseParseFrame { 329 pub buffer: *mut gst::GstBuffer, 330 pub out_buffer: *mut gst::GstBuffer, 331 pub flags: c_uint, 332 pub offset: u64, 333 pub overhead: c_int, 334 pub size: c_int, 335 pub _gst_reserved_i: [c_uint; 2], 336 pub _gst_reserved_p: [gpointer; 2], 337 pub _private_flags: c_uint, 338 } 339 340 impl ::std::fmt::Debug for GstBaseParseFrame { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result341 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 342 f.debug_struct(&format!("GstBaseParseFrame @ {:?}", self as *const _)) 343 .field("buffer", &self.buffer) 344 .field("out_buffer", &self.out_buffer) 345 .field("flags", &self.flags) 346 .field("offset", &self.offset) 347 .field("overhead", &self.overhead) 348 .finish() 349 } 350 } 351 352 #[repr(C)] 353 pub struct _GstBaseParsePrivate(c_void); 354 355 pub type GstBaseParsePrivate = *mut _GstBaseParsePrivate; 356 357 #[repr(C)] 358 #[derive(Copy, Clone)] 359 pub struct GstBaseSinkClass { 360 pub parent_class: gst::GstElementClass, 361 pub get_caps: 362 Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstCaps) -> *mut gst::GstCaps>, 363 pub set_caps: Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstCaps) -> gboolean>, 364 pub fixate: 365 Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstCaps) -> *mut gst::GstCaps>, 366 pub activate_pull: Option<unsafe extern "C" fn(*mut GstBaseSink, gboolean) -> gboolean>, 367 pub get_times: Option< 368 unsafe extern "C" fn( 369 *mut GstBaseSink, 370 *mut gst::GstBuffer, 371 *mut gst::GstClockTime, 372 *mut gst::GstClockTime, 373 ), 374 >, 375 pub propose_allocation: 376 Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstQuery) -> gboolean>, 377 pub start: Option<unsafe extern "C" fn(*mut GstBaseSink) -> gboolean>, 378 pub stop: Option<unsafe extern "C" fn(*mut GstBaseSink) -> gboolean>, 379 pub unlock: Option<unsafe extern "C" fn(*mut GstBaseSink) -> gboolean>, 380 pub unlock_stop: Option<unsafe extern "C" fn(*mut GstBaseSink) -> gboolean>, 381 pub query: Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstQuery) -> gboolean>, 382 pub event: Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstEvent) -> gboolean>, 383 pub wait_event: 384 Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstEvent) -> gst::GstFlowReturn>, 385 pub prepare: 386 Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstBuffer) -> gst::GstFlowReturn>, 387 pub prepare_list: Option< 388 unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstBufferList) -> gst::GstFlowReturn, 389 >, 390 pub preroll: 391 Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstBuffer) -> gst::GstFlowReturn>, 392 pub render: 393 Option<unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstBuffer) -> gst::GstFlowReturn>, 394 pub render_list: Option< 395 unsafe extern "C" fn(*mut GstBaseSink, *mut gst::GstBufferList) -> gst::GstFlowReturn, 396 >, 397 pub _gst_reserved: [gpointer; 20], 398 } 399 400 impl ::std::fmt::Debug for GstBaseSinkClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result401 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 402 f.debug_struct(&format!("GstBaseSinkClass @ {:?}", self as *const _)) 403 .field("parent_class", &self.parent_class) 404 .field("get_caps", &self.get_caps) 405 .field("set_caps", &self.set_caps) 406 .field("fixate", &self.fixate) 407 .field("activate_pull", &self.activate_pull) 408 .field("get_times", &self.get_times) 409 .field("propose_allocation", &self.propose_allocation) 410 .field("start", &self.start) 411 .field("stop", &self.stop) 412 .field("unlock", &self.unlock) 413 .field("unlock_stop", &self.unlock_stop) 414 .field("query", &self.query) 415 .field("event", &self.event) 416 .field("wait_event", &self.wait_event) 417 .field("prepare", &self.prepare) 418 .field("prepare_list", &self.prepare_list) 419 .field("preroll", &self.preroll) 420 .field("render", &self.render) 421 .field("render_list", &self.render_list) 422 .finish() 423 } 424 } 425 426 #[repr(C)] 427 pub struct _GstBaseSinkPrivate(c_void); 428 429 pub type GstBaseSinkPrivate = *mut _GstBaseSinkPrivate; 430 431 #[repr(C)] 432 #[derive(Copy, Clone)] 433 pub struct GstBaseSrcClass { 434 pub parent_class: gst::GstElementClass, 435 pub get_caps: 436 Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstCaps) -> *mut gst::GstCaps>, 437 pub negotiate: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>, 438 pub fixate: 439 Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstCaps) -> *mut gst::GstCaps>, 440 pub set_caps: Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstCaps) -> gboolean>, 441 pub decide_allocation: 442 Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstQuery) -> gboolean>, 443 pub start: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>, 444 pub stop: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>, 445 pub get_times: Option< 446 unsafe extern "C" fn( 447 *mut GstBaseSrc, 448 *mut gst::GstBuffer, 449 *mut gst::GstClockTime, 450 *mut gst::GstClockTime, 451 ), 452 >, 453 pub get_size: Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut u64) -> gboolean>, 454 pub is_seekable: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>, 455 pub prepare_seek_segment: Option< 456 unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstEvent, *mut gst::GstSegment) -> gboolean, 457 >, 458 pub do_seek: Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstSegment) -> gboolean>, 459 pub unlock: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>, 460 pub unlock_stop: Option<unsafe extern "C" fn(*mut GstBaseSrc) -> gboolean>, 461 pub query: Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstQuery) -> gboolean>, 462 pub event: Option<unsafe extern "C" fn(*mut GstBaseSrc, *mut gst::GstEvent) -> gboolean>, 463 pub create: Option< 464 unsafe extern "C" fn( 465 *mut GstBaseSrc, 466 u64, 467 c_uint, 468 *mut gst::GstBuffer, 469 ) -> gst::GstFlowReturn, 470 >, 471 pub alloc: Option< 472 unsafe extern "C" fn( 473 *mut GstBaseSrc, 474 u64, 475 c_uint, 476 *mut gst::GstBuffer, 477 ) -> gst::GstFlowReturn, 478 >, 479 pub fill: Option< 480 unsafe extern "C" fn( 481 *mut GstBaseSrc, 482 u64, 483 c_uint, 484 *mut gst::GstBuffer, 485 ) -> gst::GstFlowReturn, 486 >, 487 pub _gst_reserved: [gpointer; 20], 488 } 489 490 impl ::std::fmt::Debug for GstBaseSrcClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result491 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 492 f.debug_struct(&format!("GstBaseSrcClass @ {:?}", self as *const _)) 493 .field("parent_class", &self.parent_class) 494 .field("get_caps", &self.get_caps) 495 .field("negotiate", &self.negotiate) 496 .field("fixate", &self.fixate) 497 .field("set_caps", &self.set_caps) 498 .field("decide_allocation", &self.decide_allocation) 499 .field("start", &self.start) 500 .field("stop", &self.stop) 501 .field("get_times", &self.get_times) 502 .field("get_size", &self.get_size) 503 .field("is_seekable", &self.is_seekable) 504 .field("prepare_seek_segment", &self.prepare_seek_segment) 505 .field("do_seek", &self.do_seek) 506 .field("unlock", &self.unlock) 507 .field("unlock_stop", &self.unlock_stop) 508 .field("query", &self.query) 509 .field("event", &self.event) 510 .field("create", &self.create) 511 .field("alloc", &self.alloc) 512 .field("fill", &self.fill) 513 .finish() 514 } 515 } 516 517 #[repr(C)] 518 pub struct _GstBaseSrcPrivate(c_void); 519 520 pub type GstBaseSrcPrivate = *mut _GstBaseSrcPrivate; 521 522 #[repr(C)] 523 #[derive(Copy, Clone)] 524 pub struct GstBaseTransformClass { 525 pub parent_class: gst::GstElementClass, 526 pub passthrough_on_same_caps: gboolean, 527 pub transform_ip_on_passthrough: gboolean, 528 pub transform_caps: Option< 529 unsafe extern "C" fn( 530 *mut GstBaseTransform, 531 gst::GstPadDirection, 532 *mut gst::GstCaps, 533 *mut gst::GstCaps, 534 ) -> *mut gst::GstCaps, 535 >, 536 pub fixate_caps: Option< 537 unsafe extern "C" fn( 538 *mut GstBaseTransform, 539 gst::GstPadDirection, 540 *mut gst::GstCaps, 541 *mut gst::GstCaps, 542 ) -> *mut gst::GstCaps, 543 >, 544 pub accept_caps: Option< 545 unsafe extern "C" fn( 546 *mut GstBaseTransform, 547 gst::GstPadDirection, 548 *mut gst::GstCaps, 549 ) -> gboolean, 550 >, 551 pub set_caps: Option< 552 unsafe extern "C" fn( 553 *mut GstBaseTransform, 554 *mut gst::GstCaps, 555 *mut gst::GstCaps, 556 ) -> gboolean, 557 >, 558 pub query: Option< 559 unsafe extern "C" fn( 560 *mut GstBaseTransform, 561 gst::GstPadDirection, 562 *mut gst::GstQuery, 563 ) -> gboolean, 564 >, 565 pub decide_allocation: 566 Option<unsafe extern "C" fn(*mut GstBaseTransform, *mut gst::GstQuery) -> gboolean>, 567 pub filter_meta: Option< 568 unsafe extern "C" fn( 569 *mut GstBaseTransform, 570 *mut gst::GstQuery, 571 GType, 572 *const gst::GstStructure, 573 ) -> gboolean, 574 >, 575 pub propose_allocation: Option< 576 unsafe extern "C" fn( 577 *mut GstBaseTransform, 578 *mut gst::GstQuery, 579 *mut gst::GstQuery, 580 ) -> gboolean, 581 >, 582 pub transform_size: Option< 583 unsafe extern "C" fn( 584 *mut GstBaseTransform, 585 gst::GstPadDirection, 586 *mut gst::GstCaps, 587 size_t, 588 *mut gst::GstCaps, 589 *mut size_t, 590 ) -> gboolean, 591 >, 592 pub get_unit_size: Option< 593 unsafe extern "C" fn(*mut GstBaseTransform, *mut gst::GstCaps, *mut size_t) -> gboolean, 594 >, 595 pub start: Option<unsafe extern "C" fn(*mut GstBaseTransform) -> gboolean>, 596 pub stop: Option<unsafe extern "C" fn(*mut GstBaseTransform) -> gboolean>, 597 pub sink_event: 598 Option<unsafe extern "C" fn(*mut GstBaseTransform, *mut gst::GstEvent) -> gboolean>, 599 pub src_event: 600 Option<unsafe extern "C" fn(*mut GstBaseTransform, *mut gst::GstEvent) -> gboolean>, 601 pub prepare_output_buffer: Option< 602 unsafe extern "C" fn( 603 *mut GstBaseTransform, 604 *mut gst::GstBuffer, 605 *mut gst::GstBuffer, 606 ) -> gst::GstFlowReturn, 607 >, 608 pub copy_metadata: Option< 609 unsafe extern "C" fn( 610 *mut GstBaseTransform, 611 *mut gst::GstBuffer, 612 *mut gst::GstBuffer, 613 ) -> gboolean, 614 >, 615 pub transform_meta: Option< 616 unsafe extern "C" fn( 617 *mut GstBaseTransform, 618 *mut gst::GstBuffer, 619 *mut gst::GstMeta, 620 *mut gst::GstBuffer, 621 ) -> gboolean, 622 >, 623 pub before_transform: Option<unsafe extern "C" fn(*mut GstBaseTransform, *mut gst::GstBuffer)>, 624 pub transform: Option< 625 unsafe extern "C" fn( 626 *mut GstBaseTransform, 627 *mut gst::GstBuffer, 628 *mut gst::GstBuffer, 629 ) -> gst::GstFlowReturn, 630 >, 631 pub transform_ip: Option< 632 unsafe extern "C" fn(*mut GstBaseTransform, *mut *mut gst::GstBuffer) -> gst::GstFlowReturn, 633 >, 634 pub submit_input_buffer: Option< 635 unsafe extern "C" fn( 636 *mut GstBaseTransform, 637 gboolean, 638 *mut gst::GstBuffer, 639 ) -> gst::GstFlowReturn, 640 >, 641 pub generate_output: Option< 642 unsafe extern "C" fn(*mut GstBaseTransform, *mut *mut gst::GstBuffer) -> gst::GstFlowReturn, 643 >, 644 pub _gst_reserved: [gpointer; 18], 645 } 646 647 impl ::std::fmt::Debug for GstBaseTransformClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result648 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 649 f.debug_struct(&format!("GstBaseTransformClass @ {:?}", self as *const _)) 650 .field("parent_class", &self.parent_class) 651 .field("passthrough_on_same_caps", &self.passthrough_on_same_caps) 652 .field( 653 "transform_ip_on_passthrough", 654 &self.transform_ip_on_passthrough, 655 ) 656 .field("transform_caps", &self.transform_caps) 657 .field("fixate_caps", &self.fixate_caps) 658 .field("accept_caps", &self.accept_caps) 659 .field("set_caps", &self.set_caps) 660 .field("query", &self.query) 661 .field("decide_allocation", &self.decide_allocation) 662 .field("filter_meta", &self.filter_meta) 663 .field("propose_allocation", &self.propose_allocation) 664 .field("transform_size", &self.transform_size) 665 .field("get_unit_size", &self.get_unit_size) 666 .field("start", &self.start) 667 .field("stop", &self.stop) 668 .field("sink_event", &self.sink_event) 669 .field("src_event", &self.src_event) 670 .field("prepare_output_buffer", &self.prepare_output_buffer) 671 .field("copy_metadata", &self.copy_metadata) 672 .field("transform_meta", &self.transform_meta) 673 .field("before_transform", &self.before_transform) 674 .field("transform", &self.transform) 675 .field("transform_ip", &self.transform_ip) 676 .field("submit_input_buffer", &self.submit_input_buffer) 677 .field("generate_output", &self.generate_output) 678 .finish() 679 } 680 } 681 682 #[repr(C)] 683 pub struct _GstBaseTransformPrivate(c_void); 684 685 pub type GstBaseTransformPrivate = *mut _GstBaseTransformPrivate; 686 687 #[repr(C)] 688 #[derive(Copy, Clone)] 689 pub struct GstBitReader { 690 pub data: *const u8, 691 pub size: c_uint, 692 pub byte: c_uint, 693 pub bit: c_uint, 694 pub _gst_reserved: [gpointer; 4], 695 } 696 697 impl ::std::fmt::Debug for GstBitReader { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result698 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 699 f.debug_struct(&format!("GstBitReader @ {:?}", self as *const _)) 700 .field("data", &self.data) 701 .field("size", &self.size) 702 .field("byte", &self.byte) 703 .field("bit", &self.bit) 704 .finish() 705 } 706 } 707 708 #[repr(C)] 709 #[derive(Copy, Clone)] 710 pub struct GstBitWriter { 711 pub data: *mut u8, 712 pub bit_size: c_uint, 713 pub bit_capacity: c_uint, 714 pub auto_grow: gboolean, 715 pub owned: gboolean, 716 pub _gst_reserved: [gpointer; 4], 717 } 718 719 impl ::std::fmt::Debug for GstBitWriter { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result720 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 721 f.debug_struct(&format!("GstBitWriter @ {:?}", self as *const _)) 722 .field("data", &self.data) 723 .field("bit_size", &self.bit_size) 724 .finish() 725 } 726 } 727 728 #[repr(C)] 729 #[derive(Copy, Clone)] 730 pub struct GstByteReader { 731 pub data: *const u8, 732 pub size: c_uint, 733 pub byte: c_uint, 734 pub _gst_reserved: [gpointer; 4], 735 } 736 737 impl ::std::fmt::Debug for GstByteReader { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result738 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 739 f.debug_struct(&format!("GstByteReader @ {:?}", self as *const _)) 740 .field("data", &self.data) 741 .field("size", &self.size) 742 .field("byte", &self.byte) 743 .finish() 744 } 745 } 746 747 #[repr(C)] 748 #[derive(Copy, Clone)] 749 pub struct GstByteWriter { 750 pub parent: GstByteReader, 751 pub alloc_size: c_uint, 752 pub fixed: gboolean, 753 pub owned: gboolean, 754 pub _gst_reserved: [gpointer; 4], 755 } 756 757 impl ::std::fmt::Debug for GstByteWriter { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result758 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 759 f.debug_struct(&format!("GstByteWriter @ {:?}", self as *const _)) 760 .field("parent", &self.parent) 761 .field("alloc_size", &self.alloc_size) 762 .field("fixed", &self.fixed) 763 .field("owned", &self.owned) 764 .finish() 765 } 766 } 767 768 #[repr(C)] 769 #[derive(Copy, Clone)] 770 pub struct GstCollectData { 771 pub collect: *mut GstCollectPads, 772 pub pad: *mut gst::GstPad, 773 pub buffer: *mut gst::GstBuffer, 774 pub pos: c_uint, 775 pub segment: gst::GstSegment, 776 pub state: GstCollectPadsStateFlags, 777 pub priv_: *mut GstCollectDataPrivate, 778 pub ABI: GstCollectData_ABI, 779 } 780 781 impl ::std::fmt::Debug for GstCollectData { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result782 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 783 f.debug_struct(&format!("GstCollectData @ {:?}", self as *const _)) 784 .field("collect", &self.collect) 785 .field("pad", &self.pad) 786 .field("buffer", &self.buffer) 787 .field("pos", &self.pos) 788 .field("segment", &self.segment) 789 .field("ABI", &self.ABI) 790 .finish() 791 } 792 } 793 794 #[repr(C)] 795 pub struct _GstCollectDataPrivate(c_void); 796 797 pub type GstCollectDataPrivate = *mut _GstCollectDataPrivate; 798 799 #[repr(C)] 800 #[derive(Copy, Clone)] 801 pub struct GstCollectData_ABI_abi { 802 pub dts: i64, 803 } 804 805 impl ::std::fmt::Debug for GstCollectData_ABI_abi { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result806 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 807 f.debug_struct(&format!("GstCollectData_ABI_abi @ {:?}", self as *const _)) 808 .field("dts", &self.dts) 809 .finish() 810 } 811 } 812 813 #[repr(C)] 814 #[derive(Copy, Clone)] 815 pub struct GstCollectPadsClass { 816 pub parent_class: gst::GstObjectClass, 817 pub _gst_reserved: [gpointer; 4], 818 } 819 820 impl ::std::fmt::Debug for GstCollectPadsClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result821 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 822 f.debug_struct(&format!("GstCollectPadsClass @ {:?}", self as *const _)) 823 .field("parent_class", &self.parent_class) 824 .finish() 825 } 826 } 827 828 #[repr(C)] 829 pub struct _GstCollectPadsPrivate(c_void); 830 831 pub type GstCollectPadsPrivate = *mut _GstCollectPadsPrivate; 832 833 #[repr(C)] 834 #[derive(Copy, Clone)] 835 pub struct GstDataQueueClass { 836 pub parent_class: gobject::GObjectClass, 837 pub empty: Option<unsafe extern "C" fn(*mut GstDataQueue)>, 838 pub full: Option<unsafe extern "C" fn(*mut GstDataQueue)>, 839 pub _gst_reserved: [gpointer; 4], 840 } 841 842 impl ::std::fmt::Debug for GstDataQueueClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result843 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 844 f.debug_struct(&format!("GstDataQueueClass @ {:?}", self as *const _)) 845 .field("parent_class", &self.parent_class) 846 .field("empty", &self.empty) 847 .field("full", &self.full) 848 .field("_gst_reserved", &self._gst_reserved) 849 .finish() 850 } 851 } 852 853 #[repr(C)] 854 #[derive(Copy, Clone)] 855 pub struct GstDataQueueItem { 856 pub object: *mut gst::GstMiniObject, 857 pub size: c_uint, 858 pub duration: u64, 859 pub visible: gboolean, 860 pub destroy: glib::GDestroyNotify, 861 pub _gst_reserved: [gpointer; 4], 862 } 863 864 impl ::std::fmt::Debug for GstDataQueueItem { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result865 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 866 f.debug_struct(&format!("GstDataQueueItem @ {:?}", self as *const _)) 867 .field("object", &self.object) 868 .field("size", &self.size) 869 .field("duration", &self.duration) 870 .field("visible", &self.visible) 871 .field("destroy", &self.destroy) 872 .finish() 873 } 874 } 875 876 #[repr(C)] 877 pub struct _GstDataQueuePrivate(c_void); 878 879 pub type GstDataQueuePrivate = *mut _GstDataQueuePrivate; 880 881 #[repr(C)] 882 #[derive(Copy, Clone)] 883 pub struct GstDataQueueSize { 884 pub visible: c_uint, 885 pub bytes: c_uint, 886 pub time: u64, 887 } 888 889 impl ::std::fmt::Debug for GstDataQueueSize { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result890 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 891 f.debug_struct(&format!("GstDataQueueSize @ {:?}", self as *const _)) 892 .field("visible", &self.visible) 893 .field("bytes", &self.bytes) 894 .field("time", &self.time) 895 .finish() 896 } 897 } 898 899 #[repr(C)] 900 pub struct GstFlowCombiner(c_void); 901 902 impl ::std::fmt::Debug for GstFlowCombiner { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result903 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 904 f.debug_struct(&format!("GstFlowCombiner @ {:?}", self as *const _)) 905 .finish() 906 } 907 } 908 909 #[repr(C)] 910 #[derive(Copy, Clone)] 911 pub struct GstPushSrcClass { 912 pub parent_class: GstBaseSrcClass, 913 pub create: 914 Option<unsafe extern "C" fn(*mut GstPushSrc, *mut gst::GstBuffer) -> gst::GstFlowReturn>, 915 pub alloc: 916 Option<unsafe extern "C" fn(*mut GstPushSrc, *mut gst::GstBuffer) -> gst::GstFlowReturn>, 917 pub fill: 918 Option<unsafe extern "C" fn(*mut GstPushSrc, *mut gst::GstBuffer) -> gst::GstFlowReturn>, 919 pub _gst_reserved: [gpointer; 4], 920 } 921 922 impl ::std::fmt::Debug for GstPushSrcClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result923 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 924 f.debug_struct(&format!("GstPushSrcClass @ {:?}", self as *const _)) 925 .field("parent_class", &self.parent_class) 926 .field("create", &self.create) 927 .field("alloc", &self.alloc) 928 .field("fill", &self.fill) 929 .finish() 930 } 931 } 932 933 #[repr(C)] 934 pub struct _GstQueueArray(c_void); 935 936 pub type GstQueueArray = *mut _GstQueueArray; 937 938 // Classes 939 #[repr(C)] 940 pub struct GstAdapter(c_void); 941 942 impl ::std::fmt::Debug for GstAdapter { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result943 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 944 f.debug_struct(&format!("GstAdapter @ {:?}", self as *const _)) 945 .finish() 946 } 947 } 948 949 #[repr(C)] 950 #[derive(Copy, Clone)] 951 pub struct GstAggregator { 952 pub parent: gst::GstElement, 953 pub srcpad: *mut gst::GstPad, 954 pub priv_: *mut GstAggregatorPrivate, 955 pub _gst_reserved: [gpointer; 20], 956 } 957 958 impl ::std::fmt::Debug for GstAggregator { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result959 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 960 f.debug_struct(&format!("GstAggregator @ {:?}", self as *const _)) 961 .field("parent", &self.parent) 962 .field("srcpad", &self.srcpad) 963 .finish() 964 } 965 } 966 967 #[repr(C)] 968 #[derive(Copy, Clone)] 969 pub struct GstAggregatorPad { 970 pub parent: gst::GstPad, 971 pub segment: gst::GstSegment, 972 pub priv_: *mut GstAggregatorPadPrivate, 973 pub _gst_reserved: [gpointer; 4], 974 } 975 976 impl ::std::fmt::Debug for GstAggregatorPad { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result977 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 978 f.debug_struct(&format!("GstAggregatorPad @ {:?}", self as *const _)) 979 .field("parent", &self.parent) 980 .field("segment", &self.segment) 981 .finish() 982 } 983 } 984 985 #[repr(C)] 986 #[derive(Copy, Clone)] 987 pub struct GstBaseParse { 988 pub element: gst::GstElement, 989 pub sinkpad: *mut gst::GstPad, 990 pub srcpad: *mut gst::GstPad, 991 pub flags: c_uint, 992 pub segment: gst::GstSegment, 993 pub _gst_reserved: [gpointer; 20], 994 pub priv_: *mut GstBaseParsePrivate, 995 } 996 997 impl ::std::fmt::Debug for GstBaseParse { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result998 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 999 f.debug_struct(&format!("GstBaseParse @ {:?}", self as *const _)) 1000 .field("element", &self.element) 1001 .field("sinkpad", &self.sinkpad) 1002 .field("srcpad", &self.srcpad) 1003 .field("flags", &self.flags) 1004 .field("segment", &self.segment) 1005 .finish() 1006 } 1007 } 1008 1009 #[repr(C)] 1010 #[derive(Copy, Clone)] 1011 pub struct GstBaseSink { 1012 pub element: gst::GstElement, 1013 pub sinkpad: *mut gst::GstPad, 1014 pub pad_mode: gst::GstPadMode, 1015 pub offset: u64, 1016 pub can_activate_pull: gboolean, 1017 pub can_activate_push: gboolean, 1018 pub preroll_lock: glib::GMutex, 1019 pub preroll_cond: glib::GCond, 1020 pub eos: gboolean, 1021 pub need_preroll: gboolean, 1022 pub have_preroll: gboolean, 1023 pub playing_async: gboolean, 1024 pub have_newsegment: gboolean, 1025 pub segment: gst::GstSegment, 1026 pub clock_id: gst::GstClockID, 1027 pub sync: gboolean, 1028 pub flushing: gboolean, 1029 pub running: gboolean, 1030 pub max_lateness: i64, 1031 pub priv_: *mut GstBaseSinkPrivate, 1032 pub _gst_reserved: [gpointer; 20], 1033 } 1034 1035 impl ::std::fmt::Debug for GstBaseSink { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1036 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1037 f.debug_struct(&format!("GstBaseSink @ {:?}", self as *const _)) 1038 .field("element", &self.element) 1039 .field("sinkpad", &self.sinkpad) 1040 .field("pad_mode", &self.pad_mode) 1041 .field("offset", &self.offset) 1042 .field("can_activate_pull", &self.can_activate_pull) 1043 .field("can_activate_push", &self.can_activate_push) 1044 .field("preroll_lock", &self.preroll_lock) 1045 .field("preroll_cond", &self.preroll_cond) 1046 .field("eos", &self.eos) 1047 .field("need_preroll", &self.need_preroll) 1048 .field("have_preroll", &self.have_preroll) 1049 .field("playing_async", &self.playing_async) 1050 .field("have_newsegment", &self.have_newsegment) 1051 .field("segment", &self.segment) 1052 .finish() 1053 } 1054 } 1055 1056 #[repr(C)] 1057 #[derive(Copy, Clone)] 1058 pub struct GstBaseSrc { 1059 pub element: gst::GstElement, 1060 pub srcpad: *mut gst::GstPad, 1061 pub live_lock: glib::GMutex, 1062 pub live_cond: glib::GCond, 1063 pub is_live: gboolean, 1064 pub live_running: gboolean, 1065 pub blocksize: c_uint, 1066 pub can_activate_push: gboolean, 1067 pub random_access: gboolean, 1068 pub clock_id: gst::GstClockID, 1069 pub segment: gst::GstSegment, 1070 pub need_newsegment: gboolean, 1071 pub num_buffers: c_int, 1072 pub num_buffers_left: c_int, 1073 pub typefind: gboolean, 1074 pub running: gboolean, 1075 pub pending_seek: *mut gst::GstEvent, 1076 pub priv_: *mut GstBaseSrcPrivate, 1077 pub _gst_reserved: [gpointer; 20], 1078 } 1079 1080 impl ::std::fmt::Debug for GstBaseSrc { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1081 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1082 f.debug_struct(&format!("GstBaseSrc @ {:?}", self as *const _)) 1083 .field("element", &self.element) 1084 .field("srcpad", &self.srcpad) 1085 .field("live_lock", &self.live_lock) 1086 .field("live_cond", &self.live_cond) 1087 .field("is_live", &self.is_live) 1088 .field("live_running", &self.live_running) 1089 .field("blocksize", &self.blocksize) 1090 .field("can_activate_push", &self.can_activate_push) 1091 .field("random_access", &self.random_access) 1092 .field("clock_id", &self.clock_id) 1093 .field("segment", &self.segment) 1094 .field("need_newsegment", &self.need_newsegment) 1095 .field("num_buffers", &self.num_buffers) 1096 .field("num_buffers_left", &self.num_buffers_left) 1097 .field("typefind", &self.typefind) 1098 .field("running", &self.running) 1099 .field("pending_seek", &self.pending_seek) 1100 .field("priv_", &self.priv_) 1101 .finish() 1102 } 1103 } 1104 1105 #[repr(C)] 1106 #[derive(Copy, Clone)] 1107 pub struct GstBaseTransform { 1108 pub element: gst::GstElement, 1109 pub sinkpad: *mut gst::GstPad, 1110 pub srcpad: *mut gst::GstPad, 1111 pub have_segment: gboolean, 1112 pub segment: gst::GstSegment, 1113 pub queued_buf: *mut gst::GstBuffer, 1114 pub priv_: *mut GstBaseTransformPrivate, 1115 pub _gst_reserved: [gpointer; 19], 1116 } 1117 1118 impl ::std::fmt::Debug for GstBaseTransform { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1119 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1120 f.debug_struct(&format!("GstBaseTransform @ {:?}", self as *const _)) 1121 .field("element", &self.element) 1122 .field("sinkpad", &self.sinkpad) 1123 .field("srcpad", &self.srcpad) 1124 .field("have_segment", &self.have_segment) 1125 .field("segment", &self.segment) 1126 .field("queued_buf", &self.queued_buf) 1127 .finish() 1128 } 1129 } 1130 1131 #[repr(C)] 1132 #[derive(Copy, Clone)] 1133 pub struct GstCollectPads { 1134 pub object: gst::GstObject, 1135 pub data: *mut glib::GSList, 1136 pub stream_lock: glib::GRecMutex, 1137 pub priv_: *mut GstCollectPadsPrivate, 1138 pub _gst_reserved: [gpointer; 4], 1139 } 1140 1141 impl ::std::fmt::Debug for GstCollectPads { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1142 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1143 f.debug_struct(&format!("GstCollectPads @ {:?}", self as *const _)) 1144 .field("object", &self.object) 1145 .field("data", &self.data) 1146 .finish() 1147 } 1148 } 1149 1150 #[repr(C)] 1151 #[derive(Copy, Clone)] 1152 pub struct GstDataQueue { 1153 pub object: gobject::GObject, 1154 pub priv_: *mut GstDataQueuePrivate, 1155 pub _gst_reserved: [gpointer; 4], 1156 } 1157 1158 impl ::std::fmt::Debug for GstDataQueue { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1159 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1160 f.debug_struct(&format!("GstDataQueue @ {:?}", self as *const _)) 1161 .field("object", &self.object) 1162 .finish() 1163 } 1164 } 1165 1166 #[repr(C)] 1167 #[derive(Copy, Clone)] 1168 pub struct GstPushSrc { 1169 pub parent: GstBaseSrc, 1170 pub _gst_reserved: [gpointer; 4], 1171 } 1172 1173 impl ::std::fmt::Debug for GstPushSrc { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1174 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1175 f.debug_struct(&format!("GstPushSrc @ {:?}", self as *const _)) 1176 .field("parent", &self.parent) 1177 .finish() 1178 } 1179 } 1180 1181 extern "C" { 1182 1183 //========================================================================= 1184 // GstBaseParseFrame 1185 //========================================================================= gst_base_parse_frame_get_type() -> GType1186 pub fn gst_base_parse_frame_get_type() -> GType; gst_base_parse_frame_new( buffer: *mut gst::GstBuffer, flags: GstBaseParseFrameFlags, overhead: c_int, ) -> *mut GstBaseParseFrame1187 pub fn gst_base_parse_frame_new( 1188 buffer: *mut gst::GstBuffer, 1189 flags: GstBaseParseFrameFlags, 1190 overhead: c_int, 1191 ) -> *mut GstBaseParseFrame; gst_base_parse_frame_copy(frame: *mut GstBaseParseFrame) -> *mut GstBaseParseFrame1192 pub fn gst_base_parse_frame_copy(frame: *mut GstBaseParseFrame) -> *mut GstBaseParseFrame; gst_base_parse_frame_free(frame: *mut GstBaseParseFrame)1193 pub fn gst_base_parse_frame_free(frame: *mut GstBaseParseFrame); gst_base_parse_frame_init(frame: *mut GstBaseParseFrame)1194 pub fn gst_base_parse_frame_init(frame: *mut GstBaseParseFrame); 1195 1196 //========================================================================= 1197 // GstBitReader 1198 //========================================================================= gst_bit_reader_free(reader: *mut GstBitReader)1199 pub fn gst_bit_reader_free(reader: *mut GstBitReader); gst_bit_reader_get_bits_uint16( reader: *mut GstBitReader, val: *mut u16, nbits: c_uint, ) -> gboolean1200 pub fn gst_bit_reader_get_bits_uint16( 1201 reader: *mut GstBitReader, 1202 val: *mut u16, 1203 nbits: c_uint, 1204 ) -> gboolean; gst_bit_reader_get_bits_uint32( reader: *mut GstBitReader, val: *mut u32, nbits: c_uint, ) -> gboolean1205 pub fn gst_bit_reader_get_bits_uint32( 1206 reader: *mut GstBitReader, 1207 val: *mut u32, 1208 nbits: c_uint, 1209 ) -> gboolean; gst_bit_reader_get_bits_uint64( reader: *mut GstBitReader, val: *mut u64, nbits: c_uint, ) -> gboolean1210 pub fn gst_bit_reader_get_bits_uint64( 1211 reader: *mut GstBitReader, 1212 val: *mut u64, 1213 nbits: c_uint, 1214 ) -> gboolean; gst_bit_reader_get_bits_uint8( reader: *mut GstBitReader, val: *mut u8, nbits: c_uint, ) -> gboolean1215 pub fn gst_bit_reader_get_bits_uint8( 1216 reader: *mut GstBitReader, 1217 val: *mut u8, 1218 nbits: c_uint, 1219 ) -> gboolean; gst_bit_reader_get_pos(reader: *const GstBitReader) -> c_uint1220 pub fn gst_bit_reader_get_pos(reader: *const GstBitReader) -> c_uint; gst_bit_reader_get_remaining(reader: *const GstBitReader) -> c_uint1221 pub fn gst_bit_reader_get_remaining(reader: *const GstBitReader) -> c_uint; gst_bit_reader_get_size(reader: *const GstBitReader) -> c_uint1222 pub fn gst_bit_reader_get_size(reader: *const GstBitReader) -> c_uint; gst_bit_reader_init(reader: *mut GstBitReader, data: *const u8, size: c_uint)1223 pub fn gst_bit_reader_init(reader: *mut GstBitReader, data: *const u8, size: c_uint); gst_bit_reader_peek_bits_uint16( reader: *const GstBitReader, val: *mut u16, nbits: c_uint, ) -> gboolean1224 pub fn gst_bit_reader_peek_bits_uint16( 1225 reader: *const GstBitReader, 1226 val: *mut u16, 1227 nbits: c_uint, 1228 ) -> gboolean; gst_bit_reader_peek_bits_uint32( reader: *const GstBitReader, val: *mut u32, nbits: c_uint, ) -> gboolean1229 pub fn gst_bit_reader_peek_bits_uint32( 1230 reader: *const GstBitReader, 1231 val: *mut u32, 1232 nbits: c_uint, 1233 ) -> gboolean; gst_bit_reader_peek_bits_uint64( reader: *const GstBitReader, val: *mut u64, nbits: c_uint, ) -> gboolean1234 pub fn gst_bit_reader_peek_bits_uint64( 1235 reader: *const GstBitReader, 1236 val: *mut u64, 1237 nbits: c_uint, 1238 ) -> gboolean; gst_bit_reader_peek_bits_uint8( reader: *const GstBitReader, val: *mut u8, nbits: c_uint, ) -> gboolean1239 pub fn gst_bit_reader_peek_bits_uint8( 1240 reader: *const GstBitReader, 1241 val: *mut u8, 1242 nbits: c_uint, 1243 ) -> gboolean; gst_bit_reader_set_pos(reader: *mut GstBitReader, pos: c_uint) -> gboolean1244 pub fn gst_bit_reader_set_pos(reader: *mut GstBitReader, pos: c_uint) -> gboolean; gst_bit_reader_skip(reader: *mut GstBitReader, nbits: c_uint) -> gboolean1245 pub fn gst_bit_reader_skip(reader: *mut GstBitReader, nbits: c_uint) -> gboolean; gst_bit_reader_skip_to_byte(reader: *mut GstBitReader) -> gboolean1246 pub fn gst_bit_reader_skip_to_byte(reader: *mut GstBitReader) -> gboolean; gst_bit_reader_new(data: *const u8, size: c_uint) -> *mut GstBitReader1247 pub fn gst_bit_reader_new(data: *const u8, size: c_uint) -> *mut GstBitReader; 1248 1249 //========================================================================= 1250 // GstBitWriter 1251 //========================================================================= 1252 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_align_bytes(bitwriter: *mut GstBitWriter, trailing_bit: u8) -> gboolean1253 pub fn gst_bit_writer_align_bytes(bitwriter: *mut GstBitWriter, trailing_bit: u8) -> gboolean; 1254 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_free(bitwriter: *mut GstBitWriter)1255 pub fn gst_bit_writer_free(bitwriter: *mut GstBitWriter); 1256 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_free_and_get_buffer(bitwriter: *mut GstBitWriter) -> *mut gst::GstBuffer1257 pub fn gst_bit_writer_free_and_get_buffer(bitwriter: *mut GstBitWriter) -> *mut gst::GstBuffer; 1258 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_free_and_get_data(bitwriter: *mut GstBitWriter) -> *mut u81259 pub fn gst_bit_writer_free_and_get_data(bitwriter: *mut GstBitWriter) -> *mut u8; 1260 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_get_data(bitwriter: *const GstBitWriter) -> *mut u81261 pub fn gst_bit_writer_get_data(bitwriter: *const GstBitWriter) -> *mut u8; 1262 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_get_remaining(bitwriter: *const GstBitWriter) -> c_uint1263 pub fn gst_bit_writer_get_remaining(bitwriter: *const GstBitWriter) -> c_uint; 1264 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_get_size(bitwriter: *const GstBitWriter) -> c_uint1265 pub fn gst_bit_writer_get_size(bitwriter: *const GstBitWriter) -> c_uint; 1266 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_init(bitwriter: *mut GstBitWriter)1267 pub fn gst_bit_writer_init(bitwriter: *mut GstBitWriter); 1268 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_init_with_data( bitwriter: *mut GstBitWriter, data: *mut u8, size: c_uint, initialized: gboolean, )1269 pub fn gst_bit_writer_init_with_data( 1270 bitwriter: *mut GstBitWriter, 1271 data: *mut u8, 1272 size: c_uint, 1273 initialized: gboolean, 1274 ); 1275 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_init_with_size(bitwriter: *mut GstBitWriter, size: u32, fixed: gboolean)1276 pub fn gst_bit_writer_init_with_size(bitwriter: *mut GstBitWriter, size: u32, fixed: gboolean); 1277 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_put_bits_uint16( bitwriter: *mut GstBitWriter, value: u16, nbits: c_uint, ) -> gboolean1278 pub fn gst_bit_writer_put_bits_uint16( 1279 bitwriter: *mut GstBitWriter, 1280 value: u16, 1281 nbits: c_uint, 1282 ) -> gboolean; 1283 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_put_bits_uint32( bitwriter: *mut GstBitWriter, value: u32, nbits: c_uint, ) -> gboolean1284 pub fn gst_bit_writer_put_bits_uint32( 1285 bitwriter: *mut GstBitWriter, 1286 value: u32, 1287 nbits: c_uint, 1288 ) -> gboolean; 1289 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_put_bits_uint64( bitwriter: *mut GstBitWriter, value: u64, nbits: c_uint, ) -> gboolean1290 pub fn gst_bit_writer_put_bits_uint64( 1291 bitwriter: *mut GstBitWriter, 1292 value: u64, 1293 nbits: c_uint, 1294 ) -> gboolean; 1295 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_put_bits_uint8( bitwriter: *mut GstBitWriter, value: u8, nbits: c_uint, ) -> gboolean1296 pub fn gst_bit_writer_put_bits_uint8( 1297 bitwriter: *mut GstBitWriter, 1298 value: u8, 1299 nbits: c_uint, 1300 ) -> gboolean; 1301 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_put_bytes( bitwriter: *mut GstBitWriter, data: *const u8, nbytes: c_uint, ) -> gboolean1302 pub fn gst_bit_writer_put_bytes( 1303 bitwriter: *mut GstBitWriter, 1304 data: *const u8, 1305 nbytes: c_uint, 1306 ) -> gboolean; 1307 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_reset(bitwriter: *mut GstBitWriter)1308 pub fn gst_bit_writer_reset(bitwriter: *mut GstBitWriter); 1309 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_reset_and_get_buffer(bitwriter: *mut GstBitWriter) -> *mut gst::GstBuffer1310 pub fn gst_bit_writer_reset_and_get_buffer(bitwriter: *mut GstBitWriter) 1311 -> *mut gst::GstBuffer; 1312 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_reset_and_get_data(bitwriter: *mut GstBitWriter) -> *mut u81313 pub fn gst_bit_writer_reset_and_get_data(bitwriter: *mut GstBitWriter) -> *mut u8; 1314 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_set_pos(bitwriter: *mut GstBitWriter, pos: c_uint) -> gboolean1315 pub fn gst_bit_writer_set_pos(bitwriter: *mut GstBitWriter, pos: c_uint) -> gboolean; 1316 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_new() -> *mut GstBitWriter1317 pub fn gst_bit_writer_new() -> *mut GstBitWriter; 1318 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_new_with_data( data: *mut u8, size: c_uint, initialized: gboolean, ) -> *mut GstBitWriter1319 pub fn gst_bit_writer_new_with_data( 1320 data: *mut u8, 1321 size: c_uint, 1322 initialized: gboolean, 1323 ) -> *mut GstBitWriter; 1324 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_bit_writer_new_with_size(size: u32, fixed: gboolean) -> *mut GstBitWriter1325 pub fn gst_bit_writer_new_with_size(size: u32, fixed: gboolean) -> *mut GstBitWriter; 1326 1327 //========================================================================= 1328 // GstByteReader 1329 //========================================================================= gst_byte_reader_dup_data( reader: *mut GstByteReader, size: c_uint, val: *mut *mut u8, ) -> gboolean1330 pub fn gst_byte_reader_dup_data( 1331 reader: *mut GstByteReader, 1332 size: c_uint, 1333 val: *mut *mut u8, 1334 ) -> gboolean; gst_byte_reader_dup_string_utf16( reader: *mut GstByteReader, str: *mut *mut u16, ) -> gboolean1335 pub fn gst_byte_reader_dup_string_utf16( 1336 reader: *mut GstByteReader, 1337 str: *mut *mut u16, 1338 ) -> gboolean; gst_byte_reader_dup_string_utf32( reader: *mut GstByteReader, str: *mut *mut u32, ) -> gboolean1339 pub fn gst_byte_reader_dup_string_utf32( 1340 reader: *mut GstByteReader, 1341 str: *mut *mut u32, 1342 ) -> gboolean; gst_byte_reader_dup_string_utf8( reader: *mut GstByteReader, str: *mut *mut c_char, ) -> gboolean1343 pub fn gst_byte_reader_dup_string_utf8( 1344 reader: *mut GstByteReader, 1345 str: *mut *mut c_char, 1346 ) -> gboolean; gst_byte_reader_free(reader: *mut GstByteReader)1347 pub fn gst_byte_reader_free(reader: *mut GstByteReader); gst_byte_reader_get_data( reader: *mut GstByteReader, size: c_uint, val: *mut *const u8, ) -> gboolean1348 pub fn gst_byte_reader_get_data( 1349 reader: *mut GstByteReader, 1350 size: c_uint, 1351 val: *mut *const u8, 1352 ) -> gboolean; gst_byte_reader_get_float32_be( reader: *mut GstByteReader, val: *mut c_float, ) -> gboolean1353 pub fn gst_byte_reader_get_float32_be( 1354 reader: *mut GstByteReader, 1355 val: *mut c_float, 1356 ) -> gboolean; gst_byte_reader_get_float32_le( reader: *mut GstByteReader, val: *mut c_float, ) -> gboolean1357 pub fn gst_byte_reader_get_float32_le( 1358 reader: *mut GstByteReader, 1359 val: *mut c_float, 1360 ) -> gboolean; gst_byte_reader_get_float64_be( reader: *mut GstByteReader, val: *mut c_double, ) -> gboolean1361 pub fn gst_byte_reader_get_float64_be( 1362 reader: *mut GstByteReader, 1363 val: *mut c_double, 1364 ) -> gboolean; gst_byte_reader_get_float64_le( reader: *mut GstByteReader, val: *mut c_double, ) -> gboolean1365 pub fn gst_byte_reader_get_float64_le( 1366 reader: *mut GstByteReader, 1367 val: *mut c_double, 1368 ) -> gboolean; gst_byte_reader_get_int16_be(reader: *mut GstByteReader, val: *mut i16) -> gboolean1369 pub fn gst_byte_reader_get_int16_be(reader: *mut GstByteReader, val: *mut i16) -> gboolean; gst_byte_reader_get_int16_le(reader: *mut GstByteReader, val: *mut i16) -> gboolean1370 pub fn gst_byte_reader_get_int16_le(reader: *mut GstByteReader, val: *mut i16) -> gboolean; gst_byte_reader_get_int24_be(reader: *mut GstByteReader, val: *mut i32) -> gboolean1371 pub fn gst_byte_reader_get_int24_be(reader: *mut GstByteReader, val: *mut i32) -> gboolean; gst_byte_reader_get_int24_le(reader: *mut GstByteReader, val: *mut i32) -> gboolean1372 pub fn gst_byte_reader_get_int24_le(reader: *mut GstByteReader, val: *mut i32) -> gboolean; gst_byte_reader_get_int32_be(reader: *mut GstByteReader, val: *mut i32) -> gboolean1373 pub fn gst_byte_reader_get_int32_be(reader: *mut GstByteReader, val: *mut i32) -> gboolean; gst_byte_reader_get_int32_le(reader: *mut GstByteReader, val: *mut i32) -> gboolean1374 pub fn gst_byte_reader_get_int32_le(reader: *mut GstByteReader, val: *mut i32) -> gboolean; gst_byte_reader_get_int64_be(reader: *mut GstByteReader, val: *mut i64) -> gboolean1375 pub fn gst_byte_reader_get_int64_be(reader: *mut GstByteReader, val: *mut i64) -> gboolean; gst_byte_reader_get_int64_le(reader: *mut GstByteReader, val: *mut i64) -> gboolean1376 pub fn gst_byte_reader_get_int64_le(reader: *mut GstByteReader, val: *mut i64) -> gboolean; gst_byte_reader_get_int8(reader: *mut GstByteReader, val: *mut i8) -> gboolean1377 pub fn gst_byte_reader_get_int8(reader: *mut GstByteReader, val: *mut i8) -> gboolean; gst_byte_reader_get_pos(reader: *const GstByteReader) -> c_uint1378 pub fn gst_byte_reader_get_pos(reader: *const GstByteReader) -> c_uint; gst_byte_reader_get_remaining(reader: *const GstByteReader) -> c_uint1379 pub fn gst_byte_reader_get_remaining(reader: *const GstByteReader) -> c_uint; gst_byte_reader_get_size(reader: *const GstByteReader) -> c_uint1380 pub fn gst_byte_reader_get_size(reader: *const GstByteReader) -> c_uint; gst_byte_reader_get_string_utf8( reader: *mut GstByteReader, str: *mut *const c_char, ) -> gboolean1381 pub fn gst_byte_reader_get_string_utf8( 1382 reader: *mut GstByteReader, 1383 str: *mut *const c_char, 1384 ) -> gboolean; 1385 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_byte_reader_get_sub_reader( reader: *mut GstByteReader, sub_reader: *mut GstByteReader, size: c_uint, ) -> gboolean1386 pub fn gst_byte_reader_get_sub_reader( 1387 reader: *mut GstByteReader, 1388 sub_reader: *mut GstByteReader, 1389 size: c_uint, 1390 ) -> gboolean; gst_byte_reader_get_uint16_be(reader: *mut GstByteReader, val: *mut u16) -> gboolean1391 pub fn gst_byte_reader_get_uint16_be(reader: *mut GstByteReader, val: *mut u16) -> gboolean; gst_byte_reader_get_uint16_le(reader: *mut GstByteReader, val: *mut u16) -> gboolean1392 pub fn gst_byte_reader_get_uint16_le(reader: *mut GstByteReader, val: *mut u16) -> gboolean; gst_byte_reader_get_uint24_be(reader: *mut GstByteReader, val: *mut u32) -> gboolean1393 pub fn gst_byte_reader_get_uint24_be(reader: *mut GstByteReader, val: *mut u32) -> gboolean; gst_byte_reader_get_uint24_le(reader: *mut GstByteReader, val: *mut u32) -> gboolean1394 pub fn gst_byte_reader_get_uint24_le(reader: *mut GstByteReader, val: *mut u32) -> gboolean; gst_byte_reader_get_uint32_be(reader: *mut GstByteReader, val: *mut u32) -> gboolean1395 pub fn gst_byte_reader_get_uint32_be(reader: *mut GstByteReader, val: *mut u32) -> gboolean; gst_byte_reader_get_uint32_le(reader: *mut GstByteReader, val: *mut u32) -> gboolean1396 pub fn gst_byte_reader_get_uint32_le(reader: *mut GstByteReader, val: *mut u32) -> gboolean; gst_byte_reader_get_uint64_be(reader: *mut GstByteReader, val: *mut u64) -> gboolean1397 pub fn gst_byte_reader_get_uint64_be(reader: *mut GstByteReader, val: *mut u64) -> gboolean; gst_byte_reader_get_uint64_le(reader: *mut GstByteReader, val: *mut u64) -> gboolean1398 pub fn gst_byte_reader_get_uint64_le(reader: *mut GstByteReader, val: *mut u64) -> gboolean; gst_byte_reader_get_uint8(reader: *mut GstByteReader, val: *mut u8) -> gboolean1399 pub fn gst_byte_reader_get_uint8(reader: *mut GstByteReader, val: *mut u8) -> gboolean; gst_byte_reader_init(reader: *mut GstByteReader, data: *const u8, size: c_uint)1400 pub fn gst_byte_reader_init(reader: *mut GstByteReader, data: *const u8, size: c_uint); gst_byte_reader_masked_scan_uint32( reader: *const GstByteReader, mask: u32, pattern: u32, offset: c_uint, size: c_uint, ) -> c_uint1401 pub fn gst_byte_reader_masked_scan_uint32( 1402 reader: *const GstByteReader, 1403 mask: u32, 1404 pattern: u32, 1405 offset: c_uint, 1406 size: c_uint, 1407 ) -> c_uint; 1408 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_byte_reader_masked_scan_uint32_peek( reader: *const GstByteReader, mask: u32, pattern: u32, offset: c_uint, size: c_uint, value: *mut u32, ) -> c_uint1409 pub fn gst_byte_reader_masked_scan_uint32_peek( 1410 reader: *const GstByteReader, 1411 mask: u32, 1412 pattern: u32, 1413 offset: c_uint, 1414 size: c_uint, 1415 value: *mut u32, 1416 ) -> c_uint; gst_byte_reader_peek_data( reader: *const GstByteReader, size: c_uint, val: *mut *const u8, ) -> gboolean1417 pub fn gst_byte_reader_peek_data( 1418 reader: *const GstByteReader, 1419 size: c_uint, 1420 val: *mut *const u8, 1421 ) -> gboolean; gst_byte_reader_peek_float32_be( reader: *const GstByteReader, val: *mut c_float, ) -> gboolean1422 pub fn gst_byte_reader_peek_float32_be( 1423 reader: *const GstByteReader, 1424 val: *mut c_float, 1425 ) -> gboolean; gst_byte_reader_peek_float32_le( reader: *const GstByteReader, val: *mut c_float, ) -> gboolean1426 pub fn gst_byte_reader_peek_float32_le( 1427 reader: *const GstByteReader, 1428 val: *mut c_float, 1429 ) -> gboolean; gst_byte_reader_peek_float64_be( reader: *const GstByteReader, val: *mut c_double, ) -> gboolean1430 pub fn gst_byte_reader_peek_float64_be( 1431 reader: *const GstByteReader, 1432 val: *mut c_double, 1433 ) -> gboolean; gst_byte_reader_peek_float64_le( reader: *const GstByteReader, val: *mut c_double, ) -> gboolean1434 pub fn gst_byte_reader_peek_float64_le( 1435 reader: *const GstByteReader, 1436 val: *mut c_double, 1437 ) -> gboolean; gst_byte_reader_peek_int16_be(reader: *const GstByteReader, val: *mut i16) -> gboolean1438 pub fn gst_byte_reader_peek_int16_be(reader: *const GstByteReader, val: *mut i16) -> gboolean; gst_byte_reader_peek_int16_le(reader: *const GstByteReader, val: *mut i16) -> gboolean1439 pub fn gst_byte_reader_peek_int16_le(reader: *const GstByteReader, val: *mut i16) -> gboolean; gst_byte_reader_peek_int24_be(reader: *const GstByteReader, val: *mut i32) -> gboolean1440 pub fn gst_byte_reader_peek_int24_be(reader: *const GstByteReader, val: *mut i32) -> gboolean; gst_byte_reader_peek_int24_le(reader: *const GstByteReader, val: *mut i32) -> gboolean1441 pub fn gst_byte_reader_peek_int24_le(reader: *const GstByteReader, val: *mut i32) -> gboolean; gst_byte_reader_peek_int32_be(reader: *const GstByteReader, val: *mut i32) -> gboolean1442 pub fn gst_byte_reader_peek_int32_be(reader: *const GstByteReader, val: *mut i32) -> gboolean; gst_byte_reader_peek_int32_le(reader: *const GstByteReader, val: *mut i32) -> gboolean1443 pub fn gst_byte_reader_peek_int32_le(reader: *const GstByteReader, val: *mut i32) -> gboolean; gst_byte_reader_peek_int64_be(reader: *const GstByteReader, val: *mut i64) -> gboolean1444 pub fn gst_byte_reader_peek_int64_be(reader: *const GstByteReader, val: *mut i64) -> gboolean; gst_byte_reader_peek_int64_le(reader: *const GstByteReader, val: *mut i64) -> gboolean1445 pub fn gst_byte_reader_peek_int64_le(reader: *const GstByteReader, val: *mut i64) -> gboolean; gst_byte_reader_peek_int8(reader: *const GstByteReader, val: *mut i8) -> gboolean1446 pub fn gst_byte_reader_peek_int8(reader: *const GstByteReader, val: *mut i8) -> gboolean; gst_byte_reader_peek_string_utf8( reader: *const GstByteReader, str: *mut *const c_char, ) -> gboolean1447 pub fn gst_byte_reader_peek_string_utf8( 1448 reader: *const GstByteReader, 1449 str: *mut *const c_char, 1450 ) -> gboolean; 1451 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_byte_reader_peek_sub_reader( reader: *mut GstByteReader, sub_reader: *mut GstByteReader, size: c_uint, ) -> gboolean1452 pub fn gst_byte_reader_peek_sub_reader( 1453 reader: *mut GstByteReader, 1454 sub_reader: *mut GstByteReader, 1455 size: c_uint, 1456 ) -> gboolean; gst_byte_reader_peek_uint16_be(reader: *const GstByteReader, val: *mut u16) -> gboolean1457 pub fn gst_byte_reader_peek_uint16_be(reader: *const GstByteReader, val: *mut u16) -> gboolean; gst_byte_reader_peek_uint16_le(reader: *const GstByteReader, val: *mut u16) -> gboolean1458 pub fn gst_byte_reader_peek_uint16_le(reader: *const GstByteReader, val: *mut u16) -> gboolean; gst_byte_reader_peek_uint24_be(reader: *const GstByteReader, val: *mut u32) -> gboolean1459 pub fn gst_byte_reader_peek_uint24_be(reader: *const GstByteReader, val: *mut u32) -> gboolean; gst_byte_reader_peek_uint24_le(reader: *const GstByteReader, val: *mut u32) -> gboolean1460 pub fn gst_byte_reader_peek_uint24_le(reader: *const GstByteReader, val: *mut u32) -> gboolean; gst_byte_reader_peek_uint32_be(reader: *const GstByteReader, val: *mut u32) -> gboolean1461 pub fn gst_byte_reader_peek_uint32_be(reader: *const GstByteReader, val: *mut u32) -> gboolean; gst_byte_reader_peek_uint32_le(reader: *const GstByteReader, val: *mut u32) -> gboolean1462 pub fn gst_byte_reader_peek_uint32_le(reader: *const GstByteReader, val: *mut u32) -> gboolean; gst_byte_reader_peek_uint64_be(reader: *const GstByteReader, val: *mut u64) -> gboolean1463 pub fn gst_byte_reader_peek_uint64_be(reader: *const GstByteReader, val: *mut u64) -> gboolean; gst_byte_reader_peek_uint64_le(reader: *const GstByteReader, val: *mut u64) -> gboolean1464 pub fn gst_byte_reader_peek_uint64_le(reader: *const GstByteReader, val: *mut u64) -> gboolean; gst_byte_reader_peek_uint8(reader: *const GstByteReader, val: *mut u8) -> gboolean1465 pub fn gst_byte_reader_peek_uint8(reader: *const GstByteReader, val: *mut u8) -> gboolean; gst_byte_reader_set_pos(reader: *mut GstByteReader, pos: c_uint) -> gboolean1466 pub fn gst_byte_reader_set_pos(reader: *mut GstByteReader, pos: c_uint) -> gboolean; gst_byte_reader_skip(reader: *mut GstByteReader, nbytes: c_uint) -> gboolean1467 pub fn gst_byte_reader_skip(reader: *mut GstByteReader, nbytes: c_uint) -> gboolean; gst_byte_reader_skip_string_utf16(reader: *mut GstByteReader) -> gboolean1468 pub fn gst_byte_reader_skip_string_utf16(reader: *mut GstByteReader) -> gboolean; gst_byte_reader_skip_string_utf32(reader: *mut GstByteReader) -> gboolean1469 pub fn gst_byte_reader_skip_string_utf32(reader: *mut GstByteReader) -> gboolean; gst_byte_reader_skip_string_utf8(reader: *mut GstByteReader) -> gboolean1470 pub fn gst_byte_reader_skip_string_utf8(reader: *mut GstByteReader) -> gboolean; gst_byte_reader_new(data: *const u8, size: c_uint) -> *mut GstByteReader1471 pub fn gst_byte_reader_new(data: *const u8, size: c_uint) -> *mut GstByteReader; 1472 1473 //========================================================================= 1474 // GstByteWriter 1475 //========================================================================= gst_byte_writer_ensure_free_space(writer: *mut GstByteWriter, size: c_uint) -> gboolean1476 pub fn gst_byte_writer_ensure_free_space(writer: *mut GstByteWriter, size: c_uint) -> gboolean; gst_byte_writer_fill(writer: *mut GstByteWriter, value: u8, size: c_uint) -> gboolean1477 pub fn gst_byte_writer_fill(writer: *mut GstByteWriter, value: u8, size: c_uint) -> gboolean; gst_byte_writer_free(writer: *mut GstByteWriter)1478 pub fn gst_byte_writer_free(writer: *mut GstByteWriter); gst_byte_writer_free_and_get_buffer(writer: *mut GstByteWriter) -> *mut gst::GstBuffer1479 pub fn gst_byte_writer_free_and_get_buffer(writer: *mut GstByteWriter) -> *mut gst::GstBuffer; gst_byte_writer_free_and_get_data(writer: *mut GstByteWriter) -> *mut u81480 pub fn gst_byte_writer_free_and_get_data(writer: *mut GstByteWriter) -> *mut u8; gst_byte_writer_get_remaining(writer: *const GstByteWriter) -> c_uint1481 pub fn gst_byte_writer_get_remaining(writer: *const GstByteWriter) -> c_uint; gst_byte_writer_init(writer: *mut GstByteWriter)1482 pub fn gst_byte_writer_init(writer: *mut GstByteWriter); gst_byte_writer_init_with_data( writer: *mut GstByteWriter, data: *mut u8, size: c_uint, initialized: gboolean, )1483 pub fn gst_byte_writer_init_with_data( 1484 writer: *mut GstByteWriter, 1485 data: *mut u8, 1486 size: c_uint, 1487 initialized: gboolean, 1488 ); gst_byte_writer_init_with_size( writer: *mut GstByteWriter, size: c_uint, fixed: gboolean, )1489 pub fn gst_byte_writer_init_with_size( 1490 writer: *mut GstByteWriter, 1491 size: c_uint, 1492 fixed: gboolean, 1493 ); gst_byte_writer_put_buffer( writer: *mut GstByteWriter, buffer: *mut gst::GstBuffer, offset: size_t, size: ssize_t, ) -> gboolean1494 pub fn gst_byte_writer_put_buffer( 1495 writer: *mut GstByteWriter, 1496 buffer: *mut gst::GstBuffer, 1497 offset: size_t, 1498 size: ssize_t, 1499 ) -> gboolean; gst_byte_writer_put_data( writer: *mut GstByteWriter, data: *const u8, size: c_uint, ) -> gboolean1500 pub fn gst_byte_writer_put_data( 1501 writer: *mut GstByteWriter, 1502 data: *const u8, 1503 size: c_uint, 1504 ) -> gboolean; gst_byte_writer_put_float32_be(writer: *mut GstByteWriter, val: c_float) -> gboolean1505 pub fn gst_byte_writer_put_float32_be(writer: *mut GstByteWriter, val: c_float) -> gboolean; gst_byte_writer_put_float32_le(writer: *mut GstByteWriter, val: c_float) -> gboolean1506 pub fn gst_byte_writer_put_float32_le(writer: *mut GstByteWriter, val: c_float) -> gboolean; gst_byte_writer_put_float64_be(writer: *mut GstByteWriter, val: c_double) -> gboolean1507 pub fn gst_byte_writer_put_float64_be(writer: *mut GstByteWriter, val: c_double) -> gboolean; gst_byte_writer_put_float64_le(writer: *mut GstByteWriter, val: c_double) -> gboolean1508 pub fn gst_byte_writer_put_float64_le(writer: *mut GstByteWriter, val: c_double) -> gboolean; gst_byte_writer_put_int16_be(writer: *mut GstByteWriter, val: i16) -> gboolean1509 pub fn gst_byte_writer_put_int16_be(writer: *mut GstByteWriter, val: i16) -> gboolean; gst_byte_writer_put_int16_le(writer: *mut GstByteWriter, val: i16) -> gboolean1510 pub fn gst_byte_writer_put_int16_le(writer: *mut GstByteWriter, val: i16) -> gboolean; gst_byte_writer_put_int24_be(writer: *mut GstByteWriter, val: i32) -> gboolean1511 pub fn gst_byte_writer_put_int24_be(writer: *mut GstByteWriter, val: i32) -> gboolean; gst_byte_writer_put_int24_le(writer: *mut GstByteWriter, val: i32) -> gboolean1512 pub fn gst_byte_writer_put_int24_le(writer: *mut GstByteWriter, val: i32) -> gboolean; gst_byte_writer_put_int32_be(writer: *mut GstByteWriter, val: i32) -> gboolean1513 pub fn gst_byte_writer_put_int32_be(writer: *mut GstByteWriter, val: i32) -> gboolean; gst_byte_writer_put_int32_le(writer: *mut GstByteWriter, val: i32) -> gboolean1514 pub fn gst_byte_writer_put_int32_le(writer: *mut GstByteWriter, val: i32) -> gboolean; gst_byte_writer_put_int64_be(writer: *mut GstByteWriter, val: i64) -> gboolean1515 pub fn gst_byte_writer_put_int64_be(writer: *mut GstByteWriter, val: i64) -> gboolean; gst_byte_writer_put_int64_le(writer: *mut GstByteWriter, val: i64) -> gboolean1516 pub fn gst_byte_writer_put_int64_le(writer: *mut GstByteWriter, val: i64) -> gboolean; gst_byte_writer_put_int8(writer: *mut GstByteWriter, val: i8) -> gboolean1517 pub fn gst_byte_writer_put_int8(writer: *mut GstByteWriter, val: i8) -> gboolean; gst_byte_writer_put_string_utf16( writer: *mut GstByteWriter, data: *const u16, ) -> gboolean1518 pub fn gst_byte_writer_put_string_utf16( 1519 writer: *mut GstByteWriter, 1520 data: *const u16, 1521 ) -> gboolean; gst_byte_writer_put_string_utf32( writer: *mut GstByteWriter, data: *const u32, ) -> gboolean1522 pub fn gst_byte_writer_put_string_utf32( 1523 writer: *mut GstByteWriter, 1524 data: *const u32, 1525 ) -> gboolean; gst_byte_writer_put_string_utf8( writer: *mut GstByteWriter, data: *const c_char, ) -> gboolean1526 pub fn gst_byte_writer_put_string_utf8( 1527 writer: *mut GstByteWriter, 1528 data: *const c_char, 1529 ) -> gboolean; gst_byte_writer_put_uint16_be(writer: *mut GstByteWriter, val: u16) -> gboolean1530 pub fn gst_byte_writer_put_uint16_be(writer: *mut GstByteWriter, val: u16) -> gboolean; gst_byte_writer_put_uint16_le(writer: *mut GstByteWriter, val: u16) -> gboolean1531 pub fn gst_byte_writer_put_uint16_le(writer: *mut GstByteWriter, val: u16) -> gboolean; gst_byte_writer_put_uint24_be(writer: *mut GstByteWriter, val: u32) -> gboolean1532 pub fn gst_byte_writer_put_uint24_be(writer: *mut GstByteWriter, val: u32) -> gboolean; gst_byte_writer_put_uint24_le(writer: *mut GstByteWriter, val: u32) -> gboolean1533 pub fn gst_byte_writer_put_uint24_le(writer: *mut GstByteWriter, val: u32) -> gboolean; gst_byte_writer_put_uint32_be(writer: *mut GstByteWriter, val: u32) -> gboolean1534 pub fn gst_byte_writer_put_uint32_be(writer: *mut GstByteWriter, val: u32) -> gboolean; gst_byte_writer_put_uint32_le(writer: *mut GstByteWriter, val: u32) -> gboolean1535 pub fn gst_byte_writer_put_uint32_le(writer: *mut GstByteWriter, val: u32) -> gboolean; gst_byte_writer_put_uint64_be(writer: *mut GstByteWriter, val: u64) -> gboolean1536 pub fn gst_byte_writer_put_uint64_be(writer: *mut GstByteWriter, val: u64) -> gboolean; gst_byte_writer_put_uint64_le(writer: *mut GstByteWriter, val: u64) -> gboolean1537 pub fn gst_byte_writer_put_uint64_le(writer: *mut GstByteWriter, val: u64) -> gboolean; gst_byte_writer_put_uint8(writer: *mut GstByteWriter, val: u8) -> gboolean1538 pub fn gst_byte_writer_put_uint8(writer: *mut GstByteWriter, val: u8) -> gboolean; gst_byte_writer_reset(writer: *mut GstByteWriter)1539 pub fn gst_byte_writer_reset(writer: *mut GstByteWriter); gst_byte_writer_reset_and_get_buffer(writer: *mut GstByteWriter) -> *mut gst::GstBuffer1540 pub fn gst_byte_writer_reset_and_get_buffer(writer: *mut GstByteWriter) -> *mut gst::GstBuffer; gst_byte_writer_reset_and_get_data(writer: *mut GstByteWriter) -> *mut u81541 pub fn gst_byte_writer_reset_and_get_data(writer: *mut GstByteWriter) -> *mut u8; gst_byte_writer_new() -> *mut GstByteWriter1542 pub fn gst_byte_writer_new() -> *mut GstByteWriter; gst_byte_writer_new_with_data( data: *mut u8, size: c_uint, initialized: gboolean, ) -> *mut GstByteWriter1543 pub fn gst_byte_writer_new_with_data( 1544 data: *mut u8, 1545 size: c_uint, 1546 initialized: gboolean, 1547 ) -> *mut GstByteWriter; gst_byte_writer_new_with_size(size: c_uint, fixed: gboolean) -> *mut GstByteWriter1548 pub fn gst_byte_writer_new_with_size(size: c_uint, fixed: gboolean) -> *mut GstByteWriter; 1549 1550 //========================================================================= 1551 // GstFlowCombiner 1552 //========================================================================= gst_flow_combiner_get_type() -> GType1553 pub fn gst_flow_combiner_get_type() -> GType; 1554 #[cfg(any(feature = "v1_4", feature = "dox"))] gst_flow_combiner_new() -> *mut GstFlowCombiner1555 pub fn gst_flow_combiner_new() -> *mut GstFlowCombiner; 1556 #[cfg(any(feature = "v1_4", feature = "dox"))] gst_flow_combiner_add_pad(combiner: *mut GstFlowCombiner, pad: *mut gst::GstPad)1557 pub fn gst_flow_combiner_add_pad(combiner: *mut GstFlowCombiner, pad: *mut gst::GstPad); 1558 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_flow_combiner_clear(combiner: *mut GstFlowCombiner)1559 pub fn gst_flow_combiner_clear(combiner: *mut GstFlowCombiner); 1560 #[cfg(any(feature = "v1_4", feature = "dox"))] gst_flow_combiner_free(combiner: *mut GstFlowCombiner)1561 pub fn gst_flow_combiner_free(combiner: *mut GstFlowCombiner); 1562 #[cfg(any(feature = "v1_12_1", feature = "dox"))] gst_flow_combiner_ref(combiner: *mut GstFlowCombiner) -> *mut GstFlowCombiner1563 pub fn gst_flow_combiner_ref(combiner: *mut GstFlowCombiner) -> *mut GstFlowCombiner; 1564 #[cfg(any(feature = "v1_4", feature = "dox"))] gst_flow_combiner_remove_pad(combiner: *mut GstFlowCombiner, pad: *mut gst::GstPad)1565 pub fn gst_flow_combiner_remove_pad(combiner: *mut GstFlowCombiner, pad: *mut gst::GstPad); 1566 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_flow_combiner_reset(combiner: *mut GstFlowCombiner)1567 pub fn gst_flow_combiner_reset(combiner: *mut GstFlowCombiner); 1568 #[cfg(any(feature = "v1_12_1", feature = "dox"))] gst_flow_combiner_unref(combiner: *mut GstFlowCombiner)1569 pub fn gst_flow_combiner_unref(combiner: *mut GstFlowCombiner); 1570 #[cfg(any(feature = "v1_4", feature = "dox"))] gst_flow_combiner_update_flow( combiner: *mut GstFlowCombiner, fret: gst::GstFlowReturn, ) -> gst::GstFlowReturn1571 pub fn gst_flow_combiner_update_flow( 1572 combiner: *mut GstFlowCombiner, 1573 fret: gst::GstFlowReturn, 1574 ) -> gst::GstFlowReturn; 1575 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_flow_combiner_update_pad_flow( combiner: *mut GstFlowCombiner, pad: *mut gst::GstPad, fret: gst::GstFlowReturn, ) -> gst::GstFlowReturn1576 pub fn gst_flow_combiner_update_pad_flow( 1577 combiner: *mut GstFlowCombiner, 1578 pad: *mut gst::GstPad, 1579 fret: gst::GstFlowReturn, 1580 ) -> gst::GstFlowReturn; 1581 1582 //========================================================================= 1583 // GstQueueArray 1584 //========================================================================= 1585 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_queue_array_clear(array: *mut GstQueueArray)1586 pub fn gst_queue_array_clear(array: *mut GstQueueArray); 1587 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_queue_array_drop_element(array: *mut GstQueueArray, idx: c_uint) -> gpointer1588 pub fn gst_queue_array_drop_element(array: *mut GstQueueArray, idx: c_uint) -> gpointer; 1589 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_queue_array_drop_struct( array: *mut GstQueueArray, idx: c_uint, p_struct: gpointer, ) -> gboolean1590 pub fn gst_queue_array_drop_struct( 1591 array: *mut GstQueueArray, 1592 idx: c_uint, 1593 p_struct: gpointer, 1594 ) -> gboolean; 1595 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_queue_array_find( array: *mut GstQueueArray, func: glib::GCompareFunc, data: gpointer, ) -> c_uint1596 pub fn gst_queue_array_find( 1597 array: *mut GstQueueArray, 1598 func: glib::GCompareFunc, 1599 data: gpointer, 1600 ) -> c_uint; 1601 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_queue_array_free(array: *mut GstQueueArray)1602 pub fn gst_queue_array_free(array: *mut GstQueueArray); 1603 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_queue_array_get_length(array: *mut GstQueueArray) -> c_uint1604 pub fn gst_queue_array_get_length(array: *mut GstQueueArray) -> c_uint; 1605 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_queue_array_is_empty(array: *mut GstQueueArray) -> gboolean1606 pub fn gst_queue_array_is_empty(array: *mut GstQueueArray) -> gboolean; 1607 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_queue_array_peek_head(array: *mut GstQueueArray) -> gpointer1608 pub fn gst_queue_array_peek_head(array: *mut GstQueueArray) -> gpointer; 1609 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_queue_array_peek_head_struct(array: *mut GstQueueArray) -> gpointer1610 pub fn gst_queue_array_peek_head_struct(array: *mut GstQueueArray) -> gpointer; 1611 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_queue_array_peek_nth(array: *mut GstQueueArray, idx: c_uint) -> gpointer1612 pub fn gst_queue_array_peek_nth(array: *mut GstQueueArray, idx: c_uint) -> gpointer; 1613 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_queue_array_peek_nth_struct(array: *mut GstQueueArray, idx: c_uint) -> gpointer1614 pub fn gst_queue_array_peek_nth_struct(array: *mut GstQueueArray, idx: c_uint) -> gpointer; 1615 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_queue_array_peek_tail(array: *mut GstQueueArray) -> gpointer1616 pub fn gst_queue_array_peek_tail(array: *mut GstQueueArray) -> gpointer; 1617 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_queue_array_peek_tail_struct(array: *mut GstQueueArray) -> gpointer1618 pub fn gst_queue_array_peek_tail_struct(array: *mut GstQueueArray) -> gpointer; 1619 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_queue_array_pop_head(array: *mut GstQueueArray) -> gpointer1620 pub fn gst_queue_array_pop_head(array: *mut GstQueueArray) -> gpointer; 1621 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_queue_array_pop_head_struct(array: *mut GstQueueArray) -> gpointer1622 pub fn gst_queue_array_pop_head_struct(array: *mut GstQueueArray) -> gpointer; 1623 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_queue_array_pop_tail(array: *mut GstQueueArray) -> gpointer1624 pub fn gst_queue_array_pop_tail(array: *mut GstQueueArray) -> gpointer; 1625 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_queue_array_pop_tail_struct(array: *mut GstQueueArray) -> gpointer1626 pub fn gst_queue_array_pop_tail_struct(array: *mut GstQueueArray) -> gpointer; 1627 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_queue_array_push_tail(array: *mut GstQueueArray, data: gpointer)1628 pub fn gst_queue_array_push_tail(array: *mut GstQueueArray, data: gpointer); gst_queue_array_push_tail_struct(array: *mut GstQueueArray, p_struct: gpointer)1629 pub fn gst_queue_array_push_tail_struct(array: *mut GstQueueArray, p_struct: gpointer); 1630 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_queue_array_set_clear_func( array: *mut GstQueueArray, clear_func: glib::GDestroyNotify, )1631 pub fn gst_queue_array_set_clear_func( 1632 array: *mut GstQueueArray, 1633 clear_func: glib::GDestroyNotify, 1634 ); 1635 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_queue_array_new(initial_size: c_uint) -> *mut GstQueueArray1636 pub fn gst_queue_array_new(initial_size: c_uint) -> *mut GstQueueArray; 1637 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_queue_array_new_for_struct( struct_size: size_t, initial_size: c_uint, ) -> *mut GstQueueArray1638 pub fn gst_queue_array_new_for_struct( 1639 struct_size: size_t, 1640 initial_size: c_uint, 1641 ) -> *mut GstQueueArray; 1642 1643 //========================================================================= 1644 // GstAdapter 1645 //========================================================================= gst_adapter_get_type() -> GType1646 pub fn gst_adapter_get_type() -> GType; gst_adapter_new() -> *mut GstAdapter1647 pub fn gst_adapter_new() -> *mut GstAdapter; gst_adapter_available(adapter: *mut GstAdapter) -> size_t1648 pub fn gst_adapter_available(adapter: *mut GstAdapter) -> size_t; gst_adapter_available_fast(adapter: *mut GstAdapter) -> size_t1649 pub fn gst_adapter_available_fast(adapter: *mut GstAdapter) -> size_t; gst_adapter_clear(adapter: *mut GstAdapter)1650 pub fn gst_adapter_clear(adapter: *mut GstAdapter); gst_adapter_copy(adapter: *mut GstAdapter, dest: gpointer, offset: size_t, size: size_t)1651 pub fn gst_adapter_copy(adapter: *mut GstAdapter, dest: gpointer, offset: size_t, size: size_t); 1652 #[cfg(any(feature = "v1_4", feature = "dox"))] gst_adapter_copy_bytes( adapter: *mut GstAdapter, offset: size_t, size: size_t, ) -> *mut glib::GBytes1653 pub fn gst_adapter_copy_bytes( 1654 adapter: *mut GstAdapter, 1655 offset: size_t, 1656 size: size_t, 1657 ) -> *mut glib::GBytes; gst_adapter_distance_from_discont(adapter: *mut GstAdapter) -> u641658 pub fn gst_adapter_distance_from_discont(adapter: *mut GstAdapter) -> u64; 1659 #[cfg(any(feature = "v1_10", feature = "dox"))] gst_adapter_dts_at_discont(adapter: *mut GstAdapter) -> gst::GstClockTime1660 pub fn gst_adapter_dts_at_discont(adapter: *mut GstAdapter) -> gst::GstClockTime; gst_adapter_flush(adapter: *mut GstAdapter, flush: size_t)1661 pub fn gst_adapter_flush(adapter: *mut GstAdapter, flush: size_t); 1662 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_adapter_get_buffer(adapter: *mut GstAdapter, nbytes: size_t) -> *mut gst::GstBuffer1663 pub fn gst_adapter_get_buffer(adapter: *mut GstAdapter, nbytes: size_t) -> *mut gst::GstBuffer; 1664 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_adapter_get_buffer_fast( adapter: *mut GstAdapter, nbytes: size_t, ) -> *mut gst::GstBuffer1665 pub fn gst_adapter_get_buffer_fast( 1666 adapter: *mut GstAdapter, 1667 nbytes: size_t, 1668 ) -> *mut gst::GstBuffer; 1669 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_adapter_get_buffer_list( adapter: *mut GstAdapter, nbytes: size_t, ) -> *mut gst::GstBufferList1670 pub fn gst_adapter_get_buffer_list( 1671 adapter: *mut GstAdapter, 1672 nbytes: size_t, 1673 ) -> *mut gst::GstBufferList; 1674 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_adapter_get_list(adapter: *mut GstAdapter, nbytes: size_t) -> *mut glib::GList1675 pub fn gst_adapter_get_list(adapter: *mut GstAdapter, nbytes: size_t) -> *mut glib::GList; gst_adapter_map(adapter: *mut GstAdapter, size: size_t) -> gconstpointer1676 pub fn gst_adapter_map(adapter: *mut GstAdapter, size: size_t) -> gconstpointer; gst_adapter_masked_scan_uint32( adapter: *mut GstAdapter, mask: u32, pattern: u32, offset: size_t, size: size_t, ) -> ssize_t1677 pub fn gst_adapter_masked_scan_uint32( 1678 adapter: *mut GstAdapter, 1679 mask: u32, 1680 pattern: u32, 1681 offset: size_t, 1682 size: size_t, 1683 ) -> ssize_t; gst_adapter_masked_scan_uint32_peek( adapter: *mut GstAdapter, mask: u32, pattern: u32, offset: size_t, size: size_t, value: *mut u32, ) -> ssize_t1684 pub fn gst_adapter_masked_scan_uint32_peek( 1685 adapter: *mut GstAdapter, 1686 mask: u32, 1687 pattern: u32, 1688 offset: size_t, 1689 size: size_t, 1690 value: *mut u32, 1691 ) -> ssize_t; 1692 #[cfg(any(feature = "v1_10", feature = "dox"))] gst_adapter_offset_at_discont(adapter: *mut GstAdapter) -> u641693 pub fn gst_adapter_offset_at_discont(adapter: *mut GstAdapter) -> u64; gst_adapter_prev_dts(adapter: *mut GstAdapter, distance: *mut u64) -> gst::GstClockTime1694 pub fn gst_adapter_prev_dts(adapter: *mut GstAdapter, distance: *mut u64) -> gst::GstClockTime; 1695 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_adapter_prev_dts_at_offset( adapter: *mut GstAdapter, offset: size_t, distance: *mut u64, ) -> gst::GstClockTime1696 pub fn gst_adapter_prev_dts_at_offset( 1697 adapter: *mut GstAdapter, 1698 offset: size_t, 1699 distance: *mut u64, 1700 ) -> gst::GstClockTime; 1701 #[cfg(any(feature = "v1_10", feature = "dox"))] gst_adapter_prev_offset(adapter: *mut GstAdapter, distance: *mut u64) -> u641702 pub fn gst_adapter_prev_offset(adapter: *mut GstAdapter, distance: *mut u64) -> u64; gst_adapter_prev_pts(adapter: *mut GstAdapter, distance: *mut u64) -> gst::GstClockTime1703 pub fn gst_adapter_prev_pts(adapter: *mut GstAdapter, distance: *mut u64) -> gst::GstClockTime; 1704 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_adapter_prev_pts_at_offset( adapter: *mut GstAdapter, offset: size_t, distance: *mut u64, ) -> gst::GstClockTime1705 pub fn gst_adapter_prev_pts_at_offset( 1706 adapter: *mut GstAdapter, 1707 offset: size_t, 1708 distance: *mut u64, 1709 ) -> gst::GstClockTime; 1710 #[cfg(any(feature = "v1_10", feature = "dox"))] gst_adapter_pts_at_discont(adapter: *mut GstAdapter) -> gst::GstClockTime1711 pub fn gst_adapter_pts_at_discont(adapter: *mut GstAdapter) -> gst::GstClockTime; gst_adapter_push(adapter: *mut GstAdapter, buf: *mut gst::GstBuffer)1712 pub fn gst_adapter_push(adapter: *mut GstAdapter, buf: *mut gst::GstBuffer); gst_adapter_take(adapter: *mut GstAdapter, nbytes: size_t) -> gpointer1713 pub fn gst_adapter_take(adapter: *mut GstAdapter, nbytes: size_t) -> gpointer; gst_adapter_take_buffer(adapter: *mut GstAdapter, nbytes: size_t) -> *mut gst::GstBuffer1714 pub fn gst_adapter_take_buffer(adapter: *mut GstAdapter, nbytes: size_t) 1715 -> *mut gst::GstBuffer; 1716 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_adapter_take_buffer_fast( adapter: *mut GstAdapter, nbytes: size_t, ) -> *mut gst::GstBuffer1717 pub fn gst_adapter_take_buffer_fast( 1718 adapter: *mut GstAdapter, 1719 nbytes: size_t, 1720 ) -> *mut gst::GstBuffer; 1721 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_adapter_take_buffer_list( adapter: *mut GstAdapter, nbytes: size_t, ) -> *mut gst::GstBufferList1722 pub fn gst_adapter_take_buffer_list( 1723 adapter: *mut GstAdapter, 1724 nbytes: size_t, 1725 ) -> *mut gst::GstBufferList; gst_adapter_take_list(adapter: *mut GstAdapter, nbytes: size_t) -> *mut glib::GList1726 pub fn gst_adapter_take_list(adapter: *mut GstAdapter, nbytes: size_t) -> *mut glib::GList; gst_adapter_unmap(adapter: *mut GstAdapter)1727 pub fn gst_adapter_unmap(adapter: *mut GstAdapter); 1728 1729 //========================================================================= 1730 // GstAggregator 1731 //========================================================================= gst_aggregator_get_type() -> GType1732 pub fn gst_aggregator_get_type() -> GType; 1733 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_aggregator_finish_buffer( aggregator: *mut GstAggregator, buffer: *mut gst::GstBuffer, ) -> gst::GstFlowReturn1734 pub fn gst_aggregator_finish_buffer( 1735 aggregator: *mut GstAggregator, 1736 buffer: *mut gst::GstBuffer, 1737 ) -> gst::GstFlowReturn; 1738 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_aggregator_get_allocator( self_: *mut GstAggregator, allocator: *mut *mut gst::GstAllocator, params: *mut gst::GstAllocationParams, )1739 pub fn gst_aggregator_get_allocator( 1740 self_: *mut GstAggregator, 1741 allocator: *mut *mut gst::GstAllocator, 1742 params: *mut gst::GstAllocationParams, 1743 ); 1744 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_aggregator_get_buffer_pool(self_: *mut GstAggregator) -> *mut gst::GstBufferPool1745 pub fn gst_aggregator_get_buffer_pool(self_: *mut GstAggregator) -> *mut gst::GstBufferPool; 1746 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_aggregator_get_latency(self_: *mut GstAggregator) -> gst::GstClockTime1747 pub fn gst_aggregator_get_latency(self_: *mut GstAggregator) -> gst::GstClockTime; 1748 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_aggregator_set_latency( self_: *mut GstAggregator, min_latency: gst::GstClockTime, max_latency: gst::GstClockTime, )1749 pub fn gst_aggregator_set_latency( 1750 self_: *mut GstAggregator, 1751 min_latency: gst::GstClockTime, 1752 max_latency: gst::GstClockTime, 1753 ); 1754 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_aggregator_set_src_caps(self_: *mut GstAggregator, caps: *mut gst::GstCaps)1755 pub fn gst_aggregator_set_src_caps(self_: *mut GstAggregator, caps: *mut gst::GstCaps); 1756 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_aggregator_simple_get_next_time(self_: *mut GstAggregator) -> gst::GstClockTime1757 pub fn gst_aggregator_simple_get_next_time(self_: *mut GstAggregator) -> gst::GstClockTime; 1758 1759 //========================================================================= 1760 // GstAggregatorPad 1761 //========================================================================= gst_aggregator_pad_get_type() -> GType1762 pub fn gst_aggregator_pad_get_type() -> GType; 1763 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_aggregator_pad_drop_buffer(pad: *mut GstAggregatorPad) -> gboolean1764 pub fn gst_aggregator_pad_drop_buffer(pad: *mut GstAggregatorPad) -> gboolean; 1765 #[cfg(any(feature = "v1_14_1", feature = "dox"))] gst_aggregator_pad_has_buffer(pad: *mut GstAggregatorPad) -> gboolean1766 pub fn gst_aggregator_pad_has_buffer(pad: *mut GstAggregatorPad) -> gboolean; 1767 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_aggregator_pad_is_eos(pad: *mut GstAggregatorPad) -> gboolean1768 pub fn gst_aggregator_pad_is_eos(pad: *mut GstAggregatorPad) -> gboolean; 1769 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_aggregator_pad_peek_buffer(pad: *mut GstAggregatorPad) -> *mut gst::GstBuffer1770 pub fn gst_aggregator_pad_peek_buffer(pad: *mut GstAggregatorPad) -> *mut gst::GstBuffer; 1771 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_aggregator_pad_pop_buffer(pad: *mut GstAggregatorPad) -> *mut gst::GstBuffer1772 pub fn gst_aggregator_pad_pop_buffer(pad: *mut GstAggregatorPad) -> *mut gst::GstBuffer; 1773 1774 //========================================================================= 1775 // GstBaseParse 1776 //========================================================================= gst_base_parse_get_type() -> GType1777 pub fn gst_base_parse_get_type() -> GType; gst_base_parse_add_index_entry( parse: *mut GstBaseParse, offset: u64, ts: gst::GstClockTime, key: gboolean, force: gboolean, ) -> gboolean1778 pub fn gst_base_parse_add_index_entry( 1779 parse: *mut GstBaseParse, 1780 offset: u64, 1781 ts: gst::GstClockTime, 1782 key: gboolean, 1783 force: gboolean, 1784 ) -> gboolean; gst_base_parse_convert_default( parse: *mut GstBaseParse, src_format: gst::GstFormat, src_value: i64, dest_format: gst::GstFormat, dest_value: *mut i64, ) -> gboolean1785 pub fn gst_base_parse_convert_default( 1786 parse: *mut GstBaseParse, 1787 src_format: gst::GstFormat, 1788 src_value: i64, 1789 dest_format: gst::GstFormat, 1790 dest_value: *mut i64, 1791 ) -> gboolean; 1792 #[cfg(any(feature = "v1_12", feature = "dox"))] gst_base_parse_drain(parse: *mut GstBaseParse)1793 pub fn gst_base_parse_drain(parse: *mut GstBaseParse); gst_base_parse_finish_frame( parse: *mut GstBaseParse, frame: *mut GstBaseParseFrame, size: c_int, ) -> gst::GstFlowReturn1794 pub fn gst_base_parse_finish_frame( 1795 parse: *mut GstBaseParse, 1796 frame: *mut GstBaseParseFrame, 1797 size: c_int, 1798 ) -> gst::GstFlowReturn; 1799 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_base_parse_merge_tags( parse: *mut GstBaseParse, tags: *mut gst::GstTagList, mode: gst::GstTagMergeMode, )1800 pub fn gst_base_parse_merge_tags( 1801 parse: *mut GstBaseParse, 1802 tags: *mut gst::GstTagList, 1803 mode: gst::GstTagMergeMode, 1804 ); gst_base_parse_push_frame( parse: *mut GstBaseParse, frame: *mut GstBaseParseFrame, ) -> gst::GstFlowReturn1805 pub fn gst_base_parse_push_frame( 1806 parse: *mut GstBaseParse, 1807 frame: *mut GstBaseParseFrame, 1808 ) -> gst::GstFlowReturn; gst_base_parse_set_average_bitrate(parse: *mut GstBaseParse, bitrate: c_uint)1809 pub fn gst_base_parse_set_average_bitrate(parse: *mut GstBaseParse, bitrate: c_uint); gst_base_parse_set_duration( parse: *mut GstBaseParse, fmt: gst::GstFormat, duration: i64, interval: c_int, )1810 pub fn gst_base_parse_set_duration( 1811 parse: *mut GstBaseParse, 1812 fmt: gst::GstFormat, 1813 duration: i64, 1814 interval: c_int, 1815 ); gst_base_parse_set_frame_rate( parse: *mut GstBaseParse, fps_num: c_uint, fps_den: c_uint, lead_in: c_uint, lead_out: c_uint, )1816 pub fn gst_base_parse_set_frame_rate( 1817 parse: *mut GstBaseParse, 1818 fps_num: c_uint, 1819 fps_den: c_uint, 1820 lead_in: c_uint, 1821 lead_out: c_uint, 1822 ); gst_base_parse_set_has_timing_info(parse: *mut GstBaseParse, has_timing: gboolean)1823 pub fn gst_base_parse_set_has_timing_info(parse: *mut GstBaseParse, has_timing: gboolean); gst_base_parse_set_infer_ts(parse: *mut GstBaseParse, infer_ts: gboolean)1824 pub fn gst_base_parse_set_infer_ts(parse: *mut GstBaseParse, infer_ts: gboolean); gst_base_parse_set_latency( parse: *mut GstBaseParse, min_latency: gst::GstClockTime, max_latency: gst::GstClockTime, )1825 pub fn gst_base_parse_set_latency( 1826 parse: *mut GstBaseParse, 1827 min_latency: gst::GstClockTime, 1828 max_latency: gst::GstClockTime, 1829 ); gst_base_parse_set_min_frame_size(parse: *mut GstBaseParse, min_size: c_uint)1830 pub fn gst_base_parse_set_min_frame_size(parse: *mut GstBaseParse, min_size: c_uint); gst_base_parse_set_passthrough(parse: *mut GstBaseParse, passthrough: gboolean)1831 pub fn gst_base_parse_set_passthrough(parse: *mut GstBaseParse, passthrough: gboolean); gst_base_parse_set_pts_interpolation( parse: *mut GstBaseParse, pts_interpolate: gboolean, )1832 pub fn gst_base_parse_set_pts_interpolation( 1833 parse: *mut GstBaseParse, 1834 pts_interpolate: gboolean, 1835 ); gst_base_parse_set_syncable(parse: *mut GstBaseParse, syncable: gboolean)1836 pub fn gst_base_parse_set_syncable(parse: *mut GstBaseParse, syncable: gboolean); 1837 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_base_parse_set_ts_at_offset(parse: *mut GstBaseParse, offset: size_t)1838 pub fn gst_base_parse_set_ts_at_offset(parse: *mut GstBaseParse, offset: size_t); 1839 1840 //========================================================================= 1841 // GstBaseSink 1842 //========================================================================= gst_base_sink_get_type() -> GType1843 pub fn gst_base_sink_get_type() -> GType; gst_base_sink_do_preroll( sink: *mut GstBaseSink, obj: *mut gst::GstMiniObject, ) -> gst::GstFlowReturn1844 pub fn gst_base_sink_do_preroll( 1845 sink: *mut GstBaseSink, 1846 obj: *mut gst::GstMiniObject, 1847 ) -> gst::GstFlowReturn; gst_base_sink_get_blocksize(sink: *mut GstBaseSink) -> c_uint1848 pub fn gst_base_sink_get_blocksize(sink: *mut GstBaseSink) -> c_uint; 1849 #[cfg(any(feature = "v1_12", feature = "dox"))] gst_base_sink_get_drop_out_of_segment(sink: *mut GstBaseSink) -> gboolean1850 pub fn gst_base_sink_get_drop_out_of_segment(sink: *mut GstBaseSink) -> gboolean; gst_base_sink_get_last_sample(sink: *mut GstBaseSink) -> *mut gst::GstSample1851 pub fn gst_base_sink_get_last_sample(sink: *mut GstBaseSink) -> *mut gst::GstSample; gst_base_sink_get_latency(sink: *mut GstBaseSink) -> gst::GstClockTime1852 pub fn gst_base_sink_get_latency(sink: *mut GstBaseSink) -> gst::GstClockTime; 1853 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_base_sink_get_max_bitrate(sink: *mut GstBaseSink) -> u641854 pub fn gst_base_sink_get_max_bitrate(sink: *mut GstBaseSink) -> u64; gst_base_sink_get_max_lateness(sink: *mut GstBaseSink) -> i641855 pub fn gst_base_sink_get_max_lateness(sink: *mut GstBaseSink) -> i64; 1856 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_base_sink_get_processing_deadline(sink: *mut GstBaseSink) -> gst::GstClockTime1857 pub fn gst_base_sink_get_processing_deadline(sink: *mut GstBaseSink) -> gst::GstClockTime; gst_base_sink_get_render_delay(sink: *mut GstBaseSink) -> gst::GstClockTime1858 pub fn gst_base_sink_get_render_delay(sink: *mut GstBaseSink) -> gst::GstClockTime; gst_base_sink_get_sync(sink: *mut GstBaseSink) -> gboolean1859 pub fn gst_base_sink_get_sync(sink: *mut GstBaseSink) -> gboolean; gst_base_sink_get_throttle_time(sink: *mut GstBaseSink) -> u641860 pub fn gst_base_sink_get_throttle_time(sink: *mut GstBaseSink) -> u64; gst_base_sink_get_ts_offset(sink: *mut GstBaseSink) -> gst::GstClockTimeDiff1861 pub fn gst_base_sink_get_ts_offset(sink: *mut GstBaseSink) -> gst::GstClockTimeDiff; gst_base_sink_is_async_enabled(sink: *mut GstBaseSink) -> gboolean1862 pub fn gst_base_sink_is_async_enabled(sink: *mut GstBaseSink) -> gboolean; gst_base_sink_is_last_sample_enabled(sink: *mut GstBaseSink) -> gboolean1863 pub fn gst_base_sink_is_last_sample_enabled(sink: *mut GstBaseSink) -> gboolean; gst_base_sink_is_qos_enabled(sink: *mut GstBaseSink) -> gboolean1864 pub fn gst_base_sink_is_qos_enabled(sink: *mut GstBaseSink) -> gboolean; gst_base_sink_query_latency( sink: *mut GstBaseSink, live: *mut gboolean, upstream_live: *mut gboolean, min_latency: *mut gst::GstClockTime, max_latency: *mut gst::GstClockTime, ) -> gboolean1865 pub fn gst_base_sink_query_latency( 1866 sink: *mut GstBaseSink, 1867 live: *mut gboolean, 1868 upstream_live: *mut gboolean, 1869 min_latency: *mut gst::GstClockTime, 1870 max_latency: *mut gst::GstClockTime, 1871 ) -> gboolean; gst_base_sink_set_async_enabled(sink: *mut GstBaseSink, enabled: gboolean)1872 pub fn gst_base_sink_set_async_enabled(sink: *mut GstBaseSink, enabled: gboolean); gst_base_sink_set_blocksize(sink: *mut GstBaseSink, blocksize: c_uint)1873 pub fn gst_base_sink_set_blocksize(sink: *mut GstBaseSink, blocksize: c_uint); 1874 #[cfg(any(feature = "v1_12", feature = "dox"))] gst_base_sink_set_drop_out_of_segment( sink: *mut GstBaseSink, drop_out_of_segment: gboolean, )1875 pub fn gst_base_sink_set_drop_out_of_segment( 1876 sink: *mut GstBaseSink, 1877 drop_out_of_segment: gboolean, 1878 ); gst_base_sink_set_last_sample_enabled(sink: *mut GstBaseSink, enabled: gboolean)1879 pub fn gst_base_sink_set_last_sample_enabled(sink: *mut GstBaseSink, enabled: gboolean); 1880 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_base_sink_set_max_bitrate(sink: *mut GstBaseSink, max_bitrate: u64)1881 pub fn gst_base_sink_set_max_bitrate(sink: *mut GstBaseSink, max_bitrate: u64); gst_base_sink_set_max_lateness(sink: *mut GstBaseSink, max_lateness: i64)1882 pub fn gst_base_sink_set_max_lateness(sink: *mut GstBaseSink, max_lateness: i64); 1883 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_base_sink_set_processing_deadline( sink: *mut GstBaseSink, processing_deadline: gst::GstClockTime, )1884 pub fn gst_base_sink_set_processing_deadline( 1885 sink: *mut GstBaseSink, 1886 processing_deadline: gst::GstClockTime, 1887 ); gst_base_sink_set_qos_enabled(sink: *mut GstBaseSink, enabled: gboolean)1888 pub fn gst_base_sink_set_qos_enabled(sink: *mut GstBaseSink, enabled: gboolean); gst_base_sink_set_render_delay(sink: *mut GstBaseSink, delay: gst::GstClockTime)1889 pub fn gst_base_sink_set_render_delay(sink: *mut GstBaseSink, delay: gst::GstClockTime); gst_base_sink_set_sync(sink: *mut GstBaseSink, sync: gboolean)1890 pub fn gst_base_sink_set_sync(sink: *mut GstBaseSink, sync: gboolean); gst_base_sink_set_throttle_time(sink: *mut GstBaseSink, throttle: u64)1891 pub fn gst_base_sink_set_throttle_time(sink: *mut GstBaseSink, throttle: u64); gst_base_sink_set_ts_offset(sink: *mut GstBaseSink, offset: gst::GstClockTimeDiff)1892 pub fn gst_base_sink_set_ts_offset(sink: *mut GstBaseSink, offset: gst::GstClockTimeDiff); gst_base_sink_wait( sink: *mut GstBaseSink, time: gst::GstClockTime, jitter: *mut gst::GstClockTimeDiff, ) -> gst::GstFlowReturn1893 pub fn gst_base_sink_wait( 1894 sink: *mut GstBaseSink, 1895 time: gst::GstClockTime, 1896 jitter: *mut gst::GstClockTimeDiff, 1897 ) -> gst::GstFlowReturn; gst_base_sink_wait_clock( sink: *mut GstBaseSink, time: gst::GstClockTime, jitter: *mut gst::GstClockTimeDiff, ) -> gst::GstClockReturn1898 pub fn gst_base_sink_wait_clock( 1899 sink: *mut GstBaseSink, 1900 time: gst::GstClockTime, 1901 jitter: *mut gst::GstClockTimeDiff, 1902 ) -> gst::GstClockReturn; gst_base_sink_wait_preroll(sink: *mut GstBaseSink) -> gst::GstFlowReturn1903 pub fn gst_base_sink_wait_preroll(sink: *mut GstBaseSink) -> gst::GstFlowReturn; 1904 1905 //========================================================================= 1906 // GstBaseSrc 1907 //========================================================================= gst_base_src_get_type() -> GType1908 pub fn gst_base_src_get_type() -> GType; gst_base_src_get_allocator( src: *mut GstBaseSrc, allocator: *mut *mut gst::GstAllocator, params: *mut gst::GstAllocationParams, )1909 pub fn gst_base_src_get_allocator( 1910 src: *mut GstBaseSrc, 1911 allocator: *mut *mut gst::GstAllocator, 1912 params: *mut gst::GstAllocationParams, 1913 ); gst_base_src_get_blocksize(src: *mut GstBaseSrc) -> c_uint1914 pub fn gst_base_src_get_blocksize(src: *mut GstBaseSrc) -> c_uint; gst_base_src_get_buffer_pool(src: *mut GstBaseSrc) -> *mut gst::GstBufferPool1915 pub fn gst_base_src_get_buffer_pool(src: *mut GstBaseSrc) -> *mut gst::GstBufferPool; gst_base_src_get_do_timestamp(src: *mut GstBaseSrc) -> gboolean1916 pub fn gst_base_src_get_do_timestamp(src: *mut GstBaseSrc) -> gboolean; gst_base_src_is_async(src: *mut GstBaseSrc) -> gboolean1917 pub fn gst_base_src_is_async(src: *mut GstBaseSrc) -> gboolean; gst_base_src_is_live(src: *mut GstBaseSrc) -> gboolean1918 pub fn gst_base_src_is_live(src: *mut GstBaseSrc) -> gboolean; gst_base_src_new_seamless_segment( src: *mut GstBaseSrc, start: i64, stop: i64, time: i64, ) -> gboolean1919 pub fn gst_base_src_new_seamless_segment( 1920 src: *mut GstBaseSrc, 1921 start: i64, 1922 stop: i64, 1923 time: i64, 1924 ) -> gboolean; gst_base_src_query_latency( src: *mut GstBaseSrc, live: *mut gboolean, min_latency: *mut gst::GstClockTime, max_latency: *mut gst::GstClockTime, ) -> gboolean1925 pub fn gst_base_src_query_latency( 1926 src: *mut GstBaseSrc, 1927 live: *mut gboolean, 1928 min_latency: *mut gst::GstClockTime, 1929 max_latency: *mut gst::GstClockTime, 1930 ) -> gboolean; gst_base_src_set_async(src: *mut GstBaseSrc, async: gboolean)1931 pub fn gst_base_src_set_async(src: *mut GstBaseSrc, async: gboolean); 1932 #[cfg(any(feature = "v1_4", feature = "dox"))] gst_base_src_set_automatic_eos(src: *mut GstBaseSrc, automatic_eos: gboolean)1933 pub fn gst_base_src_set_automatic_eos(src: *mut GstBaseSrc, automatic_eos: gboolean); gst_base_src_set_blocksize(src: *mut GstBaseSrc, blocksize: c_uint)1934 pub fn gst_base_src_set_blocksize(src: *mut GstBaseSrc, blocksize: c_uint); gst_base_src_set_caps(src: *mut GstBaseSrc, caps: *mut gst::GstCaps) -> gboolean1935 pub fn gst_base_src_set_caps(src: *mut GstBaseSrc, caps: *mut gst::GstCaps) -> gboolean; gst_base_src_set_do_timestamp(src: *mut GstBaseSrc, timestamp: gboolean)1936 pub fn gst_base_src_set_do_timestamp(src: *mut GstBaseSrc, timestamp: gboolean); gst_base_src_set_dynamic_size(src: *mut GstBaseSrc, dynamic: gboolean)1937 pub fn gst_base_src_set_dynamic_size(src: *mut GstBaseSrc, dynamic: gboolean); gst_base_src_set_format(src: *mut GstBaseSrc, format: gst::GstFormat)1938 pub fn gst_base_src_set_format(src: *mut GstBaseSrc, format: gst::GstFormat); gst_base_src_set_live(src: *mut GstBaseSrc, live: gboolean)1939 pub fn gst_base_src_set_live(src: *mut GstBaseSrc, live: gboolean); gst_base_src_start_complete(basesrc: *mut GstBaseSrc, ret: gst::GstFlowReturn)1940 pub fn gst_base_src_start_complete(basesrc: *mut GstBaseSrc, ret: gst::GstFlowReturn); gst_base_src_start_wait(basesrc: *mut GstBaseSrc) -> gst::GstFlowReturn1941 pub fn gst_base_src_start_wait(basesrc: *mut GstBaseSrc) -> gst::GstFlowReturn; 1942 #[cfg(any(feature = "v1_14", feature = "dox"))] gst_base_src_submit_buffer_list( src: *mut GstBaseSrc, buffer_list: *mut gst::GstBufferList, )1943 pub fn gst_base_src_submit_buffer_list( 1944 src: *mut GstBaseSrc, 1945 buffer_list: *mut gst::GstBufferList, 1946 ); gst_base_src_wait_playing(src: *mut GstBaseSrc) -> gst::GstFlowReturn1947 pub fn gst_base_src_wait_playing(src: *mut GstBaseSrc) -> gst::GstFlowReturn; 1948 1949 //========================================================================= 1950 // GstBaseTransform 1951 //========================================================================= gst_base_transform_get_type() -> GType1952 pub fn gst_base_transform_get_type() -> GType; gst_base_transform_get_allocator( trans: *mut GstBaseTransform, allocator: *mut *mut gst::GstAllocator, params: *mut gst::GstAllocationParams, )1953 pub fn gst_base_transform_get_allocator( 1954 trans: *mut GstBaseTransform, 1955 allocator: *mut *mut gst::GstAllocator, 1956 params: *mut gst::GstAllocationParams, 1957 ); gst_base_transform_get_buffer_pool( trans: *mut GstBaseTransform, ) -> *mut gst::GstBufferPool1958 pub fn gst_base_transform_get_buffer_pool( 1959 trans: *mut GstBaseTransform, 1960 ) -> *mut gst::GstBufferPool; gst_base_transform_is_in_place(trans: *mut GstBaseTransform) -> gboolean1961 pub fn gst_base_transform_is_in_place(trans: *mut GstBaseTransform) -> gboolean; gst_base_transform_is_passthrough(trans: *mut GstBaseTransform) -> gboolean1962 pub fn gst_base_transform_is_passthrough(trans: *mut GstBaseTransform) -> gboolean; gst_base_transform_is_qos_enabled(trans: *mut GstBaseTransform) -> gboolean1963 pub fn gst_base_transform_is_qos_enabled(trans: *mut GstBaseTransform) -> gboolean; gst_base_transform_reconfigure_sink(trans: *mut GstBaseTransform)1964 pub fn gst_base_transform_reconfigure_sink(trans: *mut GstBaseTransform); gst_base_transform_reconfigure_src(trans: *mut GstBaseTransform)1965 pub fn gst_base_transform_reconfigure_src(trans: *mut GstBaseTransform); gst_base_transform_set_gap_aware(trans: *mut GstBaseTransform, gap_aware: gboolean)1966 pub fn gst_base_transform_set_gap_aware(trans: *mut GstBaseTransform, gap_aware: gboolean); gst_base_transform_set_in_place(trans: *mut GstBaseTransform, in_place: gboolean)1967 pub fn gst_base_transform_set_in_place(trans: *mut GstBaseTransform, in_place: gboolean); gst_base_transform_set_passthrough(trans: *mut GstBaseTransform, passthrough: gboolean)1968 pub fn gst_base_transform_set_passthrough(trans: *mut GstBaseTransform, passthrough: gboolean); 1969 #[cfg(any(feature = "v1_0_1", feature = "dox"))] gst_base_transform_set_prefer_passthrough( trans: *mut GstBaseTransform, prefer_passthrough: gboolean, )1970 pub fn gst_base_transform_set_prefer_passthrough( 1971 trans: *mut GstBaseTransform, 1972 prefer_passthrough: gboolean, 1973 ); gst_base_transform_set_qos_enabled(trans: *mut GstBaseTransform, enabled: gboolean)1974 pub fn gst_base_transform_set_qos_enabled(trans: *mut GstBaseTransform, enabled: gboolean); gst_base_transform_update_qos( trans: *mut GstBaseTransform, proportion: c_double, diff: gst::GstClockTimeDiff, timestamp: gst::GstClockTime, )1975 pub fn gst_base_transform_update_qos( 1976 trans: *mut GstBaseTransform, 1977 proportion: c_double, 1978 diff: gst::GstClockTimeDiff, 1979 timestamp: gst::GstClockTime, 1980 ); 1981 #[cfg(any(feature = "v1_6", feature = "dox"))] gst_base_transform_update_src_caps( trans: *mut GstBaseTransform, updated_caps: *mut gst::GstCaps, ) -> gboolean1982 pub fn gst_base_transform_update_src_caps( 1983 trans: *mut GstBaseTransform, 1984 updated_caps: *mut gst::GstCaps, 1985 ) -> gboolean; 1986 1987 //========================================================================= 1988 // GstCollectPads 1989 //========================================================================= gst_collect_pads_get_type() -> GType1990 pub fn gst_collect_pads_get_type() -> GType; gst_collect_pads_new() -> *mut GstCollectPads1991 pub fn gst_collect_pads_new() -> *mut GstCollectPads; gst_collect_pads_add_pad( pads: *mut GstCollectPads, pad: *mut gst::GstPad, size: c_uint, destroy_notify: GstCollectDataDestroyNotify, lock: gboolean, ) -> *mut GstCollectData1992 pub fn gst_collect_pads_add_pad( 1993 pads: *mut GstCollectPads, 1994 pad: *mut gst::GstPad, 1995 size: c_uint, 1996 destroy_notify: GstCollectDataDestroyNotify, 1997 lock: gboolean, 1998 ) -> *mut GstCollectData; gst_collect_pads_available(pads: *mut GstCollectPads) -> c_uint1999 pub fn gst_collect_pads_available(pads: *mut GstCollectPads) -> c_uint; gst_collect_pads_clip_running_time( pads: *mut GstCollectPads, cdata: *mut GstCollectData, buf: *mut gst::GstBuffer, outbuf: *mut *mut gst::GstBuffer, user_data: gpointer, ) -> gst::GstFlowReturn2000 pub fn gst_collect_pads_clip_running_time( 2001 pads: *mut GstCollectPads, 2002 cdata: *mut GstCollectData, 2003 buf: *mut gst::GstBuffer, 2004 outbuf: *mut *mut gst::GstBuffer, 2005 user_data: gpointer, 2006 ) -> gst::GstFlowReturn; gst_collect_pads_event_default( pads: *mut GstCollectPads, data: *mut GstCollectData, event: *mut gst::GstEvent, discard: gboolean, ) -> gboolean2007 pub fn gst_collect_pads_event_default( 2008 pads: *mut GstCollectPads, 2009 data: *mut GstCollectData, 2010 event: *mut gst::GstEvent, 2011 discard: gboolean, 2012 ) -> gboolean; gst_collect_pads_flush( pads: *mut GstCollectPads, data: *mut GstCollectData, size: c_uint, ) -> c_uint2013 pub fn gst_collect_pads_flush( 2014 pads: *mut GstCollectPads, 2015 data: *mut GstCollectData, 2016 size: c_uint, 2017 ) -> c_uint; gst_collect_pads_peek( pads: *mut GstCollectPads, data: *mut GstCollectData, ) -> *mut gst::GstBuffer2018 pub fn gst_collect_pads_peek( 2019 pads: *mut GstCollectPads, 2020 data: *mut GstCollectData, 2021 ) -> *mut gst::GstBuffer; gst_collect_pads_pop( pads: *mut GstCollectPads, data: *mut GstCollectData, ) -> *mut gst::GstBuffer2022 pub fn gst_collect_pads_pop( 2023 pads: *mut GstCollectPads, 2024 data: *mut GstCollectData, 2025 ) -> *mut gst::GstBuffer; gst_collect_pads_query_default( pads: *mut GstCollectPads, data: *mut GstCollectData, query: *mut gst::GstQuery, discard: gboolean, ) -> gboolean2026 pub fn gst_collect_pads_query_default( 2027 pads: *mut GstCollectPads, 2028 data: *mut GstCollectData, 2029 query: *mut gst::GstQuery, 2030 discard: gboolean, 2031 ) -> gboolean; gst_collect_pads_read_buffer( pads: *mut GstCollectPads, data: *mut GstCollectData, size: c_uint, ) -> *mut gst::GstBuffer2032 pub fn gst_collect_pads_read_buffer( 2033 pads: *mut GstCollectPads, 2034 data: *mut GstCollectData, 2035 size: c_uint, 2036 ) -> *mut gst::GstBuffer; gst_collect_pads_remove_pad( pads: *mut GstCollectPads, pad: *mut gst::GstPad, ) -> gboolean2037 pub fn gst_collect_pads_remove_pad( 2038 pads: *mut GstCollectPads, 2039 pad: *mut gst::GstPad, 2040 ) -> gboolean; gst_collect_pads_set_buffer_function( pads: *mut GstCollectPads, func: GstCollectPadsBufferFunction, user_data: gpointer, )2041 pub fn gst_collect_pads_set_buffer_function( 2042 pads: *mut GstCollectPads, 2043 func: GstCollectPadsBufferFunction, 2044 user_data: gpointer, 2045 ); gst_collect_pads_set_clip_function( pads: *mut GstCollectPads, clipfunc: GstCollectPadsClipFunction, user_data: gpointer, )2046 pub fn gst_collect_pads_set_clip_function( 2047 pads: *mut GstCollectPads, 2048 clipfunc: GstCollectPadsClipFunction, 2049 user_data: gpointer, 2050 ); gst_collect_pads_set_compare_function( pads: *mut GstCollectPads, func: GstCollectPadsCompareFunction, user_data: gpointer, )2051 pub fn gst_collect_pads_set_compare_function( 2052 pads: *mut GstCollectPads, 2053 func: GstCollectPadsCompareFunction, 2054 user_data: gpointer, 2055 ); gst_collect_pads_set_event_function( pads: *mut GstCollectPads, func: GstCollectPadsEventFunction, user_data: gpointer, )2056 pub fn gst_collect_pads_set_event_function( 2057 pads: *mut GstCollectPads, 2058 func: GstCollectPadsEventFunction, 2059 user_data: gpointer, 2060 ); 2061 #[cfg(any(feature = "v1_4", feature = "dox"))] gst_collect_pads_set_flush_function( pads: *mut GstCollectPads, func: GstCollectPadsFlushFunction, user_data: gpointer, )2062 pub fn gst_collect_pads_set_flush_function( 2063 pads: *mut GstCollectPads, 2064 func: GstCollectPadsFlushFunction, 2065 user_data: gpointer, 2066 ); gst_collect_pads_set_flushing(pads: *mut GstCollectPads, flushing: gboolean)2067 pub fn gst_collect_pads_set_flushing(pads: *mut GstCollectPads, flushing: gboolean); gst_collect_pads_set_function( pads: *mut GstCollectPads, func: GstCollectPadsFunction, user_data: gpointer, )2068 pub fn gst_collect_pads_set_function( 2069 pads: *mut GstCollectPads, 2070 func: GstCollectPadsFunction, 2071 user_data: gpointer, 2072 ); gst_collect_pads_set_query_function( pads: *mut GstCollectPads, func: GstCollectPadsQueryFunction, user_data: gpointer, )2073 pub fn gst_collect_pads_set_query_function( 2074 pads: *mut GstCollectPads, 2075 func: GstCollectPadsQueryFunction, 2076 user_data: gpointer, 2077 ); gst_collect_pads_set_waiting( pads: *mut GstCollectPads, data: *mut GstCollectData, waiting: gboolean, )2078 pub fn gst_collect_pads_set_waiting( 2079 pads: *mut GstCollectPads, 2080 data: *mut GstCollectData, 2081 waiting: gboolean, 2082 ); 2083 #[cfg(any(feature = "v1_4", feature = "dox"))] gst_collect_pads_src_event_default( pads: *mut GstCollectPads, pad: *mut gst::GstPad, event: *mut gst::GstEvent, ) -> gboolean2084 pub fn gst_collect_pads_src_event_default( 2085 pads: *mut GstCollectPads, 2086 pad: *mut gst::GstPad, 2087 event: *mut gst::GstEvent, 2088 ) -> gboolean; gst_collect_pads_start(pads: *mut GstCollectPads)2089 pub fn gst_collect_pads_start(pads: *mut GstCollectPads); gst_collect_pads_stop(pads: *mut GstCollectPads)2090 pub fn gst_collect_pads_stop(pads: *mut GstCollectPads); gst_collect_pads_take_buffer( pads: *mut GstCollectPads, data: *mut GstCollectData, size: c_uint, ) -> *mut gst::GstBuffer2091 pub fn gst_collect_pads_take_buffer( 2092 pads: *mut GstCollectPads, 2093 data: *mut GstCollectData, 2094 size: c_uint, 2095 ) -> *mut gst::GstBuffer; 2096 2097 //========================================================================= 2098 // GstDataQueue 2099 //========================================================================= gst_data_queue_get_type() -> GType2100 pub fn gst_data_queue_get_type() -> GType; 2101 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_new( checkfull: GstDataQueueCheckFullFunction, fullcallback: GstDataQueueFullCallback, emptycallback: GstDataQueueEmptyCallback, checkdata: gpointer, ) -> *mut GstDataQueue2102 pub fn gst_data_queue_new( 2103 checkfull: GstDataQueueCheckFullFunction, 2104 fullcallback: GstDataQueueFullCallback, 2105 emptycallback: GstDataQueueEmptyCallback, 2106 checkdata: gpointer, 2107 ) -> *mut GstDataQueue; 2108 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_drop_head(queue: *mut GstDataQueue, type_: GType) -> gboolean2109 pub fn gst_data_queue_drop_head(queue: *mut GstDataQueue, type_: GType) -> gboolean; 2110 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_flush(queue: *mut GstDataQueue)2111 pub fn gst_data_queue_flush(queue: *mut GstDataQueue); 2112 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_get_level(queue: *mut GstDataQueue, level: *mut GstDataQueueSize)2113 pub fn gst_data_queue_get_level(queue: *mut GstDataQueue, level: *mut GstDataQueueSize); 2114 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_is_empty(queue: *mut GstDataQueue) -> gboolean2115 pub fn gst_data_queue_is_empty(queue: *mut GstDataQueue) -> gboolean; 2116 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_is_full(queue: *mut GstDataQueue) -> gboolean2117 pub fn gst_data_queue_is_full(queue: *mut GstDataQueue) -> gboolean; 2118 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_limits_changed(queue: *mut GstDataQueue)2119 pub fn gst_data_queue_limits_changed(queue: *mut GstDataQueue); 2120 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_peek( queue: *mut GstDataQueue, item: *mut *mut GstDataQueueItem, ) -> gboolean2121 pub fn gst_data_queue_peek( 2122 queue: *mut GstDataQueue, 2123 item: *mut *mut GstDataQueueItem, 2124 ) -> gboolean; 2125 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_pop( queue: *mut GstDataQueue, item: *mut *mut GstDataQueueItem, ) -> gboolean2126 pub fn gst_data_queue_pop( 2127 queue: *mut GstDataQueue, 2128 item: *mut *mut GstDataQueueItem, 2129 ) -> gboolean; 2130 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_push(queue: *mut GstDataQueue, item: *mut GstDataQueueItem) -> gboolean2131 pub fn gst_data_queue_push(queue: *mut GstDataQueue, item: *mut GstDataQueueItem) -> gboolean; 2132 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_push_force( queue: *mut GstDataQueue, item: *mut GstDataQueueItem, ) -> gboolean2133 pub fn gst_data_queue_push_force( 2134 queue: *mut GstDataQueue, 2135 item: *mut GstDataQueueItem, 2136 ) -> gboolean; 2137 #[cfg(any(feature = "v1_2", feature = "dox"))] gst_data_queue_set_flushing(queue: *mut GstDataQueue, flushing: gboolean)2138 pub fn gst_data_queue_set_flushing(queue: *mut GstDataQueue, flushing: gboolean); 2139 2140 //========================================================================= 2141 // GstPushSrc 2142 //========================================================================= gst_push_src_get_type() -> GType2143 pub fn gst_push_src_get_type() -> GType; 2144 2145 //========================================================================= 2146 // Other functions 2147 //========================================================================= gst_type_find_helper(src: *mut gst::GstPad, size: u64) -> *mut gst::GstCaps2148 pub fn gst_type_find_helper(src: *mut gst::GstPad, size: u64) -> *mut gst::GstCaps; gst_type_find_helper_for_buffer( obj: *mut gst::GstObject, buf: *mut gst::GstBuffer, prob: *mut gst::GstTypeFindProbability, ) -> *mut gst::GstCaps2149 pub fn gst_type_find_helper_for_buffer( 2150 obj: *mut gst::GstObject, 2151 buf: *mut gst::GstBuffer, 2152 prob: *mut gst::GstTypeFindProbability, 2153 ) -> *mut gst::GstCaps; 2154 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_type_find_helper_for_buffer_with_extension( obj: *mut gst::GstObject, buf: *mut gst::GstBuffer, extension: *const c_char, prob: *mut gst::GstTypeFindProbability, ) -> *mut gst::GstCaps2155 pub fn gst_type_find_helper_for_buffer_with_extension( 2156 obj: *mut gst::GstObject, 2157 buf: *mut gst::GstBuffer, 2158 extension: *const c_char, 2159 prob: *mut gst::GstTypeFindProbability, 2160 ) -> *mut gst::GstCaps; gst_type_find_helper_for_data( obj: *mut gst::GstObject, data: *const u8, size: size_t, prob: *mut gst::GstTypeFindProbability, ) -> *mut gst::GstCaps2161 pub fn gst_type_find_helper_for_data( 2162 obj: *mut gst::GstObject, 2163 data: *const u8, 2164 size: size_t, 2165 prob: *mut gst::GstTypeFindProbability, 2166 ) -> *mut gst::GstCaps; 2167 #[cfg(any(feature = "v1_16", feature = "dox"))] gst_type_find_helper_for_data_with_extension( obj: *mut gst::GstObject, data: *const u8, size: size_t, extension: *const c_char, prob: *mut gst::GstTypeFindProbability, ) -> *mut gst::GstCaps2168 pub fn gst_type_find_helper_for_data_with_extension( 2169 obj: *mut gst::GstObject, 2170 data: *const u8, 2171 size: size_t, 2172 extension: *const c_char, 2173 prob: *mut gst::GstTypeFindProbability, 2174 ) -> *mut gst::GstCaps; gst_type_find_helper_for_extension( obj: *mut gst::GstObject, extension: *const c_char, ) -> *mut gst::GstCaps2175 pub fn gst_type_find_helper_for_extension( 2176 obj: *mut gst::GstObject, 2177 extension: *const c_char, 2178 ) -> *mut gst::GstCaps; gst_type_find_helper_get_range( obj: *mut gst::GstObject, parent: *mut gst::GstObject, func: GstTypeFindHelperGetRangeFunction, size: u64, extension: *const c_char, prob: *mut gst::GstTypeFindProbability, ) -> *mut gst::GstCaps2179 pub fn gst_type_find_helper_get_range( 2180 obj: *mut gst::GstObject, 2181 parent: *mut gst::GstObject, 2182 func: GstTypeFindHelperGetRangeFunction, 2183 size: u64, 2184 extension: *const c_char, 2185 prob: *mut gst::GstTypeFindProbability, 2186 ) -> *mut gst::GstCaps; 2187 #[cfg(any(feature = "v1_14_3", feature = "dox"))] gst_type_find_helper_get_range_full( obj: *mut gst::GstObject, parent: *mut gst::GstObject, func: GstTypeFindHelperGetRangeFunction, size: u64, extension: *const c_char, caps: *mut *mut gst::GstCaps, prob: *mut gst::GstTypeFindProbability, ) -> gst::GstFlowReturn2188 pub fn gst_type_find_helper_get_range_full( 2189 obj: *mut gst::GstObject, 2190 parent: *mut gst::GstObject, 2191 func: GstTypeFindHelperGetRangeFunction, 2192 size: u64, 2193 extension: *const c_char, 2194 caps: *mut *mut gst::GstCaps, 2195 prob: *mut gst::GstTypeFindProbability, 2196 ) -> gst::GstFlowReturn; 2197 2198 } 2199