1 /* 2 * This file is part of gtkD. 3 * 4 * gtkD is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU Lesser General Public License 6 * as published by the Free Software Foundation; either version 3 7 * of the License, or (at your option) any later version, with 8 * some exceptions, please read the COPYING file. 9 * 10 * gtkD is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with gtkD; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA 18 */ 19 20 // generated automatically - do not change 21 // find conversion definition on APILookup.txt 22 // implement new conversion functionalities on the wrap.utils pakage 23 24 25 module gst.base.c.types; 26 27 public import glib.c.types; 28 public import gobject.c.types; 29 public import gstreamer.c.types; 30 31 32 /** 33 * Flags to be used in a #GstBaseParseFrame. 34 */ 35 public enum GstBaseParseFrameFlags 36 { 37 /** 38 * no flag 39 */ 40 NONE = 0, 41 /** 42 * set by baseclass if current frame 43 * is passed for processing to the subclass for the first time 44 * (and not set on subsequent calls with same data). 45 */ 46 NEW_FRAME = 1, 47 /** 48 * set to indicate this buffer should not be 49 * counted as frame, e.g. if this frame is dependent on a previous one. 50 * As it is not counted as a frame, bitrate increases but frame to time 51 * conversions are maintained. 52 */ 53 NO_FRAME = 2, 54 /** 55 * @pre_push_frame can set this to indicate 56 * that regular segment clipping can still be performed (as opposed to 57 * any custom one having been done). 58 */ 59 CLIP = 4, 60 /** 61 * indicates to @finish_frame that the 62 * the frame should be dropped (and might be handled internally by subclass) 63 */ 64 DROP = 8, 65 /** 66 * indicates to @finish_frame that the 67 * the frame should be queued for now and processed fully later 68 * when the first non-queued frame is finished 69 */ 70 QUEUE = 16, 71 } 72 alias GstBaseParseFrameFlags BaseParseFrameFlags; 73 74 /** 75 * The #GstElement flags that a basesrc element may have. 76 */ 77 public enum GstBaseSrcFlags 78 { 79 /** 80 * has source is starting 81 */ 82 STARTING = 16384, 83 /** 84 * has source been started 85 */ 86 STARTED = 32768, 87 /** 88 * offset to define more flags 89 */ 90 LAST = 1048576, 91 } 92 alias GstBaseSrcFlags BaseSrcFlags; 93 94 public enum GstCollectPadsStateFlags 95 { 96 /** 97 * Set if collectdata's pad is EOS. 98 */ 99 EOS = 1, 100 /** 101 * Set if collectdata's pad is flushing. 102 */ 103 FLUSHING = 2, 104 /** 105 * Set if collectdata's pad received a 106 * new_segment event. 107 */ 108 NEW_SEGMENT = 4, 109 /** 110 * Set if collectdata's pad must be waited 111 * for when collecting. 112 */ 113 WAITING = 8, 114 /** 115 * Set collectdata's pad WAITING state must 116 * not be changed. 117 * #GstCollectPadsStateFlags indicate private state of a collectdata('s pad). 118 */ 119 LOCKED = 16, 120 } 121 alias GstCollectPadsStateFlags CollectPadsStateFlags; 122 123 struct GstAdapter; 124 125 struct GstAdapterClass; 126 127 struct GstBaseParse 128 { 129 /** 130 * the parent element. 131 */ 132 GstElement element; 133 GstPad* sinkpad; 134 GstPad* srcpad; 135 uint flags; 136 GstSegment segment; 137 void*[20] GstReserved; 138 GstBaseParsePrivate* priv; 139 } 140 141 /** 142 * Subclasses can override any of the available virtual methods or not, as 143 * needed. At minimum @handle_frame needs to be overridden. 144 */ 145 struct GstBaseParseClass 146 { 147 /** 148 * the parent class 149 */ 150 GstElementClass parentClass; 151 /** */ 152 extern(C) int function(GstBaseParse* parse) start; 153 /** */ 154 extern(C) int function(GstBaseParse* parse) stop; 155 /** */ 156 extern(C) int function(GstBaseParse* parse, GstCaps* caps) setSinkCaps; 157 /** */ 158 extern(C) GstFlowReturn function(GstBaseParse* parse, GstBaseParseFrame* frame, int* skipsize) handleFrame; 159 /** */ 160 extern(C) GstFlowReturn function(GstBaseParse* parse, GstBaseParseFrame* frame) prePushFrame; 161 /** */ 162 extern(C) int function(GstBaseParse* parse, GstFormat srcFormat, long srcValue, GstFormat destFormat, long* destValue) convert; 163 /** */ 164 extern(C) int function(GstBaseParse* parse, GstEvent* event) sinkEvent; 165 /** */ 166 extern(C) int function(GstBaseParse* parse, GstEvent* event) srcEvent; 167 /** */ 168 extern(C) GstCaps* function(GstBaseParse* parse, GstCaps* filter) getSinkCaps; 169 /** */ 170 extern(C) GstFlowReturn function(GstBaseParse* parse, GstBuffer* buffer) detect; 171 /** */ 172 extern(C) int function(GstBaseParse* parse, GstQuery* query) sinkQuery; 173 /** */ 174 extern(C) int function(GstBaseParse* parse, GstQuery* query) srcQuery; 175 void*[18] GstReserved; 176 } 177 178 struct GstBaseParseFrame 179 { 180 /** 181 * input data to be parsed for frames. 182 */ 183 GstBuffer* buffer; 184 /** 185 * output data. 186 */ 187 GstBuffer* outBuffer; 188 /** 189 * a combination of input and output #GstBaseParseFrameFlags that 190 * convey additional context to subclass or allow subclass to tune 191 * subsequent #GstBaseParse actions. 192 */ 193 uint flags; 194 /** 195 * media specific offset of input frame 196 * Note that a converter may have a different one on the frame's buffer. 197 */ 198 ulong offset; 199 /** 200 * subclass can set this to indicates the metadata overhead 201 * for the given frame, which is then used to enable more accurate bitrate 202 * computations. If this is -1, it is assumed that this frame should be 203 * skipped in bitrate calculation. 204 */ 205 int overhead; 206 int size; 207 uint[2] GstReservedI; 208 void*[2] GstReservedP; 209 uint PrivateFlags; 210 } 211 212 struct GstBaseParsePrivate; 213 214 struct GstBaseSink 215 { 216 GstElement element; 217 GstPad* sinkpad; 218 GstPadMode padMode; 219 ulong offset; 220 bool canActivatePull; 221 bool canActivatePush; 222 GMutex prerollLock; 223 GCond prerollCond; 224 bool eos; 225 bool needPreroll; 226 bool havePreroll; 227 bool playingAsync; 228 bool haveNewsegment; 229 GstSegment segment; 230 GstClockID clockId; 231 bool sync; 232 bool flushing; 233 bool running; 234 long maxLateness; 235 GstBaseSinkPrivate* priv; 236 void*[20] GstReserved; 237 } 238 239 /** 240 * Subclasses can override any of the available virtual methods or not, as 241 * needed. At the minimum, the @render method should be overridden to 242 * output/present buffers. 243 */ 244 struct GstBaseSinkClass 245 { 246 /** 247 * Element parent class 248 */ 249 GstElementClass parentClass; 250 /** */ 251 extern(C) GstCaps* function(GstBaseSink* sink, GstCaps* filter) getCaps; 252 /** */ 253 extern(C) int function(GstBaseSink* sink, GstCaps* caps) setCaps; 254 /** */ 255 extern(C) GstCaps* function(GstBaseSink* sink, GstCaps* caps) fixate; 256 /** */ 257 extern(C) int function(GstBaseSink* sink, int active) activatePull; 258 /** */ 259 extern(C) void function(GstBaseSink* sink, GstBuffer* buffer, GstClockTime* start, GstClockTime* end) getTimes; 260 /** */ 261 extern(C) int function(GstBaseSink* sink, GstQuery* query) proposeAllocation; 262 /** */ 263 extern(C) int function(GstBaseSink* sink) start; 264 /** */ 265 extern(C) int function(GstBaseSink* sink) stop; 266 /** */ 267 extern(C) int function(GstBaseSink* sink) unlock; 268 /** */ 269 extern(C) int function(GstBaseSink* sink) unlockStop; 270 /** */ 271 extern(C) int function(GstBaseSink* sink, GstQuery* query) query; 272 /** */ 273 extern(C) int function(GstBaseSink* sink, GstEvent* event) event; 274 /** */ 275 extern(C) GstFlowReturn function(GstBaseSink* sink, GstEvent* event) waitEvent; 276 /** */ 277 extern(C) GstFlowReturn function(GstBaseSink* sink, GstBuffer* buffer) prepare; 278 /** */ 279 extern(C) GstFlowReturn function(GstBaseSink* sink, GstBufferList* bufferList) prepareList; 280 /** */ 281 extern(C) GstFlowReturn function(GstBaseSink* sink, GstBuffer* buffer) preroll; 282 /** */ 283 extern(C) GstFlowReturn function(GstBaseSink* sink, GstBuffer* buffer) render; 284 /** */ 285 extern(C) GstFlowReturn function(GstBaseSink* sink, GstBufferList* bufferList) renderList; 286 void*[20] GstReserved; 287 } 288 289 struct GstBaseSinkPrivate; 290 291 struct GstBaseSrc 292 { 293 GstElement element; 294 GstPad* srcpad; 295 GMutex liveLock; 296 GCond liveCond; 297 bool isLive; 298 bool liveRunning; 299 uint blocksize; 300 bool canActivatePush; 301 bool randomAccess; 302 GstClockID clockId; 303 GstSegment segment; 304 bool needNewsegment; 305 int numBuffers; 306 int numBuffersLeft; 307 bool typefind; 308 bool running; 309 GstEvent* pendingSeek; 310 GstBaseSrcPrivate* priv; 311 void*[20] GstReserved; 312 } 313 314 /** 315 * Subclasses can override any of the available virtual methods or not, as 316 * needed. At the minimum, the @create method should be overridden to produce 317 * buffers. 318 */ 319 struct GstBaseSrcClass 320 { 321 /** 322 * Element parent class 323 */ 324 GstElementClass parentClass; 325 /** */ 326 extern(C) GstCaps* function(GstBaseSrc* src, GstCaps* filter) getCaps; 327 /** */ 328 extern(C) int function(GstBaseSrc* src) negotiate; 329 /** */ 330 extern(C) GstCaps* function(GstBaseSrc* src, GstCaps* caps) fixate; 331 /** 332 * 333 * Params: 334 * src = a #GstBaseSrc 335 * caps = a #GstCaps 336 * Returns: %TRUE if the caps could be set 337 */ 338 extern(C) int function(GstBaseSrc* src, GstCaps* caps) setCaps; 339 /** */ 340 extern(C) int function(GstBaseSrc* src, GstQuery* query) decideAllocation; 341 /** */ 342 extern(C) int function(GstBaseSrc* src) start; 343 /** */ 344 extern(C) int function(GstBaseSrc* src) stop; 345 /** */ 346 extern(C) void function(GstBaseSrc* src, GstBuffer* buffer, GstClockTime* start, GstClockTime* end) getTimes; 347 /** */ 348 extern(C) int function(GstBaseSrc* src, ulong* size) getSize; 349 /** */ 350 extern(C) int function(GstBaseSrc* src) isSeekable; 351 /** */ 352 extern(C) int function(GstBaseSrc* src, GstEvent* seek, GstSegment* segment) prepareSeekSegment; 353 /** */ 354 extern(C) int function(GstBaseSrc* src, GstSegment* segment) doSeek; 355 /** */ 356 extern(C) int function(GstBaseSrc* src) unlock; 357 /** */ 358 extern(C) int function(GstBaseSrc* src) unlockStop; 359 /** */ 360 extern(C) int function(GstBaseSrc* src, GstQuery* query) query; 361 /** */ 362 extern(C) int function(GstBaseSrc* src, GstEvent* event) event; 363 /** */ 364 extern(C) GstFlowReturn function(GstBaseSrc* src, ulong offset, uint size, GstBuffer** buf) create; 365 /** */ 366 extern(C) GstFlowReturn function(GstBaseSrc* src, ulong offset, uint size, GstBuffer** buf) alloc; 367 /** */ 368 extern(C) GstFlowReturn function(GstBaseSrc* src, ulong offset, uint size, GstBuffer* buf) fill; 369 void*[20] GstReserved; 370 } 371 372 struct GstBaseSrcPrivate; 373 374 struct GstBaseTransform 375 { 376 GstElement element; 377 GstPad* sinkpad; 378 GstPad* srcpad; 379 bool haveSegment; 380 GstSegment segment; 381 GstBuffer* queuedBuf; 382 GstBaseTransformPrivate* priv; 383 void*[19] GstReserved; 384 } 385 386 /** 387 * Subclasses can override any of the available virtual methods or not, as 388 * needed. At minimum either @transform or @transform_ip need to be overridden. 389 * If the element can overwrite the input data with the results (data is of the 390 * same type and quantity) it should provide @transform_ip. 391 */ 392 struct GstBaseTransformClass 393 { 394 /** 395 * Element parent class 396 */ 397 GstElementClass parentClass; 398 /** 399 * If set to %TRUE, passthrough mode will be 400 * automatically enabled if the caps are the same. 401 * Set to %FALSE by default. 402 */ 403 bool passthroughOnSameCaps; 404 /** 405 * If set to %TRUE, @transform_ip will be called in 406 * passthrough mode. The passed buffer might not be 407 * writable. When %FALSE, neither @transform nor 408 * @transform_ip will be called in passthrough mode. 409 * Set to %TRUE by default. 410 */ 411 bool transformIpOnPassthrough; 412 /** */ 413 extern(C) GstCaps* function(GstBaseTransform* trans, GstPadDirection direction, GstCaps* caps, GstCaps* filter) transformCaps; 414 /** */ 415 extern(C) GstCaps* function(GstBaseTransform* trans, GstPadDirection direction, GstCaps* caps, GstCaps* othercaps) fixateCaps; 416 /** */ 417 extern(C) int function(GstBaseTransform* trans, GstPadDirection direction, GstCaps* caps) acceptCaps; 418 /** */ 419 extern(C) int function(GstBaseTransform* trans, GstCaps* incaps, GstCaps* outcaps) setCaps; 420 /** */ 421 extern(C) int function(GstBaseTransform* trans, GstPadDirection direction, GstQuery* query) query; 422 /** */ 423 extern(C) int function(GstBaseTransform* trans, GstQuery* query) decideAllocation; 424 /** */ 425 extern(C) int function(GstBaseTransform* trans, GstQuery* query, GType api, GstStructure* params) filterMeta; 426 /** */ 427 extern(C) int function(GstBaseTransform* trans, GstQuery* decideQuery, GstQuery* query) proposeAllocation; 428 /** */ 429 extern(C) int function(GstBaseTransform* trans, GstPadDirection direction, GstCaps* caps, size_t size, GstCaps* othercaps, size_t* othersize) transformSize; 430 /** */ 431 extern(C) int function(GstBaseTransform* trans, GstCaps* caps, size_t* size) getUnitSize; 432 /** */ 433 extern(C) int function(GstBaseTransform* trans) start; 434 /** */ 435 extern(C) int function(GstBaseTransform* trans) stop; 436 /** */ 437 extern(C) int function(GstBaseTransform* trans, GstEvent* event) sinkEvent; 438 /** */ 439 extern(C) int function(GstBaseTransform* trans, GstEvent* event) srcEvent; 440 /** */ 441 extern(C) GstFlowReturn function(GstBaseTransform* trans, GstBuffer* input, GstBuffer** outbuf) prepareOutputBuffer; 442 /** */ 443 extern(C) int function(GstBaseTransform* trans, GstBuffer* input, GstBuffer* outbuf) copyMetadata; 444 /** */ 445 extern(C) int function(GstBaseTransform* trans, GstBuffer* outbuf, GstMeta* meta, GstBuffer* inbuf) transformMeta; 446 /** */ 447 extern(C) void function(GstBaseTransform* trans, GstBuffer* buffer) beforeTransform; 448 /** */ 449 extern(C) GstFlowReturn function(GstBaseTransform* trans, GstBuffer* inbuf, GstBuffer* outbuf) transform; 450 /** */ 451 extern(C) GstFlowReturn function(GstBaseTransform* trans, GstBuffer* buf) transformIp; 452 /** */ 453 extern(C) GstFlowReturn function(GstBaseTransform* trans, int isDiscont, GstBuffer* input) submitInputBuffer; 454 /** */ 455 extern(C) GstFlowReturn function(GstBaseTransform* trans, GstBuffer** outbuf) generateOutput; 456 void*[18] GstReserved; 457 } 458 459 struct GstBaseTransformPrivate; 460 461 struct GstBitReader 462 { 463 /** 464 * Data from which the bit reader will 465 * read 466 */ 467 ubyte* data; 468 /** 469 * Size of @data in bytes 470 */ 471 uint size; 472 /** 473 * Current byte position 474 */ 475 uint _byte; 476 /** 477 * Bit position in the current byte 478 */ 479 uint bit; 480 void*[4] GstReserved; 481 } 482 483 struct GstByteReader 484 { 485 /** 486 * Data from which the bit reader will 487 * read 488 */ 489 ubyte* data; 490 /** 491 * Size of @data in bytes 492 */ 493 uint size; 494 /** 495 * Current byte position 496 */ 497 uint _byte; 498 void*[4] GstReserved; 499 } 500 501 struct GstByteWriter 502 { 503 /** 504 * #GstByteReader parent 505 */ 506 GstByteReader parent; 507 /** 508 * Allocation size of the data 509 */ 510 uint allocSize; 511 /** 512 * If %TRUE no reallocations are allowed 513 */ 514 bool fixed; 515 /** 516 * If %FALSE no reallocations are allowed and copies of data are returned 517 */ 518 bool owned; 519 void*[4] GstReserved; 520 } 521 522 /** 523 * Structure used by the collect_pads. 524 */ 525 struct GstCollectData 526 { 527 /** 528 * owner #GstCollectPads 529 */ 530 GstCollectPads* collect; 531 /** 532 * #GstPad managed by this data 533 */ 534 GstPad* pad; 535 /** 536 * currently queued buffer. 537 */ 538 GstBuffer* buffer; 539 /** 540 * position in the buffer 541 */ 542 uint pos; 543 /** 544 * last segment received. 545 */ 546 GstSegment segment; 547 GstCollectPadsStateFlags state; 548 GstCollectDataPrivate* priv; 549 union ABI 550 { 551 struct Abi 552 { 553 long dts; 554 } 555 Abi abi; 556 void*[4] GstReserved; 557 } 558 ABI abi; 559 } 560 561 struct GstCollectDataPrivate; 562 563 struct GstCollectPads 564 { 565 GstObject object; 566 /** 567 * #GList of #GstCollectData managed 568 * by this #GstCollectPads. 569 */ 570 GSList* data; 571 GRecMutex streamLock; 572 GstCollectPadsPrivate* priv; 573 void*[4] GstReserved; 574 } 575 576 struct GstCollectPadsClass 577 { 578 GstObjectClass parentClass; 579 void*[4] GstReserved; 580 } 581 582 struct GstCollectPadsPrivate; 583 584 struct GstDataQueue 585 { 586 /** 587 * the parent structure 588 */ 589 GObject object; 590 GstDataQueuePrivate* priv; 591 void*[4] GstReserved; 592 } 593 594 struct GstDataQueueClass 595 { 596 GObjectClass parentClass; 597 /** */ 598 extern(C) void function(GstDataQueue* queue) empty; 599 /** */ 600 extern(C) void function(GstDataQueue* queue) full; 601 void*[4] GstReserved; 602 } 603 604 /** 605 * Structure used by #GstDataQueue. You can supply a different structure, as 606 * long as the top of the structure is identical to this structure. 607 */ 608 struct GstDataQueueItem 609 { 610 /** 611 * the #GstMiniObject to queue. 612 */ 613 GstMiniObject* object; 614 /** 615 * the size in bytes of the miniobject. 616 */ 617 uint size; 618 /** 619 * the duration in #GstClockTime of the miniobject. Can not be 620 * %GST_CLOCK_TIME_NONE. 621 */ 622 ulong duration; 623 /** 624 * %TRUE if @object should be considered as a visible object. 625 */ 626 bool visible; 627 /** 628 * The #GDestroyNotify function to use to free the #GstDataQueueItem. 629 * This function should also drop the reference to @object the owner of the 630 * #GstDataQueueItem is assumed to hold. 631 */ 632 GDestroyNotify destroy; 633 void*[4] GstReserved; 634 } 635 636 struct GstDataQueuePrivate; 637 638 /** 639 * Structure describing the size of a queue. 640 */ 641 struct GstDataQueueSize 642 { 643 /** 644 * number of buffers 645 */ 646 uint visible; 647 /** 648 * number of bytes 649 */ 650 uint bytes; 651 /** 652 * amount of time 653 */ 654 ulong time; 655 } 656 657 struct GstFlowCombiner; 658 659 struct GstPushSrc 660 { 661 GstBaseSrc parent; 662 void*[4] GstReserved; 663 } 664 665 /** 666 * Subclasses can override any of the available virtual methods or not, as 667 * needed. At the minimum, the @fill method should be overridden to produce 668 * buffers. 669 */ 670 struct GstPushSrcClass 671 { 672 /** 673 * Element parent class 674 */ 675 GstBaseSrcClass parentClass; 676 /** */ 677 extern(C) GstFlowReturn function(GstPushSrc* src, GstBuffer** buf) create; 678 /** */ 679 extern(C) GstFlowReturn function(GstPushSrc* src, GstBuffer** buf) alloc; 680 /** */ 681 extern(C) GstFlowReturn function(GstPushSrc* src, GstBuffer* buf) fill; 682 void*[4] GstReserved; 683 } 684 685 struct GstQueueArray; 686 687 /** 688 * A function that will be called when the #GstCollectData will be freed. 689 * It is passed the pointer to the structure and should free any custom 690 * memory and resources allocated for it. 691 * 692 * Params: 693 * data = the #GstCollectData that will be freed 694 */ 695 public alias extern(C) void function(GstCollectData* data) GstCollectDataDestroyNotify; 696 697 /** 698 * A function that will be called when a (considered oldest) buffer can be muxed. 699 * If all pads have reached EOS, this function is called with %NULL @buffer 700 * and %NULL @data. 701 * 702 * Params: 703 * pads = the #GstCollectPads that triggered the callback 704 * data = the #GstCollectData of pad that has received the buffer 705 * buffer = the #GstBuffer 706 * userData = user data passed to gst_collect_pads_set_buffer_function() 707 * 708 * Returns: %GST_FLOW_OK for success 709 */ 710 public alias extern(C) GstFlowReturn function(GstCollectPads* pads, GstCollectData* data, GstBuffer* buffer, void* userData) GstCollectPadsBufferFunction; 711 712 /** 713 * A function that will be called when @inbuffer is received on the pad managed 714 * by @data in the collectpad object @pads. 715 * 716 * The function should use the segment of @data and the negotiated media type on 717 * the pad to perform clipping of @inbuffer. 718 * 719 * This function takes ownership of @inbuffer and should output a buffer in 720 * @outbuffer or return %NULL in @outbuffer if the buffer should be dropped. 721 * 722 * Params: 723 * pads = a #GstCollectPads 724 * data = a #GstCollectData 725 * inbuffer = the input #GstBuffer 726 * outbuffer = the output #GstBuffer 727 * userData = user data 728 * 729 * Returns: a #GstFlowReturn that corresponds to the result of clipping. 730 */ 731 public alias extern(C) GstFlowReturn function(GstCollectPads* pads, GstCollectData* data, GstBuffer* inbuffer, GstBuffer** outbuffer, void* userData) GstCollectPadsClipFunction; 732 733 /** 734 * A function for comparing two timestamps of buffers or newsegments collected on one pad. 735 * 736 * Params: 737 * pads = the #GstCollectPads that is comparing the timestamps 738 * data1 = the first #GstCollectData 739 * timestamp1 = the first timestamp 740 * data2 = the second #GstCollectData 741 * timestamp2 = the second timestamp 742 * userData = user data passed to gst_collect_pads_set_compare_function() 743 * 744 * Returns: Integer less than zero when first timestamp is deemed older than the second one. 745 * Zero if the timestamps are deemed equally old. 746 * Integer greater than zero when second timestamp is deemed older than the first one. 747 */ 748 public alias extern(C) int function(GstCollectPads* pads, GstCollectData* data1, GstClockTime timestamp1, GstCollectData* data2, GstClockTime timestamp2, void* userData) GstCollectPadsCompareFunction; 749 750 /** 751 * A function that will be called while processing an event. It takes 752 * ownership of the event and is responsible for chaining up (to 753 * gst_collect_pads_event_default()) or dropping events (such typical cases 754 * being handled by the default handler). 755 * 756 * Params: 757 * pads = the #GstCollectPads that triggered the callback 758 * pad = the #GstPad that received an event 759 * event = the #GstEvent received 760 * userData = user data passed to gst_collect_pads_set_event_function() 761 * 762 * Returns: %TRUE if the pad could handle the event 763 */ 764 public alias extern(C) int function(GstCollectPads* pads, GstCollectData* pad, GstEvent* event, void* userData) GstCollectPadsEventFunction; 765 766 /** 767 * A function that will be called while processing a flushing seek event. 768 * 769 * The function should flush any internal state of the element and the state of 770 * all the pads. It should clear only the state not directly managed by the 771 * @pads object. It is therefore not necessary to call 772 * gst_collect_pads_set_flushing nor gst_collect_pads_clear from this function. 773 * 774 * Params: 775 * pads = a #GstCollectPads 776 * userData = user data 777 * 778 * Since: 1.4 779 */ 780 public alias extern(C) void function(GstCollectPads* pads, void* userData) GstCollectPadsFlushFunction; 781 782 /** 783 * A function that will be called when all pads have received data. 784 * 785 * Params: 786 * pads = the #GstCollectPads that triggered the callback 787 * userData = user data passed to gst_collect_pads_set_function() 788 * 789 * Returns: %GST_FLOW_OK for success 790 */ 791 public alias extern(C) GstFlowReturn function(GstCollectPads* pads, void* userData) GstCollectPadsFunction; 792 793 /** 794 * A function that will be called while processing a query. It takes 795 * ownership of the query and is responsible for chaining up (to 796 * events downstream (with gst_pad_event_default()). 797 * 798 * Params: 799 * pads = the #GstCollectPads that triggered the callback 800 * pad = the #GstPad that received an event 801 * query = the #GstEvent received 802 * userData = user data passed to gst_collect_pads_set_query_function() 803 * 804 * Returns: %TRUE if the pad could handle the event 805 */ 806 public alias extern(C) int function(GstCollectPads* pads, GstCollectData* pad, GstQuery* query, void* userData) GstCollectPadsQueryFunction; 807 808 /** 809 * The prototype of the function used to inform the queue that it should be 810 * considered as full. 811 * 812 * Params: 813 * queue = a #GstDataQueue. 814 * visible = The number of visible items currently in the queue. 815 * bytes = The amount of bytes currently in the queue. 816 * time = The accumulated duration of the items currently in the queue. 817 * checkdata = The #gpointer registered when the #GstDataQueue was created. 818 * 819 * Returns: %TRUE if the queue should be considered full. 820 */ 821 public alias extern(C) int function(GstDataQueue* queue, uint visible, uint bytes, ulong time, void* checkdata) GstDataQueueCheckFullFunction; 822 823 /** */ 824 public alias extern(C) void function(GstDataQueue* queue, void* checkdata) GstDataQueueEmptyCallback; 825 826 /** */ 827 public alias extern(C) void function(GstDataQueue* queue, void* checkdata) GstDataQueueFullCallback; 828 829 /** 830 * This function will be called by gst_type_find_helper_get_range() when 831 * typefinding functions request to peek at the data of a stream at certain 832 * offsets. If this function returns GST_FLOW_OK, the result buffer will be 833 * stored in @buffer. The contents of @buffer is invalid for any other 834 * return value. 835 * 836 * This function is supposed to behave exactly like a #GstPadGetRangeFunction. 837 * 838 * Params: 839 * obj = a #GstObject that will handle the getrange request 840 * parent = the parent of @obj or %NULL 841 * offset = the offset of the range 842 * length = the length of the range 843 * buffer = a memory location to hold the result buffer 844 * 845 * Returns: GST_FLOW_OK for success 846 */ 847 public alias extern(C) GstFlowReturn function(GstObject* obj, GstObject* parent, ulong offset, uint length, GstBuffer** buffer) GstTypeFindHelperGetRangeFunction; 848 849 enum BASE_PARSE_FLAG_DRAINING = 2; 850 alias GST_BASE_PARSE_FLAG_DRAINING = BASE_PARSE_FLAG_DRAINING; 851 852 enum BASE_PARSE_FLAG_LOST_SYNC = 1; 853 alias GST_BASE_PARSE_FLAG_LOST_SYNC = BASE_PARSE_FLAG_LOST_SYNC; 854 855 /** 856 * The name of the templates for the sink pad. 857 */ 858 enum BASE_TRANSFORM_SINK_NAME = "sink"; 859 alias GST_BASE_TRANSFORM_SINK_NAME = BASE_TRANSFORM_SINK_NAME; 860 861 /** 862 * The name of the templates for the source pad. 863 */ 864 enum BASE_TRANSFORM_SRC_NAME = "src"; 865 alias GST_BASE_TRANSFORM_SRC_NAME = BASE_TRANSFORM_SRC_NAME;