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 gstreamerc.gstreamertypes; 26 27 public import gtkc.glibtypes; 28 public import gtkc.gobjecttypes; 29 30 enum GST_CLOCK_TIME_NONE = 18446744073709551615UL; 31 32 /** 33 * A datatype to hold the handle to an outstanding sync or async clock callback. 34 */ 35 public alias void* GstClockID; 36 37 /** 38 * A datatype to hold a time, measured in nanoseconds. 39 */ 40 public alias ulong GstClockTime; 41 42 /** 43 * A datatype to hold a time difference, measured in nanoseconds. 44 */ 45 public alias long GstClockTimeDiff; 46 47 public alias ulong GstElementFactoryListType; 48 49 /** 50 * Flags for allocators. 51 */ 52 public enum GstAllocatorFlags 53 { 54 /** 55 * The allocator has a custom alloc function. 56 */ 57 CUSTOM_ALLOC = 16, 58 /** 59 * first flag that can be used for custom purposes 60 */ 61 LAST = 1048576, 62 } 63 alias GstAllocatorFlags AllocatorFlags; 64 65 /** 66 * GstBinFlags are a set of flags specific to bins. Most are set/used 67 * internally. They can be checked using the GST_OBJECT_FLAG_IS_SET () macro, 68 * and (un)set using GST_OBJECT_FLAG_SET () and GST_OBJECT_FLAG_UNSET (). 69 */ 70 public enum GstBinFlags 71 { 72 /** 73 * don't resync a state change when elements are 74 * added or linked in the bin (Since 1.0.5) 75 */ 76 NO_RESYNC = 16384, 77 /** 78 * the last enum in the series of flags for bins. 79 * Derived classes can use this as first value in a list of flags. 80 */ 81 LAST = 524288, 82 } 83 alias GstBinFlags BinFlags; 84 85 /** 86 * A set of flags that can be provided to the gst_buffer_copy_into() 87 * function to specify which items should be copied. 88 */ 89 public enum GstBufferCopyFlags 90 { 91 /** 92 * copy nothing 93 */ 94 NONE = 0, 95 /** 96 * flag indicating that buffer flags should be copied 97 */ 98 FLAGS = 1, 99 /** 100 * flag indicating that buffer pts, dts, 101 * duration, offset and offset_end should be copied 102 */ 103 TIMESTAMPS = 2, 104 /** 105 * flag indicating that buffer meta should be 106 * copied 107 */ 108 META = 4, 109 /** 110 * flag indicating that buffer memory should be reffed 111 * and appended to already existing memory. Unless the memory is marked as 112 * NO_SHARE, no actual copy of the memory is made but it is simply reffed. 113 * Add @GST_BUFFER_COPY_DEEP to force a real copy. 114 */ 115 MEMORY = 8, 116 /** 117 * flag indicating that buffer memory should be 118 * merged 119 */ 120 MERGE = 16, 121 /** 122 * flag indicating that memory should always be 123 * copied instead of reffed (Since 1.2) 124 */ 125 DEEP = 32, 126 } 127 alias GstBufferCopyFlags BufferCopyFlags; 128 129 /** 130 * A set of buffer flags used to describe properties of a #GstBuffer. 131 */ 132 public enum GstBufferFlags 133 { 134 /** 135 * the buffer is live data and should be discarded in 136 * the PAUSED state. 137 */ 138 LIVE = 16, 139 /** 140 * the buffer contains data that should be dropped 141 * because it will be clipped against the segment 142 * boundaries or because it does not contain data 143 * that should be shown to the user. 144 */ 145 DECODE_ONLY = 32, 146 /** 147 * the buffer marks a data discontinuity in the stream. 148 * This typically occurs after a seek or a dropped buffer 149 * from a live or network source. 150 */ 151 DISCONT = 64, 152 /** 153 * the buffer timestamps might have a discontinuity 154 * and this buffer is a good point to resynchronize. 155 */ 156 RESYNC = 128, 157 /** 158 * the buffer data is corrupted. 159 */ 160 CORRUPTED = 256, 161 /** 162 * the buffer contains a media specific marker. for 163 * video this is typically the end of a frame boundary, for audio 164 * this is usually the start of a talkspurt. 165 */ 166 MARKER = 512, 167 /** 168 * the buffer contains header information that is 169 * needed to decode the following data. 170 */ 171 HEADER = 1024, 172 /** 173 * the buffer has been created to fill a gap in the 174 * stream and contains media neutral data (elements can 175 * switch to optimized code path that ignores the buffer 176 * content). 177 */ 178 GAP = 2048, 179 /** 180 * the buffer can be dropped without breaking the 181 * stream, for example to reduce bandwidth. 182 */ 183 DROPPABLE = 4096, 184 /** 185 * this unit cannot be decoded independently. 186 */ 187 DELTA_UNIT = 8192, 188 /** 189 * this flag is set when memory of the buffer 190 * is added/removed 191 */ 192 TAG_MEMORY = 16384, 193 /** 194 * Elements which write to disk or permanent 195 * storage should ensure the data is synced after 196 * writing the contents of this buffer. (Since 1.6) 197 */ 198 SYNC_AFTER = 32768, 199 /** 200 * additional media specific flags can be added starting from 201 * this flag. 202 */ 203 LAST = 1048576, 204 } 205 alias GstBufferFlags BufferFlags; 206 207 /** 208 * Additional flags to control the allocation of a buffer 209 */ 210 public enum GstBufferPoolAcquireFlags 211 { 212 /** 213 * no flags 214 */ 215 NONE = 0, 216 /** 217 * buffer is keyframe 218 */ 219 KEY_UNIT = 1, 220 /** 221 * when the bufferpool is empty, acquire_buffer 222 * will by default block until a buffer is released into the pool again. Setting 223 * this flag makes acquire_buffer return #GST_FLOW_EOS instead of blocking. 224 */ 225 DONTWAIT = 2, 226 /** 227 * buffer is discont 228 */ 229 DISCONT = 4, 230 /** 231 * last flag, subclasses can use private flags 232 * starting from this value. 233 */ 234 LAST = 65536, 235 } 236 alias GstBufferPoolAcquireFlags BufferPoolAcquireFlags; 237 238 /** 239 * The different types of buffering methods. 240 */ 241 public enum GstBufferingMode 242 { 243 /** 244 * a small amount of data is buffered 245 */ 246 STREAM = 0, 247 /** 248 * the stream is being downloaded 249 */ 250 DOWNLOAD = 1, 251 /** 252 * the stream is being downloaded in a ringbuffer 253 */ 254 TIMESHIFT = 2, 255 /** 256 * the stream is a live stream 257 */ 258 LIVE = 3, 259 } 260 alias GstBufferingMode BufferingMode; 261 262 /** 263 * The standard flags that a bus may have. 264 */ 265 public enum GstBusFlags 266 { 267 /** 268 * The bus is currently dropping all messages 269 */ 270 FLUSHING = 16, 271 /** 272 * offset to define more flags 273 */ 274 FLAG_LAST = 32, 275 } 276 alias GstBusFlags BusFlags; 277 278 /** 279 * The result values for a GstBusSyncHandler. 280 */ 281 public enum GstBusSyncReply 282 { 283 /** 284 * drop the message 285 */ 286 DROP = 0, 287 /** 288 * pass the message to the async queue 289 */ 290 PASS = 1, 291 /** 292 * pass message to async queue, continue if message is handled 293 */ 294 ASYNC = 2, 295 } 296 alias GstBusSyncReply BusSyncReply; 297 298 /** 299 * Extra flags for a caps. 300 */ 301 public enum GstCapsFlags 302 { 303 /** 304 * Caps has no specific content, but can contain 305 * anything. 306 */ 307 ANY = 16, 308 } 309 alias GstCapsFlags CapsFlags; 310 311 /** 312 * Modes of caps intersection 313 * 314 * @GST_CAPS_INTERSECT_ZIG_ZAG tries to preserve overall order of both caps 315 * by iterating on the caps' structures as the following matrix shows: 316 * |[ 317 * caps1 318 * +------------- 319 * | 1 2 4 7 320 * caps2 | 3 5 8 10 321 * | 6 9 11 12 322 * ]| 323 * Used when there is no explicit precedence of one caps over the other. e.g. 324 * tee's sink pad getcaps function, it will probe its src pad peers' for their 325 * caps and intersect them with this mode. 326 * 327 * @GST_CAPS_INTERSECT_FIRST is useful when an element wants to preserve 328 * another element's caps priority order when intersecting with its own caps. 329 * Example: If caps1 is [A, B, C] and caps2 is [E, B, D, A], the result 330 * would be [A, B], maintaining the first caps priority on the intersection. 331 */ 332 public enum GstCapsIntersectMode 333 { 334 /** 335 * Zig-zags over both caps. 336 */ 337 ZIG_ZAG = 0, 338 /** 339 * Keeps the first caps order. 340 */ 341 FIRST = 1, 342 } 343 alias GstCapsIntersectMode CapsIntersectMode; 344 345 /** 346 * The type of the clock entry 347 */ 348 public enum GstClockEntryType 349 { 350 /** 351 * a single shot timeout 352 */ 353 SINGLE = 0, 354 /** 355 * a periodic timeout request 356 */ 357 PERIODIC = 1, 358 } 359 alias GstClockEntryType ClockEntryType; 360 361 /** 362 * The capabilities of this clock 363 */ 364 public enum GstClockFlags 365 { 366 /** 367 * clock can do a single sync timeout request 368 */ 369 CAN_DO_SINGLE_SYNC = 16, 370 /** 371 * clock can do a single async timeout request 372 */ 373 CAN_DO_SINGLE_ASYNC = 32, 374 /** 375 * clock can do sync periodic timeout requests 376 */ 377 CAN_DO_PERIODIC_SYNC = 64, 378 /** 379 * clock can do async periodic timeout callbacks 380 */ 381 CAN_DO_PERIODIC_ASYNC = 128, 382 /** 383 * clock's resolution can be changed 384 */ 385 CAN_SET_RESOLUTION = 256, 386 /** 387 * clock can be slaved to a master clock 388 */ 389 CAN_SET_MASTER = 512, 390 /** 391 * clock needs to be synced before it can be used 392 * (Since 1.6) 393 */ 394 NEEDS_STARTUP_SYNC = 1024, 395 /** 396 * subclasses can add additional flags starting from this flag 397 */ 398 LAST = 4096, 399 } 400 alias GstClockFlags ClockFlags; 401 402 /** 403 * The return value of a clock operation. 404 */ 405 public enum GstClockReturn 406 { 407 /** 408 * The operation succeeded. 409 */ 410 OK = 0, 411 /** 412 * The operation was scheduled too late. 413 */ 414 EARLY = 1, 415 /** 416 * The clockID was unscheduled 417 */ 418 UNSCHEDULED = 2, 419 /** 420 * The ClockID is busy 421 */ 422 BUSY = 3, 423 /** 424 * A bad time was provided to a function. 425 */ 426 BADTIME = 4, 427 /** 428 * An error occurred 429 */ 430 ERROR = 5, 431 /** 432 * Operation is not supported 433 */ 434 UNSUPPORTED = 6, 435 /** 436 * The ClockID is done waiting 437 */ 438 DONE = 7, 439 } 440 alias GstClockReturn ClockReturn; 441 442 /** 443 * The different kind of clocks. 444 */ 445 public enum GstClockType 446 { 447 /** 448 * time since Epoch 449 */ 450 REALTIME = 0, 451 /** 452 * monotonic time since some unspecified starting 453 * point 454 */ 455 MONOTONIC = 1, 456 /** 457 * some other time source is used (Since 1.0.5) 458 */ 459 OTHER = 2, 460 } 461 alias GstClockType ClockType; 462 463 /** 464 * Core errors are errors inside the core GStreamer library. 465 */ 466 public enum GstCoreError 467 { 468 /** 469 * a general error which doesn't fit in any other 470 * category. Make sure you add a custom message to the error call. 471 */ 472 FAILED = 1, 473 /** 474 * do not use this except as a placeholder for 475 * deciding where to go while developing code. 476 */ 477 TOO_LAZY = 2, 478 /** 479 * use this when you do not want to implement 480 * this functionality yet. 481 */ 482 NOT_IMPLEMENTED = 3, 483 /** 484 * used for state change errors. 485 */ 486 STATE_CHANGE = 4, 487 /** 488 * used for pad-related errors. 489 */ 490 PAD = 5, 491 /** 492 * used for thread-related errors. 493 */ 494 THREAD = 6, 495 /** 496 * used for negotiation-related errors. 497 */ 498 NEGOTIATION = 7, 499 /** 500 * used for event-related errors. 501 */ 502 EVENT = 8, 503 /** 504 * used for seek-related errors. 505 */ 506 SEEK = 9, 507 /** 508 * used for caps-related errors. 509 */ 510 CAPS = 10, 511 /** 512 * used for negotiation-related errors. 513 */ 514 TAG = 11, 515 /** 516 * used if a plugin is missing. 517 */ 518 MISSING_PLUGIN = 12, 519 /** 520 * used for clock related errors. 521 */ 522 CLOCK = 13, 523 /** 524 * used if functionality has been disabled at 525 * compile time. 526 */ 527 DISABLED = 14, 528 /** 529 * the number of core error types. 530 */ 531 NUM_ERRORS = 15, 532 } 533 alias GstCoreError CoreError; 534 535 /** 536 * These are some terminal style flags you can use when creating your 537 * debugging categories to make them stand out in debugging output. 538 */ 539 public enum GstDebugColorFlags 540 { 541 /** 542 * Use black as foreground color. 543 */ 544 FG_BLACK = 0, 545 /** 546 * Use red as foreground color. 547 */ 548 FG_RED = 1, 549 /** 550 * Use green as foreground color. 551 */ 552 FG_GREEN = 2, 553 /** 554 * Use yellow as foreground color. 555 */ 556 FG_YELLOW = 3, 557 /** 558 * Use blue as foreground color. 559 */ 560 FG_BLUE = 4, 561 /** 562 * Use magenta as foreground color. 563 */ 564 FG_MAGENTA = 5, 565 /** 566 * Use cyan as foreground color. 567 */ 568 FG_CYAN = 6, 569 /** 570 * Use white as foreground color. 571 */ 572 FG_WHITE = 7, 573 /** 574 * Use black as background color. 575 */ 576 BG_BLACK = 0, 577 /** 578 * Use red as background color. 579 */ 580 BG_RED = 16, 581 /** 582 * Use green as background color. 583 */ 584 BG_GREEN = 32, 585 /** 586 * Use yellow as background color. 587 */ 588 BG_YELLOW = 48, 589 /** 590 * Use blue as background color. 591 */ 592 BG_BLUE = 64, 593 /** 594 * Use magenta as background color. 595 */ 596 BG_MAGENTA = 80, 597 /** 598 * Use cyan as background color. 599 */ 600 BG_CYAN = 96, 601 /** 602 * Use white as background color. 603 */ 604 BG_WHITE = 112, 605 /** 606 * Make the output bold. 607 */ 608 BOLD = 256, 609 /** 610 * Underline the output. 611 */ 612 UNDERLINE = 512, 613 } 614 alias GstDebugColorFlags DebugColorFlags; 615 616 public enum GstDebugColorMode 617 { 618 /** 619 * Do not use colors in logs. 620 */ 621 OFF = 0, 622 /** 623 * Paint logs in a platform-specific way. 624 */ 625 ON = 1, 626 /** 627 * Paint logs with UNIX terminal color codes 628 * no matter what platform GStreamer is running on. 629 */ 630 UNIX = 2, 631 } 632 alias GstDebugColorMode DebugColorMode; 633 634 /** 635 * Available details for pipeline graphs produced by GST_DEBUG_BIN_TO_DOT_FILE() 636 * and GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS(). 637 */ 638 public enum GstDebugGraphDetails 639 { 640 /** 641 * show caps-name on edges 642 */ 643 MEDIA_TYPE = 1, 644 /** 645 * show caps-details on edges 646 */ 647 CAPS_DETAILS = 2, 648 /** 649 * show modified parameters on 650 * elements 651 */ 652 NON_DEFAULT_PARAMS = 4, 653 /** 654 * show element states 655 */ 656 STATES = 8, 657 /** 658 * show full element parameter values even 659 * if they are very long 660 */ 661 FULL_PARAMS = 16, 662 /** 663 * show all the typical details that one might want 664 */ 665 ALL = 15, 666 /** 667 * show all details regardless of how large or 668 * verbose they make the resulting output 669 */ 670 VERBOSE = -1, 671 } 672 alias GstDebugGraphDetails DebugGraphDetails; 673 674 /** 675 * The level defines the importance of a debugging message. The more important a 676 * message is, the greater the probability that the debugging system outputs it. 677 */ 678 public enum GstDebugLevel 679 { 680 /** 681 * No debugging level specified or desired. Used to deactivate 682 * debugging output. 683 */ 684 NONE = 0, 685 /** 686 * Error messages are to be used only when an error occurred 687 * that stops the application from keeping working correctly. 688 * An examples is gst_element_error, which outputs a message with this priority. 689 * It does not mean that the application is terminating as with g_error. 690 */ 691 ERROR = 1, 692 /** 693 * Warning messages are to inform about abnormal behaviour 694 * that could lead to problems or weird behaviour later on. An example of this 695 * would be clocking issues ("your computer is pretty slow") or broken input 696 * data ("Can't synchronize to stream.") 697 */ 698 WARNING = 2, 699 /** 700 * Fixme messages are messages that indicate that something 701 * in the executed code path is not fully implemented or handled yet. Note 702 * that this does not replace proper error handling in any way, the purpose 703 * of this message is to make it easier to spot incomplete/unfinished pieces 704 * of code when reading the debug log. 705 */ 706 FIXME = 3, 707 /** 708 * Informational messages should be used to keep the developer 709 * updated about what is happening. 710 * Examples where this should be used are when a typefind function has 711 * successfully determined the type of the stream or when an mp3 plugin detects 712 * the format to be used. ("This file has mono sound.") 713 */ 714 INFO = 4, 715 /** 716 * Debugging messages should be used when something common 717 * happens that is not the expected default behavior, or something that's 718 * useful to know but doesn't happen all the time (ie. per loop iteration or 719 * buffer processed or event handled). 720 * An example would be notifications about state changes or receiving/sending 721 * of events. 722 */ 723 DEBUG = 5, 724 /** 725 * Log messages are messages that are very common but might be 726 * useful to know. As a rule of thumb a pipeline that is running as expected 727 * should never output anything else but LOG messages whilst processing data. 728 * Use this log level to log recurring information in chain functions and 729 * loop functions, for example. 730 */ 731 LOG = 6, 732 /** 733 * Tracing-related messages. 734 * Examples for this are referencing/dereferencing of objects. 735 */ 736 TRACE = 7, 737 /** 738 * memory dump messages are used to log (small) chunks of 739 * data as memory dumps in the log. They will be displayed as hexdump with 740 * ASCII characters. 741 */ 742 MEMDUMP = 9, 743 /** 744 * The number of defined debugging levels. 745 */ 746 COUNT = 10, 747 } 748 alias GstDebugLevel DebugLevel; 749 750 /** 751 * The standard flags that an element may have. 752 */ 753 public enum GstElementFlags 754 { 755 /** 756 * ignore state changes from parent 757 */ 758 LOCKED_STATE = 16, 759 /** 760 * the element is a sink 761 */ 762 SINK = 32, 763 /** 764 * the element is a source. 765 */ 766 SOURCE = 64, 767 /** 768 * the element can provide a clock 769 */ 770 PROVIDE_CLOCK = 128, 771 /** 772 * the element requires a clock 773 */ 774 REQUIRE_CLOCK = 256, 775 /** 776 * the element can use an index 777 */ 778 INDEXABLE = 512, 779 /** 780 * offset to define more flags 781 */ 782 LAST = 16384, 783 } 784 alias GstElementFlags ElementFlags; 785 786 /** 787 * #GstEventType lists the standard event types that can be sent in a pipeline. 788 * 789 * The custom event types can be used for private messages between elements 790 * that can't be expressed using normal 791 * GStreamer buffer passing semantics. Custom events carry an arbitrary 792 * #GstStructure. 793 * Specific custom events are distinguished by the name of the structure. 794 */ 795 public enum GstEventType 796 { 797 /** 798 * unknown event. 799 */ 800 UNKNOWN = 0, 801 /** 802 * Start a flush operation. This event clears all data 803 * from the pipeline and unblock all streaming threads. 804 */ 805 FLUSH_START = 2563, 806 /** 807 * Stop a flush operation. This event resets the 808 * running-time of the pipeline. 809 */ 810 FLUSH_STOP = 5127, 811 /** 812 * Event to mark the start of a new stream. Sent before any 813 * other serialized event and only sent at the start of a new stream, 814 * not after flushing seeks. 815 */ 816 STREAM_START = 10254, 817 /** 818 * #GstCaps event. Notify the pad of a new media type. 819 */ 820 CAPS = 12814, 821 /** 822 * A new media segment follows in the dataflow. The 823 * segment events contains information for clipping buffers and 824 * converting buffer timestamps to running-time and 825 * stream-time. 826 */ 827 SEGMENT = 17934, 828 /** 829 * A new set of metadata tags has been found in the stream. 830 */ 831 TAG = 20510, 832 /** 833 * Notification of buffering requirements. Currently not 834 * used yet. 835 */ 836 BUFFERSIZE = 23054, 837 /** 838 * An event that sinks turn into a message. Used to 839 * send messages that should be emitted in sync with 840 * rendering. 841 */ 842 SINK_MESSAGE = 25630, 843 /** 844 * End-Of-Stream. No more data is to be expected to follow 845 * without a SEGMENT event. 846 */ 847 EOS = 28174, 848 /** 849 * An event which indicates that a new table of contents (TOC) 850 * was found or updated. 851 */ 852 TOC = 30750, 853 /** 854 * An event which indicates that new or updated 855 * encryption information has been found in the stream. 856 */ 857 PROTECTION = 33310, 858 /** 859 * Marks the end of a segment playback. 860 */ 861 SEGMENT_DONE = 38406, 862 /** 863 * Marks a gap in the datastream. 864 */ 865 GAP = 40966, 866 /** 867 * A quality message. Used to indicate to upstream elements 868 * that the downstream elements should adjust their processing 869 * rate. 870 */ 871 QOS = 48641, 872 /** 873 * A request for a new playback position and rate. 874 */ 875 SEEK = 51201, 876 /** 877 * Navigation events are usually used for communicating 878 * user requests, such as mouse or keyboard movements, 879 * to upstream elements. 880 */ 881 NAVIGATION = 53761, 882 /** 883 * Notification of new latency adjustment. Sinks will use 884 * the latency information to adjust their synchronisation. 885 */ 886 LATENCY = 56321, 887 /** 888 * A request for stepping through the media. Sinks will usually 889 * execute the step operation. 890 */ 891 STEP = 58881, 892 /** 893 * A request for upstream renegotiating caps and reconfiguring. 894 */ 895 RECONFIGURE = 61441, 896 /** 897 * A request for a new playback position based on TOC 898 * entry's UID. 899 */ 900 TOC_SELECT = 64001, 901 /** 902 * Upstream custom event 903 */ 904 CUSTOM_UPSTREAM = 69121, 905 /** 906 * Downstream custom event that travels in the 907 * data flow. 908 */ 909 CUSTOM_DOWNSTREAM = 71686, 910 /** 911 * Custom out-of-band downstream event. 912 */ 913 CUSTOM_DOWNSTREAM_OOB = 74242, 914 /** 915 * Custom sticky downstream event. 916 */ 917 CUSTOM_DOWNSTREAM_STICKY = 76830, 918 /** 919 * Custom upstream or downstream event. 920 * In-band when travelling downstream. 921 */ 922 CUSTOM_BOTH = 79367, 923 /** 924 * Custom upstream or downstream out-of-band event. 925 */ 926 CUSTOM_BOTH_OOB = 81923, 927 } 928 alias GstEventType EventType; 929 930 /** 931 * #GstEventTypeFlags indicate the aspects of the different #GstEventType 932 * values. You can get the type flags of a #GstEventType with the 933 * gst_event_type_get_flags() function. 934 */ 935 public enum GstEventTypeFlags 936 { 937 /** 938 * Set if the event can travel upstream. 939 */ 940 UPSTREAM = 1, 941 /** 942 * Set if the event can travel downstream. 943 */ 944 DOWNSTREAM = 2, 945 /** 946 * Set if the event should be serialized with data 947 * flow. 948 */ 949 SERIALIZED = 4, 950 /** 951 * Set if the event is sticky on the pads. 952 */ 953 STICKY = 8, 954 /** 955 * Multiple sticky events can be on a pad, each 956 * identified by the event name. 957 */ 958 STICKY_MULTI = 16, 959 } 960 alias GstEventTypeFlags EventTypeFlags; 961 962 /** 963 * The result of passing data to a pad. 964 * 965 * Note that the custom return values should not be exposed outside of the 966 * element scope. 967 */ 968 public enum GstFlowReturn 969 { 970 /** 971 * Pre-defined custom success code. 972 */ 973 CUSTOM_SUCCESS_2 = 102, 974 /** 975 * Pre-defined custom success code (define your 976 * custom success code to this to avoid compiler 977 * warnings). 978 */ 979 CUSTOM_SUCCESS_1 = 101, 980 /** 981 * Elements can use values starting from 982 * this (and higher) to define custom success 983 * codes. 984 */ 985 CUSTOM_SUCCESS = 100, 986 /** 987 * Data passing was ok. 988 */ 989 OK = 0, 990 /** 991 * Pad is not linked. 992 */ 993 NOT_LINKED = -1, 994 /** 995 * Pad is flushing. 996 */ 997 FLUSHING = -2, 998 /** 999 * Pad is EOS. 1000 */ 1001 EOS = -3, 1002 /** 1003 * Pad is not negotiated. 1004 */ 1005 NOT_NEGOTIATED = -4, 1006 /** 1007 * Some (fatal) error occurred. Element generating 1008 * this error should post an error message with more 1009 * details. 1010 */ 1011 ERROR = -5, 1012 /** 1013 * This operation is not supported. 1014 */ 1015 NOT_SUPPORTED = -6, 1016 /** 1017 * Elements can use values starting from 1018 * this (and lower) to define custom error codes. 1019 */ 1020 CUSTOM_ERROR = -100, 1021 /** 1022 * Pre-defined custom error code (define your 1023 * custom error code to this to avoid compiler 1024 * warnings). 1025 */ 1026 CUSTOM_ERROR_1 = -101, 1027 /** 1028 * Pre-defined custom error code. 1029 */ 1030 CUSTOM_ERROR_2 = -102, 1031 } 1032 alias GstFlowReturn FlowReturn; 1033 1034 /** 1035 * Standard predefined formats 1036 */ 1037 public enum GstFormat 1038 { 1039 /** 1040 * undefined format 1041 */ 1042 UNDEFINED = 0, 1043 /** 1044 * the default format of the pad/element. This can be 1045 * samples for raw audio, frames/fields for raw video (some, but not all, 1046 * elements support this; use @GST_FORMAT_TIME if you don't have a good 1047 * reason to query for samples/frames) 1048 */ 1049 DEFAULT = 1, 1050 /** 1051 * bytes 1052 */ 1053 BYTES = 2, 1054 /** 1055 * time in nanoseconds 1056 */ 1057 TIME = 3, 1058 /** 1059 * buffers (few, if any, elements implement this as of 1060 * May 2009) 1061 */ 1062 BUFFERS = 4, 1063 /** 1064 * percentage of stream (few, if any, elements implement 1065 * this as of May 2009) 1066 */ 1067 PERCENT = 5, 1068 } 1069 alias GstFormat Format; 1070 1071 /** 1072 * The result of a #GstIteratorItemFunction. 1073 */ 1074 public enum GstIteratorItem 1075 { 1076 /** 1077 * Skip this item 1078 */ 1079 SKIP = 0, 1080 /** 1081 * Return item 1082 */ 1083 PASS = 1, 1084 /** 1085 * Stop after this item. 1086 */ 1087 END = 2, 1088 } 1089 alias GstIteratorItem IteratorItem; 1090 1091 /** 1092 * The result of gst_iterator_next(). 1093 */ 1094 public enum GstIteratorResult 1095 { 1096 /** 1097 * No more items in the iterator 1098 */ 1099 DONE = 0, 1100 /** 1101 * An item was retrieved 1102 */ 1103 OK = 1, 1104 /** 1105 * Datastructure changed while iterating 1106 */ 1107 RESYNC = 2, 1108 /** 1109 * An error happened 1110 */ 1111 ERROR = 3, 1112 } 1113 alias GstIteratorResult IteratorResult; 1114 1115 /** 1116 * Library errors are for errors from the library being used by elements 1117 * (initializing, finalizing, settings, ...) 1118 */ 1119 public enum GstLibraryError 1120 { 1121 /** 1122 * a general error which doesn't fit in any other 1123 * category. Make sure you add a custom message to the error call. 1124 */ 1125 FAILED = 1, 1126 /** 1127 * do not use this except as a placeholder for 1128 * deciding where to go while developing code. 1129 */ 1130 TOO_LAZY = 2, 1131 /** 1132 * used when the library could not be opened. 1133 */ 1134 INIT = 3, 1135 /** 1136 * used when the library could not be closed. 1137 */ 1138 SHUTDOWN = 4, 1139 /** 1140 * used when the library doesn't accept settings. 1141 */ 1142 SETTINGS = 5, 1143 /** 1144 * used when the library generated an encoding error. 1145 */ 1146 ENCODE = 6, 1147 /** 1148 * the number of library error types. 1149 */ 1150 NUM_ERRORS = 7, 1151 } 1152 alias GstLibraryError LibraryError; 1153 1154 /** 1155 * Flags used when locking miniobjects 1156 */ 1157 public enum GstLockFlags 1158 { 1159 /** 1160 * lock for read access 1161 */ 1162 READ = 1, 1163 /** 1164 * lock for write access 1165 */ 1166 WRITE = 2, 1167 /** 1168 * lock for exclusive access 1169 */ 1170 EXCLUSIVE = 4, 1171 /** 1172 * first flag that can be used for custom purposes 1173 */ 1174 LAST = 256, 1175 } 1176 alias GstLockFlags LockFlags; 1177 1178 /** 1179 * Flags used when mapping memory 1180 */ 1181 public enum GstMapFlags 1182 { 1183 /** 1184 * map for read access 1185 */ 1186 READ = 1, 1187 /** 1188 * map for write access 1189 */ 1190 WRITE = 2, 1191 /** 1192 * first flag that can be used for custom purposes 1193 */ 1194 FLAG_LAST = 65536, 1195 } 1196 alias GstMapFlags MapFlags; 1197 1198 /** 1199 * Flags for wrapped memory. 1200 */ 1201 public enum GstMemoryFlags 1202 { 1203 /** 1204 * memory is readonly. It is not allowed to map the 1205 * memory with #GST_MAP_WRITE. 1206 */ 1207 READONLY = 2, 1208 /** 1209 * memory must not be shared. Copies will have to be 1210 * made when this memory needs to be shared between buffers. 1211 */ 1212 NO_SHARE = 16, 1213 /** 1214 * the memory prefix is filled with 0 bytes 1215 */ 1216 ZERO_PREFIXED = 32, 1217 /** 1218 * the memory padding is filled with 0 bytes 1219 */ 1220 ZERO_PADDED = 64, 1221 /** 1222 * the memory is physically contiguous. (Since 2.2) 1223 */ 1224 PHYSICALLY_CONTIGUOUS = 128, 1225 /** 1226 * the memory can't be mapped via gst_memory_map() without any preconditions. (Since 1.2) 1227 */ 1228 NOT_MAPPABLE = 256, 1229 /** 1230 * first flag that can be used for custom purposes 1231 */ 1232 LAST = 1048576, 1233 } 1234 alias GstMemoryFlags MemoryFlags; 1235 1236 /** 1237 * The different message types that are available. 1238 */ 1239 public enum GstMessageType : uint 1240 { 1241 /** 1242 * an undefined message 1243 */ 1244 UNKNOWN = 0, 1245 /** 1246 * end-of-stream reached in a pipeline. The application will 1247 * only receive this message in the PLAYING state and every time it sets a 1248 * pipeline to PLAYING that is in the EOS state. The application can perform a 1249 * flushing seek in the pipeline, which will undo the EOS state again. 1250 */ 1251 EOS = 1, 1252 /** 1253 * an error occurred. When the application receives an error 1254 * message it should stop playback of the pipeline and not assume that more 1255 * data will be played. 1256 */ 1257 ERROR = 2, 1258 /** 1259 * a warning occurred. 1260 */ 1261 WARNING = 4, 1262 /** 1263 * an info message occurred 1264 */ 1265 INFO = 8, 1266 /** 1267 * a tag was found. 1268 */ 1269 TAG = 16, 1270 /** 1271 * the pipeline is buffering. When the application 1272 * receives a buffering message in the PLAYING state for a non-live pipeline it 1273 * must PAUSE the pipeline until the buffering completes, when the percentage 1274 * field in the message is 100%. For live pipelines, no action must be 1275 * performed and the buffering percentage can be used to inform the user about 1276 * the progress. 1277 */ 1278 BUFFERING = 32, 1279 /** 1280 * a state change happened 1281 */ 1282 STATE_CHANGED = 64, 1283 /** 1284 * an element changed state in a streaming thread. 1285 * This message is deprecated. 1286 */ 1287 STATE_DIRTY = 128, 1288 /** 1289 * a stepping operation finished. 1290 */ 1291 STEP_DONE = 256, 1292 /** 1293 * an element notifies its capability of providing 1294 * a clock. This message is used internally and 1295 * never forwarded to the application. 1296 */ 1297 CLOCK_PROVIDE = 512, 1298 /** 1299 * The current clock as selected by the pipeline became 1300 * unusable. The pipeline will select a new clock on 1301 * the next PLAYING state change. The application 1302 * should set the pipeline to PAUSED and back to 1303 * PLAYING when this message is received. 1304 */ 1305 CLOCK_LOST = 1024, 1306 /** 1307 * a new clock was selected in the pipeline. 1308 */ 1309 NEW_CLOCK = 2048, 1310 /** 1311 * the structure of the pipeline changed. This 1312 * message is used internally and never forwarded to the application. 1313 */ 1314 STRUCTURE_CHANGE = 4096, 1315 /** 1316 * status about a stream, emitted when it starts, 1317 * stops, errors, etc.. 1318 */ 1319 STREAM_STATUS = 8192, 1320 /** 1321 * message posted by the application, possibly 1322 * via an application-specific element. 1323 */ 1324 APPLICATION = 16384, 1325 /** 1326 * element-specific message, see the specific element's 1327 * documentation 1328 */ 1329 ELEMENT = 32768, 1330 /** 1331 * pipeline started playback of a segment. This 1332 * message is used internally and never forwarded to the application. 1333 */ 1334 SEGMENT_START = 65536, 1335 /** 1336 * pipeline completed playback of a segment. This 1337 * message is forwarded to the application after all elements that posted 1338 * @GST_MESSAGE_SEGMENT_START posted a GST_MESSAGE_SEGMENT_DONE message. 1339 */ 1340 SEGMENT_DONE = 131072, 1341 /** 1342 * The duration of a pipeline changed. The 1343 * application can get the new duration with a duration query. 1344 */ 1345 DURATION_CHANGED = 262144, 1346 /** 1347 * Posted by elements when their latency changes. The 1348 * application should recalculate and distribute a new latency. 1349 */ 1350 LATENCY = 524288, 1351 /** 1352 * Posted by elements when they start an ASYNC 1353 * #GstStateChange. This message is not forwarded to the application but is used 1354 * internally. 1355 */ 1356 ASYNC_START = 1048576, 1357 /** 1358 * Posted by elements when they complete an ASYNC 1359 * #GstStateChange. The application will only receive this message from the toplevel 1360 * pipeline. 1361 */ 1362 ASYNC_DONE = 2097152, 1363 /** 1364 * Posted by elements when they want the pipeline to 1365 * change state. This message is a suggestion to the application which can 1366 * decide to perform the state change on (part of) the pipeline. 1367 */ 1368 REQUEST_STATE = 4194304, 1369 /** 1370 * A stepping operation was started. 1371 */ 1372 STEP_START = 8388608, 1373 /** 1374 * A buffer was dropped or an element changed its processing 1375 * strategy for Quality of Service reasons. 1376 */ 1377 QOS = 16777216, 1378 /** 1379 * A progress message. 1380 */ 1381 PROGRESS = 33554432, 1382 /** 1383 * A new table of contents (TOC) was found or previously found TOC 1384 * was updated. 1385 */ 1386 TOC = 67108864, 1387 /** 1388 * Message to request resetting the pipeline's 1389 * running time from the pipeline. This is an internal message which 1390 * applications will likely never receive. 1391 */ 1392 RESET_TIME = 134217728, 1393 /** 1394 * Message indicating start of a new stream. Useful 1395 * e.g. when using playbin in gapless playback mode, to get notified when 1396 * the next title actually starts playing (which will be some time after 1397 * the URI for the next title has been set). 1398 */ 1399 STREAM_START = 268435456, 1400 /** 1401 * Message indicating that an element wants a specific context (Since 1.2) 1402 */ 1403 NEED_CONTEXT = 536870912, 1404 /** 1405 * Message indicating that an element created a context (Since 1.2) 1406 */ 1407 HAVE_CONTEXT = 1073741824, 1408 /** 1409 * Message is an extended message type (see below). 1410 * These extended message IDs can't be used directly with mask-based API 1411 * like gst_bus_poll() or gst_bus_timed_pop_filtered(), but you can still 1412 * filter for GST_MESSAGE_EXTENDED and then check the result for the 1413 * specific type. (Since 1.4) 1414 */ 1415 EXTENDED = 2147483648, 1416 /** 1417 * Message indicating a #GstDevice was added to 1418 * a #GstDeviceProvider (Since 1.4) 1419 */ 1420 DEVICE_ADDED = 2147483649, 1421 /** 1422 * Message indicating a #GstDevice was removed 1423 * from a #GstDeviceProvider (Since 1.4) 1424 */ 1425 DEVICE_REMOVED = 2147483650, 1426 /** 1427 * mask for all of the above messages. 1428 */ 1429 ANY = 4294967295, 1430 } 1431 alias GstMessageType MessageType; 1432 1433 /** 1434 * Extra metadata flags. 1435 */ 1436 public enum GstMetaFlags 1437 { 1438 /** 1439 * no flags 1440 */ 1441 NONE = 0, 1442 /** 1443 * metadata should not be modified 1444 */ 1445 READONLY = 1, 1446 /** 1447 * metadata is managed by a bufferpool 1448 */ 1449 POOLED = 2, 1450 /** 1451 * metadata should not be removed 1452 */ 1453 LOCKED = 4, 1454 /** 1455 * additional flags can be added starting from this flag. 1456 */ 1457 LAST = 65536, 1458 } 1459 alias GstMetaFlags MetaFlags; 1460 1461 /** 1462 * Flags for the mini object 1463 */ 1464 public enum GstMiniObjectFlags 1465 { 1466 /** 1467 * the object can be locked and unlocked with 1468 * gst_mini_object_lock() and gst_mini_object_unlock(). 1469 */ 1470 LOCKABLE = 1, 1471 /** 1472 * the object is permanently locked in 1473 * READONLY mode. Only read locks can be performed on the object. 1474 */ 1475 LOCK_READONLY = 2, 1476 /** 1477 * first flag that can be used by subclasses. 1478 */ 1479 LAST = 16, 1480 } 1481 alias GstMiniObjectFlags MiniObjectFlags; 1482 1483 /** 1484 * The standard flags that an gstobject may have. 1485 */ 1486 public enum GstObjectFlags 1487 { 1488 /** 1489 * subclasses can add additional flags starting from this flag 1490 */ 1491 LAST = 16, 1492 } 1493 alias GstObjectFlags ObjectFlags; 1494 1495 /** 1496 * The direction of a pad. 1497 */ 1498 public enum GstPadDirection 1499 { 1500 /** 1501 * direction is unknown. 1502 */ 1503 UNKNOWN = 0, 1504 /** 1505 * the pad is a source pad. 1506 */ 1507 SRC = 1, 1508 /** 1509 * the pad is a sink pad. 1510 */ 1511 SINK = 2, 1512 } 1513 alias GstPadDirection PadDirection; 1514 1515 /** 1516 * Pad state flags 1517 */ 1518 public enum GstPadFlags 1519 { 1520 /** 1521 * is dataflow on a pad blocked 1522 */ 1523 BLOCKED = 16, 1524 /** 1525 * is pad flushing 1526 */ 1527 FLUSHING = 32, 1528 /** 1529 * is pad in EOS state 1530 */ 1531 EOS = 64, 1532 /** 1533 * is pad currently blocking on a buffer or event 1534 */ 1535 BLOCKING = 128, 1536 /** 1537 * ensure that there is a parent object before calling 1538 * into the pad callbacks. 1539 */ 1540 NEED_PARENT = 256, 1541 /** 1542 * the pad should be reconfigured/renegotiated. 1543 * The flag has to be unset manually after 1544 * reconfiguration happened. 1545 */ 1546 NEED_RECONFIGURE = 512, 1547 /** 1548 * the pad has pending events 1549 */ 1550 PENDING_EVENTS = 1024, 1551 /** 1552 * the pad is using fixed caps. This means that 1553 * once the caps are set on the pad, the default caps query function 1554 * will only return those caps. 1555 */ 1556 FIXED_CAPS = 2048, 1557 /** 1558 * the default event and query handler will forward 1559 * all events and queries to the internally linked pads 1560 * instead of discarding them. 1561 */ 1562 PROXY_CAPS = 4096, 1563 /** 1564 * the default query handler will forward 1565 * allocation queries to the internally linked pads 1566 * instead of discarding them. 1567 */ 1568 PROXY_ALLOCATION = 8192, 1569 /** 1570 * the default query handler will forward 1571 * scheduling queries to the internally linked pads 1572 * instead of discarding them. 1573 */ 1574 PROXY_SCHEDULING = 16384, 1575 /** 1576 * the default accept-caps handler will check 1577 * it the caps intersect the query-caps result instead 1578 * of checking for a subset. This is interesting for 1579 * parsers that can accept incompletely specified caps. 1580 */ 1581 ACCEPT_INTERSECT = 32768, 1582 /** 1583 * the default accept-caps handler will use 1584 * the template pad caps instead of query caps to 1585 * compare with the accept caps. Use this in combination 1586 * with %GST_PAD_FLAG_ACCEPT_INTERSECT. (Since 1.6) 1587 */ 1588 ACCEPT_TEMPLATE = 65536, 1589 /** 1590 * offset to define more flags 1591 */ 1592 LAST = 1048576, 1593 } 1594 alias GstPadFlags PadFlags; 1595 1596 /** 1597 * The amount of checking to be done when linking pads. @GST_PAD_LINK_CHECK_CAPS 1598 * and @GST_PAD_LINK_CHECK_TEMPLATE_CAPS are mutually exclusive. If both are 1599 * specified, expensive but safe @GST_PAD_LINK_CHECK_CAPS are performed. 1600 * 1601 * <warning><para> 1602 * Only disable some of the checks if you are 100% certain you know the link 1603 * will not fail because of hierarchy/caps compatibility failures. If uncertain, 1604 * use the default checks (%GST_PAD_LINK_CHECK_DEFAULT) or the regular methods 1605 * for linking the pads. 1606 * </para></warning> 1607 */ 1608 public enum GstPadLinkCheck 1609 { 1610 /** 1611 * Don't check hierarchy or caps compatibility. 1612 */ 1613 NOTHING = 0, 1614 /** 1615 * Check the pads have same parents/grandparents. 1616 * Could be omitted if it is already known that the two elements that own the 1617 * pads are in the same bin. 1618 */ 1619 HIERARCHY = 1, 1620 /** 1621 * Check if the pads are compatible by using 1622 * their template caps. This is much faster than @GST_PAD_LINK_CHECK_CAPS, but 1623 * would be unsafe e.g. if one pad has %GST_CAPS_ANY. 1624 */ 1625 TEMPLATE_CAPS = 2, 1626 /** 1627 * Check if the pads are compatible by comparing the 1628 * caps returned by gst_pad_query_caps(). 1629 */ 1630 CAPS = 4, 1631 /** 1632 * The default checks done when linking 1633 * pads (i.e. the ones used by gst_pad_link()). 1634 */ 1635 DEFAULT = 5, 1636 } 1637 alias GstPadLinkCheck PadLinkCheck; 1638 1639 /** 1640 * Result values from gst_pad_link and friends. 1641 */ 1642 public enum GstPadLinkReturn 1643 { 1644 /** 1645 * link succeeded 1646 */ 1647 OK = 0, 1648 /** 1649 * pads have no common grandparent 1650 */ 1651 WRONG_HIERARCHY = -1, 1652 /** 1653 * pad was already linked 1654 */ 1655 WAS_LINKED = -2, 1656 /** 1657 * pads have wrong direction 1658 */ 1659 WRONG_DIRECTION = -3, 1660 /** 1661 * pads do not have common format 1662 */ 1663 NOFORMAT = -4, 1664 /** 1665 * pads cannot cooperate in scheduling 1666 */ 1667 NOSCHED = -5, 1668 /** 1669 * refused for some reason 1670 */ 1671 REFUSED = -6, 1672 } 1673 alias GstPadLinkReturn PadLinkReturn; 1674 1675 /** 1676 * The status of a GstPad. After activating a pad, which usually happens when the 1677 * parent element goes from READY to PAUSED, the GstPadMode defines if the 1678 * pad operates in push or pull mode. 1679 */ 1680 public enum GstPadMode 1681 { 1682 /** 1683 * Pad will not handle dataflow 1684 */ 1685 NONE = 0, 1686 /** 1687 * Pad handles dataflow in downstream push mode 1688 */ 1689 PUSH = 1, 1690 /** 1691 * Pad handles dataflow in upstream pull mode 1692 */ 1693 PULL = 2, 1694 } 1695 alias GstPadMode PadMode; 1696 1697 /** 1698 * Indicates when this pad will become available. 1699 */ 1700 public enum GstPadPresence 1701 { 1702 /** 1703 * the pad is always available 1704 */ 1705 ALWAYS = 0, 1706 /** 1707 * the pad will become available depending on the media stream 1708 */ 1709 SOMETIMES = 1, 1710 /** 1711 * the pad is only available on request with 1712 * gst_element_request_pad(). 1713 */ 1714 REQUEST = 2, 1715 } 1716 alias GstPadPresence PadPresence; 1717 1718 /** 1719 * Different return values for the #GstPadProbeCallback. 1720 */ 1721 public enum GstPadProbeReturn 1722 { 1723 /** 1724 * drop data in data probes. For push mode this means that 1725 * the data item is not sent downstream. For pull mode, it means that 1726 * the data item is not passed upstream. In both cases, no more probes 1727 * are called and #GST_FLOW_OK or %TRUE is returned to the caller. 1728 */ 1729 DROP = 0, 1730 /** 1731 * normal probe return value. This leaves the probe in 1732 * place, and defers decisions about dropping or passing data to other 1733 * probes, if any. If there are no other probes, the default behaviour 1734 * for the probe type applies (block for blocking probes, and pass for 1735 * non-blocking probes). 1736 */ 1737 OK = 1, 1738 /** 1739 * remove this probe. 1740 */ 1741 REMOVE = 2, 1742 /** 1743 * pass the data item in the block probe and block on the 1744 * next item. 1745 */ 1746 PASS = 3, 1747 /** 1748 * Data has been handled in the probe and will not be 1749 * forwarded further. For events and buffers this is the same behaviour as 1750 * @GST_PAD_PROBE_DROP (except that in this case you need to unref the buffer 1751 * or event yourself). For queries it will also return %TRUE to the caller. 1752 * The probe can also modify the #GstFlowReturn value by using the 1753 * #GST_PAD_PROBE_INFO_FLOW_RETURN() accessor. 1754 * Note that the resulting query must contain valid entries. 1755 * Since: 1.6 1756 */ 1757 HANDLED = 4, 1758 } 1759 alias GstPadProbeReturn PadProbeReturn; 1760 1761 /** 1762 * The different probing types that can occur. When either one of 1763 * @GST_PAD_PROBE_TYPE_IDLE or @GST_PAD_PROBE_TYPE_BLOCK is used, the probe will be a 1764 * blocking probe. 1765 */ 1766 public enum GstPadProbeType 1767 { 1768 /** 1769 * invalid probe type 1770 */ 1771 INVALID = 0, 1772 /** 1773 * probe idle pads and block 1774 */ 1775 IDLE = 1, 1776 /** 1777 * probe and block pads 1778 */ 1779 BLOCK = 2, 1780 /** 1781 * probe buffers 1782 */ 1783 BUFFER = 16, 1784 /** 1785 * probe buffer lists 1786 */ 1787 BUFFER_LIST = 32, 1788 /** 1789 * probe downstream events 1790 */ 1791 EVENT_DOWNSTREAM = 64, 1792 /** 1793 * probe upstream events 1794 */ 1795 EVENT_UPSTREAM = 128, 1796 /** 1797 * probe flush events. This probe has to be 1798 * explicitly enabled and is not included in the 1799 * @@GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM or 1800 * @@GST_PAD_PROBE_TYPE_EVENT_UPSTREAM probe types. 1801 */ 1802 EVENT_FLUSH = 256, 1803 /** 1804 * probe downstream queries 1805 */ 1806 QUERY_DOWNSTREAM = 512, 1807 /** 1808 * probe upstream queries 1809 */ 1810 QUERY_UPSTREAM = 1024, 1811 /** 1812 * probe push 1813 */ 1814 PUSH = 4096, 1815 /** 1816 * probe pull 1817 */ 1818 PULL = 8192, 1819 /** 1820 * probe and block at the next opportunity, at data flow or when idle 1821 */ 1822 BLOCKING = 3, 1823 /** 1824 * probe downstream data (buffers, buffer lists, and events) 1825 */ 1826 DATA_DOWNSTREAM = 112, 1827 /** 1828 * probe upstream data (events) 1829 */ 1830 DATA_UPSTREAM = 128, 1831 /** 1832 * probe upstream and downstream data (buffers, buffer lists, and events) 1833 */ 1834 DATA_BOTH = 240, 1835 /** 1836 * probe and block downstream data (buffers, buffer lists, and events) 1837 */ 1838 BLOCK_DOWNSTREAM = 114, 1839 /** 1840 * probe and block upstream data (events) 1841 */ 1842 BLOCK_UPSTREAM = 130, 1843 /** 1844 * probe upstream and downstream events 1845 */ 1846 EVENT_BOTH = 192, 1847 /** 1848 * probe upstream and downstream queries 1849 */ 1850 QUERY_BOTH = 1536, 1851 /** 1852 * probe upstream events and queries and downstream buffers, buffer lists, events and queries 1853 */ 1854 ALL_BOTH = 1776, 1855 /** 1856 * probe push and pull 1857 */ 1858 SCHEDULING = 12288, 1859 } 1860 alias GstPadProbeType PadProbeType; 1861 1862 /** 1863 * Flags for the padtemplate 1864 */ 1865 public enum GstPadTemplateFlags 1866 { 1867 /** 1868 * first flag that can be used by subclasses. 1869 */ 1870 LAST = 256, 1871 } 1872 alias GstPadTemplateFlags PadTemplateFlags; 1873 1874 /** 1875 * The different parsing errors that can occur. 1876 */ 1877 public enum GstParseError 1878 { 1879 /** 1880 * A syntax error occurred. 1881 */ 1882 SYNTAX = 0, 1883 /** 1884 * The description contained an unknown element 1885 */ 1886 NO_SUCH_ELEMENT = 1, 1887 /** 1888 * An element did not have a specified property 1889 */ 1890 NO_SUCH_PROPERTY = 2, 1891 /** 1892 * There was an error linking two pads. 1893 */ 1894 LINK = 3, 1895 /** 1896 * There was an error setting a property 1897 */ 1898 COULD_NOT_SET_PROPERTY = 4, 1899 /** 1900 * An empty bin was specified. 1901 */ 1902 EMPTY_BIN = 5, 1903 /** 1904 * An empty description was specified 1905 */ 1906 EMPTY = 6, 1907 } 1908 alias GstParseError ParseError; 1909 1910 /** 1911 * Parsing options. 1912 */ 1913 public enum GstParseFlags 1914 { 1915 /** 1916 * Do not use any special parsing options. 1917 */ 1918 NONE = 0, 1919 /** 1920 * Always return %NULL when an error occurs 1921 * (default behaviour is to return partially constructed bins or elements 1922 * in some cases) 1923 */ 1924 FATAL_ERRORS = 1, 1925 /** 1926 * If a bin only has a single element, 1927 * just return the element. 1928 */ 1929 NO_SINGLE_ELEMENT_BINS = 2, 1930 } 1931 alias GstParseFlags ParseFlags; 1932 1933 /** 1934 * Pipeline flags 1935 */ 1936 public enum GstPipelineFlags 1937 { 1938 /** 1939 * this pipeline works with a fixed clock 1940 */ 1941 FIXED_CLOCK = 524288, 1942 /** 1943 * offset to define more flags 1944 */ 1945 LAST = 8388608, 1946 } 1947 alias GstPipelineFlags PipelineFlags; 1948 1949 /** 1950 * Flags used in connection with gst_plugin_add_dependency(). 1951 */ 1952 public enum GstPluginDependencyFlags 1953 { 1954 /** 1955 * no special flags 1956 */ 1957 NONE = 0, 1958 /** 1959 * recurse into subdirectories 1960 */ 1961 RECURSE = 1, 1962 /** 1963 * use paths 1964 * argument only if none of the environment variables is set 1965 */ 1966 PATHS_ARE_DEFAULT_ONLY = 2, 1967 /** 1968 * interpret 1969 * filename argument as filter suffix and check all matching files in 1970 * the directory 1971 */ 1972 FILE_NAME_IS_SUFFIX = 4, 1973 } 1974 alias GstPluginDependencyFlags PluginDependencyFlags; 1975 1976 /** 1977 * The plugin loading errors 1978 */ 1979 public enum GstPluginError 1980 { 1981 /** 1982 * The plugin could not be loaded 1983 */ 1984 MODULE = 0, 1985 /** 1986 * The plugin has unresolved dependencies 1987 */ 1988 DEPENDENCIES = 1, 1989 /** 1990 * The plugin has already be loaded from a different file 1991 */ 1992 NAME_MISMATCH = 2, 1993 } 1994 alias GstPluginError PluginError; 1995 1996 /** 1997 * The plugin loading state 1998 */ 1999 public enum GstPluginFlags 2000 { 2001 /** 2002 * Temporarily loaded plugins 2003 */ 2004 CACHED = 16, 2005 /** 2006 * The plugin won't be scanned (again) 2007 */ 2008 BLACKLISTED = 32, 2009 } 2010 alias GstPluginFlags PluginFlags; 2011 2012 /** 2013 * The type of a %GST_MESSAGE_PROGRESS. The progress messages inform the 2014 * application of the status of asynchronous tasks. 2015 */ 2016 public enum GstProgressType 2017 { 2018 /** 2019 * A new task started. 2020 */ 2021 START = 0, 2022 /** 2023 * A task completed and a new one continues. 2024 */ 2025 CONTINUE = 1, 2026 /** 2027 * A task completed. 2028 */ 2029 COMPLETE = 2, 2030 /** 2031 * A task was canceled. 2032 */ 2033 CANCELED = 3, 2034 /** 2035 * A task caused an error. An error message is also 2036 * posted on the bus. 2037 */ 2038 ERROR = 4, 2039 } 2040 alias GstProgressType ProgressType; 2041 2042 /** 2043 * The different types of QoS events that can be given to the 2044 * gst_event_new_qos() method. 2045 */ 2046 public enum GstQOSType 2047 { 2048 /** 2049 * The QoS event type that is produced when upstream 2050 * elements are producing data too quickly and the element can't keep up 2051 * processing the data. Upstream should reduce their production rate. This 2052 * type is also used when buffers arrive early or in time. 2053 */ 2054 OVERFLOW = 0, 2055 /** 2056 * The QoS event type that is produced when upstream 2057 * elements are producing data too slowly and need to speed up their 2058 * production rate. 2059 */ 2060 UNDERFLOW = 1, 2061 /** 2062 * The QoS event type that is produced when the 2063 * application enabled throttling to limit the data rate. 2064 */ 2065 THROTTLE = 2, 2066 } 2067 alias GstQOSType QOSType; 2068 2069 /** 2070 * Standard predefined Query types 2071 */ 2072 public enum GstQueryType 2073 { 2074 /** 2075 * unknown query type 2076 */ 2077 UNKNOWN = 0, 2078 /** 2079 * current position in stream 2080 */ 2081 POSITION = 2563, 2082 /** 2083 * total duration of the stream 2084 */ 2085 DURATION = 5123, 2086 /** 2087 * latency of stream 2088 */ 2089 LATENCY = 7683, 2090 /** 2091 * current jitter of stream 2092 */ 2093 JITTER = 10243, 2094 /** 2095 * current rate of the stream 2096 */ 2097 RATE = 12803, 2098 /** 2099 * seeking capabilities 2100 */ 2101 SEEKING = 15363, 2102 /** 2103 * segment start/stop positions 2104 */ 2105 SEGMENT = 17923, 2106 /** 2107 * convert values between formats 2108 */ 2109 CONVERT = 20483, 2110 /** 2111 * query supported formats for convert 2112 */ 2113 FORMATS = 23043, 2114 /** 2115 * query available media for efficient seeking. 2116 */ 2117 BUFFERING = 28163, 2118 /** 2119 * a custom application or element defined query. 2120 */ 2121 CUSTOM = 30723, 2122 /** 2123 * query the URI of the source or sink. 2124 */ 2125 URI = 33283, 2126 /** 2127 * the buffer allocation properties 2128 */ 2129 ALLOCATION = 35846, 2130 /** 2131 * the scheduling properties 2132 */ 2133 SCHEDULING = 38401, 2134 /** 2135 * the accept caps query 2136 */ 2137 ACCEPT_CAPS = 40963, 2138 /** 2139 * the caps query 2140 */ 2141 CAPS = 43523, 2142 /** 2143 * wait till all serialized data is consumed downstream 2144 */ 2145 DRAIN = 46086, 2146 /** 2147 * query the pipeline-local context from 2148 * downstream or upstream (since 1.2) 2149 */ 2150 CONTEXT = 48643, 2151 } 2152 alias GstQueryType QueryType; 2153 2154 /** 2155 * #GstQueryTypeFlags indicate the aspects of the different #GstQueryType 2156 * values. You can get the type flags of a #GstQueryType with the 2157 * gst_query_type_get_flags() function. 2158 */ 2159 public enum GstQueryTypeFlags 2160 { 2161 /** 2162 * Set if the query can travel upstream. 2163 */ 2164 UPSTREAM = 1, 2165 /** 2166 * Set if the query can travel downstream. 2167 */ 2168 DOWNSTREAM = 2, 2169 /** 2170 * Set if the query should be serialized with data 2171 * flow. 2172 */ 2173 SERIALIZED = 4, 2174 } 2175 alias GstQueryTypeFlags QueryTypeFlags; 2176 2177 /** 2178 * Element priority ranks. Defines the order in which the autoplugger (or 2179 * similar rank-picking mechanisms, such as e.g. gst_element_make_from_uri()) 2180 * will choose this element over an alternative one with the same function. 2181 * 2182 * These constants serve as a rough guidance for defining the rank of a 2183 * #GstPluginFeature. Any value is valid, including values bigger than 2184 * @GST_RANK_PRIMARY. 2185 */ 2186 public enum GstRank 2187 { 2188 /** 2189 * will be chosen last or not at all 2190 */ 2191 NONE = 0, 2192 /** 2193 * unlikely to be chosen 2194 */ 2195 MARGINAL = 64, 2196 /** 2197 * likely to be chosen 2198 */ 2199 SECONDARY = 128, 2200 /** 2201 * will be chosen first 2202 */ 2203 PRIMARY = 256, 2204 } 2205 alias GstRank Rank; 2206 2207 /** 2208 * Resource errors are for any resource used by an element: 2209 * memory, files, network connections, process space, ... 2210 * They're typically used by source and sink elements. 2211 */ 2212 public enum GstResourceError 2213 { 2214 /** 2215 * a general error which doesn't fit in any other 2216 * category. Make sure you add a custom message to the error call. 2217 */ 2218 FAILED = 1, 2219 /** 2220 * do not use this except as a placeholder for 2221 * deciding where to go while developing code. 2222 */ 2223 TOO_LAZY = 2, 2224 /** 2225 * used when the resource could not be found. 2226 */ 2227 NOT_FOUND = 3, 2228 /** 2229 * used when resource is busy. 2230 */ 2231 BUSY = 4, 2232 /** 2233 * used when resource fails to open for reading. 2234 */ 2235 OPEN_READ = 5, 2236 /** 2237 * used when resource fails to open for writing. 2238 */ 2239 OPEN_WRITE = 6, 2240 /** 2241 * used when resource cannot be opened for 2242 * both reading and writing, or either (but unspecified which). 2243 */ 2244 OPEN_READ_WRITE = 7, 2245 /** 2246 * used when the resource can't be closed. 2247 */ 2248 CLOSE = 8, 2249 /** 2250 * used when the resource can't be read from. 2251 */ 2252 READ = 9, 2253 /** 2254 * used when the resource can't be written to. 2255 */ 2256 WRITE = 10, 2257 /** 2258 * used when a seek on the resource fails. 2259 */ 2260 SEEK = 11, 2261 /** 2262 * used when a synchronize on the resource fails. 2263 */ 2264 SYNC = 12, 2265 /** 2266 * used when settings can't be manipulated on. 2267 */ 2268 SETTINGS = 13, 2269 /** 2270 * used when the resource has no space left. 2271 */ 2272 NO_SPACE_LEFT = 14, 2273 /** 2274 * used when the resource can't be opened 2275 * due to missing authorization. 2276 * (Since 1.2.4) 2277 */ 2278 NOT_AUTHORIZED = 15, 2279 /** 2280 * the number of resource error types. 2281 */ 2282 NUM_ERRORS = 16, 2283 } 2284 alias GstResourceError ResourceError; 2285 2286 /** 2287 * The different scheduling flags. 2288 */ 2289 public enum GstSchedulingFlags 2290 { 2291 /** 2292 * if seeking is possible 2293 */ 2294 SEEKABLE = 1, 2295 /** 2296 * if sequential access is recommended 2297 */ 2298 SEQUENTIAL = 2, 2299 /** 2300 * if bandwidth is limited and buffering possible (since 1.2) 2301 */ 2302 BANDWIDTH_LIMITED = 4, 2303 } 2304 alias GstSchedulingFlags SchedulingFlags; 2305 2306 /** 2307 * The different search modes. 2308 */ 2309 public enum GstSearchMode 2310 { 2311 /** 2312 * Only search for exact matches. 2313 */ 2314 EXACT = 0, 2315 /** 2316 * Search for an exact match or the element just before. 2317 */ 2318 BEFORE = 1, 2319 /** 2320 * Search for an exact match or the element just after. 2321 */ 2322 AFTER = 2, 2323 } 2324 alias GstSearchMode SearchMode; 2325 2326 /** 2327 * Flags to be used with gst_element_seek() or gst_event_new_seek(). All flags 2328 * can be used together. 2329 * 2330 * A non flushing seek might take some time to perform as the currently 2331 * playing data in the pipeline will not be cleared. 2332 * 2333 * An accurate seek might be slower for formats that don't have any indexes 2334 * or timestamp markers in the stream. Specifying this flag might require a 2335 * complete scan of the file in those cases. 2336 * 2337 * When performing a segment seek: after the playback of the segment completes, 2338 * no EOS will be emitted by the element that performed the seek, but a 2339 * %GST_MESSAGE_SEGMENT_DONE message will be posted on the bus by the element. 2340 * When this message is posted, it is possible to send a new seek event to 2341 * continue playback. With this seek method it is possible to perform seamless 2342 * looping or simple linear editing. 2343 * 2344 * When doing fast forward (rate > 1.0) or fast reverse (rate < -1.0) trickmode 2345 * playback, the %GST_SEEK_FLAG_TRICKMODE flag can be used to instruct decoders 2346 * and demuxers to adjust the playback rate by skipping frames. This can improve 2347 * performance and decrease CPU usage because not all frames need to be decoded. 2348 * 2349 * Beyond that, the %GST_SEEK_FLAG_TRICKMODE_KEY_UNITS flag can be used to 2350 * request that decoders skip all frames except key units, and 2351 * %GST_SEEK_FLAG_TRICKMODE_NO_AUDIO flags can be used to request that audio 2352 * decoders do no decoding at all, and simple output silence. 2353 * 2354 * The %GST_SEEK_FLAG_SNAP_BEFORE flag can be used to snap to the previous 2355 * relevant location, and the %GST_SEEK_FLAG_SNAP_AFTER flag can be used to 2356 * select the next relevant location. If %GST_SEEK_FLAG_KEY_UNIT is specified, 2357 * the relevant location is a keyframe. If both flags are specified, the nearest 2358 * of these locations will be selected. If none are specified, the implementation is 2359 * free to select whichever it wants. 2360 * 2361 * The before and after here are in running time, so when playing backwards, 2362 * the next location refers to the one that will played in next, and not the 2363 * one that is located after in the actual source stream. 2364 * 2365 * Also see part-seeking.txt in the GStreamer design documentation for more 2366 * details on the meaning of these flags and the behaviour expected of 2367 * elements that handle them. 2368 */ 2369 public enum GstSeekFlags 2370 { 2371 /** 2372 * no flag 2373 */ 2374 NONE = 0, 2375 /** 2376 * flush pipeline 2377 */ 2378 FLUSH = 1, 2379 /** 2380 * accurate position is requested, this might 2381 * be considerably slower for some formats. 2382 */ 2383 ACCURATE = 2, 2384 /** 2385 * seek to the nearest keyframe. This might be 2386 * faster but less accurate. 2387 */ 2388 KEY_UNIT = 4, 2389 /** 2390 * perform a segment seek. 2391 */ 2392 SEGMENT = 8, 2393 /** 2394 * when doing fast forward or fast reverse playback, allow 2395 * elements to skip frames instead of generating all 2396 * frames. (Since 1.6) 2397 */ 2398 TRICKMODE = 16, 2399 /** 2400 * Deprecated backward compatibility flag, replaced 2401 * by %GST_SEEK_FLAG_TRICKMODE 2402 */ 2403 SKIP = 16, 2404 /** 2405 * go to a location before the requested position, 2406 * if %GST_SEEK_FLAG_KEY_UNIT this means the keyframe at or before 2407 * the requested position the one at or before the seek target. 2408 */ 2409 SNAP_BEFORE = 32, 2410 /** 2411 * go to a location after the requested position, 2412 * if %GST_SEEK_FLAG_KEY_UNIT this means the keyframe at of after the 2413 * requested position. 2414 */ 2415 SNAP_AFTER = 64, 2416 /** 2417 * go to a position near the requested position, 2418 * if %GST_SEEK_FLAG_KEY_UNIT this means the keyframe closest 2419 * to the requested position, if both keyframes are at an equal 2420 * distance, behaves like %GST_SEEK_FLAG_SNAP_BEFORE. 2421 */ 2422 SNAP_NEAREST = 96, 2423 /** 2424 * when doing fast forward or fast reverse 2425 * playback, request that elements only decode keyframes 2426 * and skip all other content, for formats that have 2427 * keyframes. (Since 1.6) 2428 */ 2429 TRICKMODE_KEY_UNITS = 128, 2430 /** 2431 * when doing fast forward or fast reverse 2432 * playback, request that audio decoder elements skip 2433 * decoding and output only gap events or silence. (Since 1.6) 2434 */ 2435 TRICKMODE_NO_AUDIO = 256, 2436 } 2437 alias GstSeekFlags SeekFlags; 2438 2439 /** 2440 * The different types of seek events. When constructing a seek event with 2441 * gst_event_new_seek() or when doing gst_segment_do_seek (). 2442 */ 2443 public enum GstSeekType 2444 { 2445 /** 2446 * no change in position is required 2447 */ 2448 NONE = 0, 2449 /** 2450 * absolute position is requested 2451 */ 2452 SET = 1, 2453 /** 2454 * relative position to duration is requested 2455 */ 2456 END = 2, 2457 } 2458 alias GstSeekType SeekType; 2459 2460 /** 2461 * Flags for the GstSegment structure. Currently mapped to the corresponding 2462 * values of the seek flags. 2463 */ 2464 public enum GstSegmentFlags 2465 { 2466 /** 2467 * no flags 2468 */ 2469 NONE = 0, 2470 /** 2471 * reset the pipeline running_time to the segment 2472 * running_time 2473 */ 2474 RESET = 1, 2475 /** 2476 * perform skip playback (Since 1.6) 2477 */ 2478 TRICKMODE = 16, 2479 /** 2480 * Deprecated backward compatibility flag, replaced 2481 * by @GST_SEGMENT_FLAG_TRICKMODE 2482 */ 2483 SKIP = 16, 2484 /** 2485 * send SEGMENT_DONE instead of EOS 2486 */ 2487 SEGMENT = 8, 2488 /** 2489 * Decode only keyframes, where 2490 * possible (Since 1.6) 2491 */ 2492 TRICKMODE_KEY_UNITS = 128, 2493 /** 2494 * Do not decode any audio, where 2495 * possible (Since 1.6) 2496 */ 2497 TRICKMODE_NO_AUDIO = 256, 2498 } 2499 alias GstSegmentFlags SegmentFlags; 2500 2501 /** 2502 * The possible states an element can be in. States can be changed using 2503 * gst_element_set_state() and checked using gst_element_get_state(). 2504 */ 2505 public enum GstState 2506 { 2507 /** 2508 * no pending state. 2509 */ 2510 VOID_PENDING = 0, 2511 /** 2512 * the NULL state or initial state of an element. 2513 */ 2514 NULL = 1, 2515 /** 2516 * the element is ready to go to PAUSED. 2517 */ 2518 READY = 2, 2519 /** 2520 * the element is PAUSED, it is ready to accept and 2521 * process data. Sink elements however only accept one 2522 * buffer and then block. 2523 */ 2524 PAUSED = 3, 2525 /** 2526 * the element is PLAYING, the #GstClock is running and 2527 * the data is flowing. 2528 */ 2529 PLAYING = 4, 2530 } 2531 alias GstState State; 2532 2533 /** 2534 * These are the different state changes an element goes through. 2535 * %GST_STATE_NULL ⇒ %GST_STATE_PLAYING is called an upwards state change 2536 * and %GST_STATE_PLAYING ⇒ %GST_STATE_NULL a downwards state change. 2537 */ 2538 public enum GstStateChange 2539 { 2540 /** 2541 * state change from NULL to READY. 2542 * <itemizedlist> 2543 * <listitem><para> 2544 * The element must check if the resources it needs are available. Device 2545 * sinks and -sources typically try to probe the device to constrain their 2546 * caps. 2547 * </para></listitem> 2548 * <listitem><para> 2549 * The element opens the device (in case feature need to be probed). 2550 * </para></listitem> 2551 * </itemizedlist> 2552 */ 2553 NULL_TO_READY = 10, 2554 /** 2555 * state change from READY to PAUSED. 2556 * <itemizedlist> 2557 * <listitem><para> 2558 * The element pads are activated in order to receive data in PAUSED. 2559 * Streaming threads are started. 2560 * </para></listitem> 2561 * <listitem><para> 2562 * Some elements might need to return %GST_STATE_CHANGE_ASYNC and complete 2563 * the state change when they have enough information. It is a requirement 2564 * for sinks to return %GST_STATE_CHANGE_ASYNC and complete the state change 2565 * when they receive the first buffer or %GST_EVENT_EOS (preroll). 2566 * Sinks also block the dataflow when in PAUSED. 2567 * </para></listitem> 2568 * <listitem><para> 2569 * A pipeline resets the running_time to 0. 2570 * </para></listitem> 2571 * <listitem><para> 2572 * Live sources return %GST_STATE_CHANGE_NO_PREROLL and don't generate data. 2573 * </para></listitem> 2574 * </itemizedlist> 2575 */ 2576 READY_TO_PAUSED = 19, 2577 /** 2578 * state change from PAUSED to PLAYING. 2579 * <itemizedlist> 2580 * <listitem><para> 2581 * Most elements ignore this state change. 2582 * </para></listitem> 2583 * <listitem><para> 2584 * The pipeline selects a #GstClock and distributes this to all the children 2585 * before setting them to PLAYING. This means that it is only allowed to 2586 * synchronize on the #GstClock in the PLAYING state. 2587 * </para></listitem> 2588 * <listitem><para> 2589 * The pipeline uses the #GstClock and the running_time to calculate the 2590 * base_time. The base_time is distributed to all children when performing 2591 * the state change. 2592 * </para></listitem> 2593 * <listitem><para> 2594 * Sink elements stop blocking on the preroll buffer or event and start 2595 * rendering the data. 2596 * </para></listitem> 2597 * <listitem><para> 2598 * Sinks can post %GST_MESSAGE_EOS in the PLAYING state. It is not allowed 2599 * to post %GST_MESSAGE_EOS when not in the PLAYING state. 2600 * </para></listitem> 2601 * <listitem><para> 2602 * While streaming in PAUSED or PLAYING elements can create and remove 2603 * sometimes pads. 2604 * </para></listitem> 2605 * <listitem><para> 2606 * Live sources start generating data and return %GST_STATE_CHANGE_SUCCESS. 2607 * </para></listitem> 2608 * </itemizedlist> 2609 */ 2610 PAUSED_TO_PLAYING = 28, 2611 /** 2612 * state change from PLAYING to PAUSED. 2613 * <itemizedlist> 2614 * <listitem><para> 2615 * Most elements ignore this state change. 2616 * </para></listitem> 2617 * <listitem><para> 2618 * The pipeline calculates the running_time based on the last selected 2619 * #GstClock and the base_time. It stores this information to continue 2620 * playback when going back to the PLAYING state. 2621 * </para></listitem> 2622 * <listitem><para> 2623 * Sinks unblock any #GstClock wait calls. 2624 * </para></listitem> 2625 * <listitem><para> 2626 * When a sink does not have a pending buffer to play, it returns 2627 * %GST_STATE_CHANGE_ASYNC from this state change and completes the state 2628 * change when it receives a new buffer or an %GST_EVENT_EOS. 2629 * </para></listitem> 2630 * <listitem><para> 2631 * Any queued %GST_MESSAGE_EOS items are removed since they will be reposted 2632 * when going back to the PLAYING state. The EOS messages are queued in 2633 * #GstBin containers. 2634 * </para></listitem> 2635 * <listitem><para> 2636 * Live sources stop generating data and return %GST_STATE_CHANGE_NO_PREROLL. 2637 * </para></listitem> 2638 * </itemizedlist> 2639 */ 2640 PLAYING_TO_PAUSED = 35, 2641 /** 2642 * state change from PAUSED to READY. 2643 * <itemizedlist> 2644 * <listitem><para> 2645 * Sinks unblock any waits in the preroll. 2646 * </para></listitem> 2647 * <listitem><para> 2648 * Elements unblock any waits on devices 2649 * </para></listitem> 2650 * <listitem><para> 2651 * Chain or get_range functions return %GST_FLOW_FLUSHING. 2652 * </para></listitem> 2653 * <listitem><para> 2654 * The element pads are deactivated so that streaming becomes impossible and 2655 * all streaming threads are stopped. 2656 * </para></listitem> 2657 * <listitem><para> 2658 * The sink forgets all negotiated formats 2659 * </para></listitem> 2660 * <listitem><para> 2661 * Elements remove all sometimes pads 2662 * </para></listitem> 2663 * </itemizedlist> 2664 */ 2665 PAUSED_TO_READY = 26, 2666 /** 2667 * state change from READY to NULL. 2668 * <itemizedlist> 2669 * <listitem><para> 2670 * Elements close devices 2671 * </para></listitem> 2672 * <listitem><para> 2673 * Elements reset any internal state. 2674 * </para></listitem> 2675 * </itemizedlist> 2676 */ 2677 READY_TO_NULL = 17, 2678 } 2679 alias GstStateChange StateChange; 2680 2681 /** 2682 * The possible return values from a state change function such as 2683 * gst_element_set_state(). Only @GST_STATE_CHANGE_FAILURE is a real failure. 2684 */ 2685 public enum GstStateChangeReturn 2686 { 2687 /** 2688 * the state change failed 2689 */ 2690 FAILURE = 0, 2691 /** 2692 * the state change succeeded 2693 */ 2694 SUCCESS = 1, 2695 /** 2696 * the state change will happen asynchronously 2697 */ 2698 ASYNC = 2, 2699 /** 2700 * the state change succeeded but the element 2701 * cannot produce data in %GST_STATE_PAUSED. 2702 * This typically happens with live sources. 2703 */ 2704 NO_PREROLL = 3, 2705 } 2706 alias GstStateChangeReturn StateChangeReturn; 2707 2708 /** 2709 * Stream errors are for anything related to the stream being processed: 2710 * format errors, media type errors, ... 2711 * They're typically used by decoders, demuxers, converters, ... 2712 */ 2713 public enum GstStreamError 2714 { 2715 /** 2716 * a general error which doesn't fit in any other 2717 * category. Make sure you add a custom message to the error call. 2718 */ 2719 FAILED = 1, 2720 /** 2721 * do not use this except as a placeholder for 2722 * deciding where to go while developing code. 2723 */ 2724 TOO_LAZY = 2, 2725 /** 2726 * use this when you do not want to implement 2727 * this functionality yet. 2728 */ 2729 NOT_IMPLEMENTED = 3, 2730 /** 2731 * used when the element doesn't know the 2732 * stream's type. 2733 */ 2734 TYPE_NOT_FOUND = 4, 2735 /** 2736 * used when the element doesn't handle this type 2737 * of stream. 2738 */ 2739 WRONG_TYPE = 5, 2740 /** 2741 * used when there's no codec to handle the 2742 * stream's type. 2743 */ 2744 CODEC_NOT_FOUND = 6, 2745 /** 2746 * used when decoding fails. 2747 */ 2748 DECODE = 7, 2749 /** 2750 * used when encoding fails. 2751 */ 2752 ENCODE = 8, 2753 /** 2754 * used when demuxing fails. 2755 */ 2756 DEMUX = 9, 2757 /** 2758 * used when muxing fails. 2759 */ 2760 MUX = 10, 2761 /** 2762 * used when the stream is of the wrong format 2763 * (for example, wrong caps). 2764 */ 2765 FORMAT = 11, 2766 /** 2767 * used when the stream is encrypted and can't be 2768 * decrypted because this is not supported by the element. 2769 */ 2770 DECRYPT = 12, 2771 /** 2772 * used when the stream is encrypted and 2773 * can't be decrypted because no suitable key is available. 2774 */ 2775 DECRYPT_NOKEY = 13, 2776 /** 2777 * the number of stream error types. 2778 */ 2779 NUM_ERRORS = 14, 2780 } 2781 alias GstStreamError StreamError; 2782 2783 public enum GstStreamFlags 2784 { 2785 /** 2786 * This stream has no special attributes 2787 */ 2788 NONE = 0, 2789 /** 2790 * This stream is a sparse stream (e.g. a subtitle 2791 * stream), data may flow only in irregular intervals with large gaps in 2792 * between. 2793 */ 2794 SPARSE = 1, 2795 /** 2796 * This stream should be selected by default. This 2797 * flag may be used by demuxers to signal that a stream should be selected 2798 * by default in a playback scenario. 2799 */ 2800 SELECT = 2, 2801 /** 2802 * This stream should not be selected by default. 2803 * This flag may be used by demuxers to signal that a stream should not 2804 * be selected by default in a playback scenario, but only if explicitly 2805 * selected by the user (e.g. an audio track for the hard of hearing or 2806 * a director's commentary track). 2807 */ 2808 UNSELECT = 4, 2809 } 2810 alias GstStreamFlags StreamFlags; 2811 2812 /** 2813 * The type of a %GST_MESSAGE_STREAM_STATUS. The stream status messages inform the 2814 * application of new streaming threads and their status. 2815 */ 2816 public enum GstStreamStatusType 2817 { 2818 /** 2819 * A new thread need to be created. 2820 */ 2821 CREATE = 0, 2822 /** 2823 * a thread entered its loop function 2824 */ 2825 ENTER = 1, 2826 /** 2827 * a thread left its loop function 2828 */ 2829 LEAVE = 2, 2830 /** 2831 * a thread is destroyed 2832 */ 2833 DESTROY = 3, 2834 /** 2835 * a thread is started 2836 */ 2837 START = 8, 2838 /** 2839 * a thread is paused 2840 */ 2841 PAUSE = 9, 2842 /** 2843 * a thread is stopped 2844 */ 2845 STOP = 10, 2846 } 2847 alias GstStreamStatusType StreamStatusType; 2848 2849 /** 2850 * The type of a %GST_MESSAGE_STRUCTURE_CHANGE. 2851 */ 2852 public enum GstStructureChangeType 2853 { 2854 /** 2855 * Pad linking is starting or done. 2856 */ 2857 LINK = 0, 2858 /** 2859 * Pad unlinking is starting or done. 2860 */ 2861 UNLINK = 1, 2862 } 2863 alias GstStructureChangeType StructureChangeType; 2864 2865 /** 2866 * Extra tag flags used when registering tags. 2867 */ 2868 public enum GstTagFlag 2869 { 2870 /** 2871 * undefined flag 2872 */ 2873 UNDEFINED = 0, 2874 /** 2875 * tag is meta data 2876 */ 2877 META = 1, 2878 /** 2879 * tag is encoded 2880 */ 2881 ENCODED = 2, 2882 /** 2883 * tag is decoded 2884 */ 2885 DECODED = 3, 2886 /** 2887 * number of tag flags 2888 */ 2889 COUNT = 4, 2890 } 2891 alias GstTagFlag TagFlag; 2892 2893 /** 2894 * The different tag merging modes are basically replace, overwrite and append, 2895 * but they can be seen from two directions. Given two taglists: (A) the tags 2896 * already in the element and (B) the ones that are supplied to the element ( 2897 * e.g. via gst_tag_setter_merge_tags() / gst_tag_setter_add_tags() or a 2898 * %GST_EVENT_TAG), how are these tags merged? 2899 * In the table below this is shown for the cases that a tag exists in the list 2900 * (A) or does not exists (!A) and combinations thereof. 2901 * 2902 * <table frame="all" colsep="1" rowsep="1"> 2903 * <title>merge mode</title> 2904 * <tgroup cols='5' align='left'> 2905 * <thead> 2906 * <row> 2907 * <entry>merge mode</entry> 2908 * <entry>A + B</entry> 2909 * <entry>A + !B</entry> 2910 * <entry>!A + B</entry> 2911 * <entry>!A + !B</entry> 2912 * </row> 2913 * </thead> 2914 * <tbody> 2915 * <row> 2916 * <entry>REPLACE_ALL</entry> 2917 * <entry>B</entry> 2918 * <entry>-</entry> 2919 * <entry>B</entry> 2920 * <entry>-</entry> 2921 * </row> 2922 * <row> 2923 * <entry>REPLACE</entry> 2924 * <entry>B</entry> 2925 * <entry>A</entry> 2926 * <entry>B</entry> 2927 * <entry>-</entry> 2928 * </row> 2929 * <row> 2930 * <entry>APPEND</entry> 2931 * <entry>A, B</entry> 2932 * <entry>A</entry> 2933 * <entry>B</entry> 2934 * <entry>-</entry> 2935 * </row> 2936 * <row> 2937 * <entry>PREPEND</entry> 2938 * <entry>B, A</entry> 2939 * <entry>A</entry> 2940 * <entry>B</entry> 2941 * <entry>-</entry> 2942 * </row> 2943 * <row> 2944 * <entry>KEEP</entry> 2945 * <entry>A</entry> 2946 * <entry>A</entry> 2947 * <entry>B</entry> 2948 * <entry>-</entry> 2949 * </row> 2950 * <row> 2951 * <entry>KEEP_ALL</entry> 2952 * <entry>A</entry> 2953 * <entry>A</entry> 2954 * <entry>-</entry> 2955 * <entry>-</entry> 2956 * </row> 2957 * </tbody> 2958 * </tgroup> 2959 * </table> 2960 */ 2961 public enum GstTagMergeMode 2962 { 2963 /** 2964 * undefined merge mode 2965 */ 2966 UNDEFINED = 0, 2967 /** 2968 * replace all tags (clear list and append) 2969 */ 2970 REPLACE_ALL = 1, 2971 /** 2972 * replace tags 2973 */ 2974 REPLACE = 2, 2975 /** 2976 * append tags 2977 */ 2978 APPEND = 3, 2979 /** 2980 * prepend tags 2981 */ 2982 PREPEND = 4, 2983 /** 2984 * keep existing tags 2985 */ 2986 KEEP = 5, 2987 /** 2988 * keep all existing tags 2989 */ 2990 KEEP_ALL = 6, 2991 /** 2992 * the number of merge modes 2993 */ 2994 COUNT = 7, 2995 } 2996 alias GstTagMergeMode TagMergeMode; 2997 2998 /** 2999 * GstTagScope specifies if a taglist applies to the complete 3000 * medium or only to one single stream. 3001 */ 3002 public enum GstTagScope 3003 { 3004 /** 3005 * tags specific to this single stream 3006 */ 3007 STREAM = 0, 3008 /** 3009 * global tags for the complete medium 3010 */ 3011 GLOBAL = 1, 3012 } 3013 alias GstTagScope TagScope; 3014 3015 /** 3016 * The different states a task can be in 3017 */ 3018 public enum GstTaskState 3019 { 3020 /** 3021 * the task is started and running 3022 */ 3023 STARTED = 0, 3024 /** 3025 * the task is stopped 3026 */ 3027 STOPPED = 1, 3028 /** 3029 * the task is paused 3030 */ 3031 PAUSED = 2, 3032 } 3033 alias GstTaskState TaskState; 3034 3035 /** 3036 * The different types of TOC entries (see #GstTocEntry). 3037 * 3038 * There are two types of TOC entries: alternatives or parts in a sequence. 3039 */ 3040 public enum GstTocEntryType 3041 { 3042 /** 3043 * entry is an angle (i.e. an alternative) 3044 */ 3045 ANGLE = -3, 3046 /** 3047 * entry is a version (i.e. alternative) 3048 */ 3049 VERSION = -2, 3050 /** 3051 * entry is an edition (i.e. alternative) 3052 */ 3053 EDITION = -1, 3054 /** 3055 * invalid entry type value 3056 */ 3057 INVALID = 0, 3058 /** 3059 * entry is a title (i.e. a part of a sequence) 3060 */ 3061 TITLE = 1, 3062 /** 3063 * entry is a track (i.e. a part of a sequence) 3064 */ 3065 TRACK = 2, 3066 /** 3067 * entry is a chapter (i.e. a part of a sequence) 3068 */ 3069 CHAPTER = 3, 3070 } 3071 alias GstTocEntryType TocEntryType; 3072 3073 /** 3074 * How a #GstTocEntry should be repeated. By default, entries are played a 3075 * single time. 3076 * 3077 * Since: 1.4 3078 */ 3079 public enum GstTocLoopType 3080 { 3081 /** 3082 * single forward playback 3083 */ 3084 NONE = 0, 3085 /** 3086 * repeat forward 3087 */ 3088 FORWARD = 1, 3089 /** 3090 * repeat backward 3091 */ 3092 REVERSE = 2, 3093 /** 3094 * repeat forward and backward 3095 */ 3096 PING_PONG = 3, 3097 } 3098 alias GstTocLoopType TocLoopType; 3099 3100 /** 3101 * The scope of a TOC. 3102 */ 3103 public enum GstTocScope 3104 { 3105 /** 3106 * global TOC representing all selectable options 3107 * (this is what applications are usually interested in) 3108 */ 3109 GLOBAL = 1, 3110 /** 3111 * TOC for the currently active/selected stream 3112 * (this is a TOC representing the current stream from start to EOS, 3113 * and is what a TOC writer / muxer is usually interested in; it will 3114 * usually be a subset of the global TOC, e.g. just the chapters of 3115 * the current title, or the chapters selected for playback from the 3116 * current title) 3117 */ 3118 CURRENT = 2, 3119 } 3120 alias GstTocScope TocScope; 3121 3122 /** 3123 * The probability of the typefind function. Higher values have more certainty 3124 * in doing a reliable typefind. 3125 */ 3126 public enum GstTypeFindProbability 3127 { 3128 /** 3129 * type undetected. 3130 */ 3131 NONE = 0, 3132 /** 3133 * unlikely typefind. 3134 */ 3135 MINIMUM = 1, 3136 /** 3137 * possible type detected. 3138 */ 3139 POSSIBLE = 50, 3140 /** 3141 * likely a type was detected. 3142 */ 3143 LIKELY = 80, 3144 /** 3145 * nearly certain that a type was detected. 3146 */ 3147 NEARLY_CERTAIN = 99, 3148 /** 3149 * very certain a type was detected. 3150 */ 3151 MAXIMUM = 100, 3152 } 3153 alias GstTypeFindProbability TypeFindProbability; 3154 3155 /** 3156 * Different URI-related errors that can occur. 3157 */ 3158 public enum GstURIError 3159 { 3160 /** 3161 * The protocol is not supported 3162 */ 3163 UNSUPPORTED_PROTOCOL = 0, 3164 /** 3165 * There was a problem with the URI 3166 */ 3167 BAD_URI = 1, 3168 /** 3169 * Could not set or change the URI because the 3170 * URI handler was in a state where that is not possible or not permitted 3171 */ 3172 BAD_STATE = 2, 3173 /** 3174 * There was a problem with the entity that 3175 * the URI references 3176 */ 3177 BAD_REFERENCE = 3, 3178 } 3179 alias GstURIError URIError; 3180 3181 /** 3182 * The different types of URI direction. 3183 */ 3184 public enum GstURIType 3185 { 3186 /** 3187 * The URI direction is unknown 3188 */ 3189 UNKNOWN = 0, 3190 /** 3191 * The URI is a consumer. 3192 */ 3193 SINK = 1, 3194 /** 3195 * The URI is a producer. 3196 */ 3197 SRC = 2, 3198 } 3199 alias GstURIType URIType; 3200 3201 struct GstAllocationParams 3202 { 3203 /** 3204 * flags to control allocation 3205 */ 3206 GstMemoryFlags flags; 3207 /** 3208 * the desired alignment of the memory 3209 */ 3210 size_t alig; 3211 /** 3212 * the desired prefix 3213 */ 3214 size_t prefix; 3215 /** 3216 * the desired padding 3217 */ 3218 size_t padding; 3219 void*[4] GstReserved; 3220 } 3221 3222 struct GstAllocator 3223 { 3224 GstObject object; 3225 const(char)* memType; 3226 /** 3227 * the implementation of the GstMemoryMapFunction 3228 */ 3229 GstMemoryMapFunction memMap; 3230 /** 3231 * the implementation of the GstMemoryUnmapFunction 3232 */ 3233 GstMemoryUnmapFunction memUnmap; 3234 /** 3235 * the implementation of the GstMemoryCopyFunction 3236 */ 3237 GstMemoryCopyFunction memCopy; 3238 /** 3239 * the implementation of the GstMemoryShareFunction 3240 */ 3241 GstMemoryShareFunction memShare; 3242 /** 3243 * the implementation of the GstMemoryIsSpanFunction 3244 */ 3245 GstMemoryIsSpanFunction memIsSpan; 3246 /** 3247 * the implementation of the GstMemoryMapFullFunction. 3248 * Will be used instead of @mem_map if present. (Since 1.6) 3249 */ 3250 GstMemoryMapFullFunction memMapFull; 3251 /** 3252 * the implementation of the GstMemoryUnmapFullFunction. 3253 * Will be used instead of @mem_unmap if present. (Since 1.6) 3254 */ 3255 GstMemoryUnmapFullFunction memUnmapFull; 3256 void*[2] GstReserved; 3257 GstAllocatorPrivate* priv; 3258 } 3259 3260 /** 3261 * The #GstAllocator is used to create new memory. 3262 */ 3263 struct GstAllocatorClass 3264 { 3265 /** 3266 * Object parent class 3267 */ 3268 GstObjectClass objectClass; 3269 /** 3270 * 3271 * Params: 3272 * allocator = a #GstAllocator to use 3273 * size = size of the visible memory area 3274 * params = optional parameters 3275 * Return: a new #GstMemory. 3276 */ 3277 extern(C) GstMemory* function(GstAllocator* allocator, size_t size, GstAllocationParams* params) alloc; 3278 extern(C) void function(GstAllocator* allocator, GstMemory* memory) free; 3279 void*[4] GstReserved; 3280 } 3281 3282 struct GstAllocatorPrivate; 3283 3284 struct GstAtomicQueue; 3285 3286 struct GstBin 3287 { 3288 GstElement element; 3289 /** 3290 * the number of children in this bin 3291 */ 3292 int numchildren; 3293 /** 3294 * the list of children in this bin 3295 */ 3296 GList* children; 3297 /** 3298 * updated whenever @children changes 3299 */ 3300 uint childrenCookie; 3301 /** 3302 * internal bus for handling child messages 3303 */ 3304 GstBus* childBus; 3305 /** 3306 * queued and cached messages 3307 */ 3308 GList* messages; 3309 /** 3310 * the bin is currently calculating its state 3311 */ 3312 bool polling; 3313 /** 3314 * the bin needs to recalculate its state (deprecated) 3315 */ 3316 bool stateDirty; 3317 /** 3318 * the bin needs to select a new clock 3319 */ 3320 bool clockDirty; 3321 /** 3322 * the last clock selected 3323 */ 3324 GstClock* providedClock; 3325 /** 3326 * the element that provided @provided_clock 3327 */ 3328 GstElement* clockProvider; 3329 GstBinPrivate* priv; 3330 void*[4] GstReserved; 3331 } 3332 3333 /** 3334 * Subclasses can override the @add_element and @remove_element to 3335 * update the list of children in the bin. 3336 * 3337 * The @handle_message method can be overridden to implement custom 3338 * message handling. @handle_message takes ownership of the message, just like 3339 * #gst_element_post_message. 3340 */ 3341 struct GstBinClass 3342 { 3343 /** 3344 * bin parent class 3345 */ 3346 GstElementClass parentClass; 3347 GThreadPool* pool; 3348 extern(C) void function(GstBin* bin, GstElement* child) elementAdded; 3349 extern(C) void function(GstBin* bin, GstElement* child) elementRemoved; 3350 extern(C) int function(GstBin* bin, GstElement* element) addElement; 3351 extern(C) int function(GstBin* bin, GstElement* element) removeElement; 3352 extern(C) void function(GstBin* bin, GstMessage* message) handleMessage; 3353 extern(C) int function(GstBin* bin) doLatency; 3354 void*[4] GstReserved; 3355 } 3356 3357 struct GstBinPrivate; 3358 3359 3360 struct GstBuffer 3361 { 3362 /** 3363 * the parent structure 3364 */ 3365 GstMiniObject miniObject; 3366 /** 3367 * pointer to the pool owner of the buffer 3368 */ 3369 GstBufferPool* pool; 3370 /** 3371 * presentation timestamp of the buffer, can be #GST_CLOCK_TIME_NONE when the 3372 * pts is not known or relevant. The pts contains the timestamp when the 3373 * media should be presented to the user. 3374 */ 3375 GstClockTime pts; 3376 /** 3377 * decoding timestamp of the buffer, can be #GST_CLOCK_TIME_NONE when the 3378 * dts is not known or relevant. The dts contains the timestamp when the 3379 * media should be processed. 3380 */ 3381 GstClockTime dts; 3382 /** 3383 * duration in time of the buffer data, can be #GST_CLOCK_TIME_NONE 3384 * when the duration is not known or relevant. 3385 */ 3386 GstClockTime duration; 3387 /** 3388 * a media specific offset for the buffer data. 3389 * For video frames, this is the frame number of this buffer. 3390 * For audio samples, this is the offset of the first sample in this buffer. 3391 * For file data or compressed data this is the byte offset of the first 3392 * byte in this buffer. 3393 */ 3394 ulong offset; 3395 /** 3396 * the last offset contained in this buffer. It has the same 3397 * format as @offset. 3398 */ 3399 ulong offsetEnd; 3400 } 3401 3402 struct GstBufferList; 3403 3404 struct GstBufferPool 3405 { 3406 GstObject object; 3407 int flushing; 3408 GstBufferPoolPrivate* priv; 3409 void*[4] GstReserved; 3410 } 3411 3412 /** 3413 * Parameters passed to the gst_buffer_pool_acquire_buffer() function to control the 3414 * allocation of the buffer. 3415 * 3416 * The default implementation ignores the @start and @stop members but other 3417 * implementations can use this extra information to decide what buffer to 3418 * return. 3419 */ 3420 struct GstBufferPoolAcquireParams 3421 { 3422 /** 3423 * the format of @start and @stop 3424 */ 3425 GstFormat format; 3426 /** 3427 * the start position 3428 */ 3429 long start; 3430 /** 3431 * the stop position 3432 */ 3433 long stop; 3434 /** 3435 * additional flags 3436 */ 3437 GstBufferPoolAcquireFlags flags; 3438 void*[4] GstReserved; 3439 } 3440 3441 /** 3442 * The GstBufferPool class. 3443 */ 3444 struct GstBufferPoolClass 3445 { 3446 /** 3447 * Object parent class 3448 */ 3449 GstObjectClass objectClass; 3450 /** 3451 * 3452 * Params: 3453 * pool = a #GstBufferPool 3454 * Return: a %NULL terminated array 3455 * of strings. 3456 */ 3457 extern(C) char** function(GstBufferPool* pool) getOptions; 3458 /** 3459 * 3460 * Params: 3461 * pool = a #GstBufferPool 3462 * config = a #GstStructure 3463 * Return: %TRUE when the configuration could be set. 3464 */ 3465 extern(C) int function(GstBufferPool* pool, GstStructure* config) setConfig; 3466 extern(C) int function(GstBufferPool* pool) start; 3467 extern(C) int function(GstBufferPool* pool) stop; 3468 /** 3469 * 3470 * Params: 3471 * pool = a #GstBufferPool 3472 * buffer = a location for a #GstBuffer 3473 * params = parameters. 3474 * Return: a #GstFlowReturn such as %GST_FLOW_FLUSHING when the pool is 3475 * inactive. 3476 */ 3477 extern(C) GstFlowReturn function(GstBufferPool* pool, GstBuffer** buffer, GstBufferPoolAcquireParams* params) acquireBuffer; 3478 extern(C) GstFlowReturn function(GstBufferPool* pool, GstBuffer** buffer, GstBufferPoolAcquireParams* params) allocBuffer; 3479 extern(C) void function(GstBufferPool* pool, GstBuffer* buffer) resetBuffer; 3480 extern(C) void function(GstBufferPool* pool, GstBuffer* buffer) releaseBuffer; 3481 extern(C) void function(GstBufferPool* pool, GstBuffer* buffer) freeBuffer; 3482 extern(C) void function(GstBufferPool* pool) flushStart; 3483 extern(C) void function(GstBufferPool* pool) flushStop; 3484 void*[2] GstReserved; 3485 } 3486 3487 struct GstBufferPoolPrivate; 3488 3489 struct GstBus 3490 { 3491 GstObject object; 3492 GstBusPrivate* priv; 3493 void*[4] GstReserved; 3494 } 3495 3496 struct GstBusClass 3497 { 3498 GstObjectClass parentClass; 3499 extern(C) void function(GstBus* bus, GstMessage* message) message; 3500 extern(C) void function(GstBus* bus, GstMessage* message) syncMessage; 3501 void*[4] GstReserved; 3502 } 3503 3504 struct GstBusPrivate; 3505 3506 struct GstCaps 3507 { 3508 /** 3509 * the parent type 3510 */ 3511 GstMiniObject miniObject; 3512 } 3513 3514 struct GstCapsFeatures; 3515 3516 struct GstChildProxy; 3517 3518 /** 3519 * #GstChildProxy interface. 3520 */ 3521 struct GstChildProxyInterface 3522 { 3523 /** 3524 * parent interface type. 3525 */ 3526 GTypeInterface parent; 3527 /** 3528 * 3529 * Params: 3530 * parent = the parent object to get the child from 3531 * name = the child's name 3532 * Return: the child object or %NULL if 3533 * not found. Unref after usage. 3534 * 3535 * MT safe. 3536 */ 3537 extern(C) GObject* function(GstChildProxy* parent, const(char)* name) getChildByName; 3538 /** 3539 * 3540 * Params: 3541 * parent = the parent object to get the child from 3542 * index = the child's position in the child list 3543 * Return: the child object or %NULL if 3544 * not found (index too high). Unref after usage. 3545 * 3546 * MT safe. 3547 */ 3548 extern(C) GObject* function(GstChildProxy* parent, uint index) getChildByIndex; 3549 /** 3550 * 3551 * Params: 3552 * parent = the parent object 3553 * Return: the number of child objects 3554 * 3555 * MT safe. 3556 */ 3557 extern(C) uint function(GstChildProxy* parent) getChildrenCount; 3558 extern(C) void function(GstChildProxy* parent, GObject* child, const(char)* name) childAdded; 3559 extern(C) void function(GstChildProxy* parent, GObject* child, const(char)* name) childRemoved; 3560 void*[4] GstReserved; 3561 } 3562 3563 struct GstClock 3564 { 3565 GstObject object; 3566 GstClockPrivate* priv; 3567 void*[4] GstReserved; 3568 } 3569 3570 /** 3571 * GStreamer clock class. Override the vmethods to implement the clock 3572 * functionality. 3573 */ 3574 struct GstClockClass 3575 { 3576 /** 3577 * the parent class structure 3578 */ 3579 GstObjectClass parentClass; 3580 extern(C) GstClockTime function(GstClock* clock, GstClockTime oldResolution, GstClockTime newResolution) changeResolution; 3581 /** 3582 * 3583 * Params: 3584 * clock = a #GstClock 3585 * Return: the resolution of the clock in units of #GstClockTime. 3586 * 3587 * MT safe. 3588 */ 3589 extern(C) GstClockTime function(GstClock* clock) getResolution; 3590 /** 3591 * 3592 * Params: 3593 * clock = a #GstClock to query 3594 * Return: the internal time of the clock. Or GST_CLOCK_TIME_NONE when 3595 * given invalid input. 3596 * 3597 * MT safe. 3598 */ 3599 extern(C) GstClockTime function(GstClock* clock) getInternalTime; 3600 extern(C) GstClockReturn function(GstClock* clock, GstClockEntry* entry, GstClockTimeDiff* jitter) wait; 3601 extern(C) GstClockReturn function(GstClock* clock, GstClockEntry* entry) waitAsync; 3602 extern(C) void function(GstClock* clock, GstClockEntry* entry) unschedule; 3603 void*[4] GstReserved; 3604 } 3605 3606 /** 3607 * All pending timeouts or periodic notifies are converted into 3608 * an entry. 3609 * Note that GstClockEntry should be treated as an opaque structure. It must 3610 * not be extended or allocated using a custom allocator. 3611 */ 3612 struct GstClockEntry 3613 { 3614 /** 3615 * reference counter (read-only) 3616 */ 3617 int refcount; 3618 GstClock* clock; 3619 GstClockEntryType type; 3620 GstClockTime time; 3621 GstClockTime interval; 3622 GstClockReturn status; 3623 GstClockCallback func; 3624 void* userData; 3625 GDestroyNotify destroyData; 3626 bool unscheduled; 3627 bool wokenUp; 3628 void*[4] GstReserved; 3629 } 3630 3631 struct GstClockPrivate; 3632 3633 struct GstContext; 3634 3635 struct GstControlBinding 3636 { 3637 GstObject parent; 3638 /** 3639 * name of the property of this binding 3640 */ 3641 char* name; 3642 /** 3643 * #GParamSpec for this property 3644 */ 3645 GParamSpec* pspec; 3646 GstObject* object; 3647 bool disabled; 3648 void*[4] GstReserved; 3649 } 3650 3651 /** 3652 * The class structure of #GstControlBinding. 3653 */ 3654 struct GstControlBindingClass 3655 { 3656 /** 3657 * Parent class 3658 */ 3659 GstObjectClass parentClass; 3660 /** 3661 * 3662 * Params: 3663 * binding = the control binding 3664 * object = the object that has controlled properties 3665 * timestamp = the time that should be processed 3666 * lastSync = the last time this was called 3667 * Return: %TRUE if the controller value could be applied to the object 3668 * property, %FALSE otherwise 3669 */ 3670 extern(C) int function(GstControlBinding* binding, GstObject* object, GstClockTime timestamp, GstClockTime lastSync) syncValues; 3671 /** 3672 * 3673 * Params: 3674 * binding = the control binding 3675 * timestamp = the time the control-change should be read from 3676 * Return: the GValue of the property at the given time, 3677 * or %NULL if the property isn't controlled. 3678 */ 3679 extern(C) GValue* function(GstControlBinding* binding, GstClockTime timestamp) getValue; 3680 /** 3681 * 3682 * Params: 3683 * binding = the control binding 3684 * timestamp = the time that should be processed 3685 * interval = the time spacing between subsequent values 3686 * nValues = the number of values 3687 * values = array to put control-values in 3688 * Return: %TRUE if the given array could be filled, %FALSE otherwise 3689 */ 3690 extern(C) int function(GstControlBinding* binding, GstClockTime timestamp, GstClockTime interval, uint nValues, void* values) getValueArray; 3691 /** 3692 * 3693 * Params: 3694 * binding = the control binding 3695 * timestamp = the time that should be processed 3696 * interval = the time spacing between subsequent values 3697 * nValues = the number of values 3698 * values = array to put control-values in 3699 * Return: %TRUE if the given array could be filled, %FALSE otherwise 3700 */ 3701 extern(C) int function(GstControlBinding* binding, GstClockTime timestamp, GstClockTime interval, uint nValues, GValue* values) getGValueArray; 3702 void*[4] GstReserved; 3703 } 3704 3705 struct GstControlSource 3706 { 3707 GstObject parent; 3708 /** 3709 * Function for returning a value for a given timestamp 3710 */ 3711 GstControlSourceGetValue getValue; 3712 /** 3713 * Function for returning a #GstValueArray for a given timestamp 3714 */ 3715 GstControlSourceGetValueArray getValueArray; 3716 void*[4] GstReserved; 3717 } 3718 3719 /** 3720 * The class structure of #GstControlSource. 3721 */ 3722 struct GstControlSourceClass 3723 { 3724 /** 3725 * Parent class 3726 */ 3727 GstObjectClass parentClass; 3728 void*[4] GstReserved; 3729 } 3730 3731 struct GstDateTime; 3732 3733 struct GstDebugCategory 3734 { 3735 int threshold; 3736 uint color; 3737 const(char)* name; 3738 const(char)* description; 3739 } 3740 3741 struct GstDebugMessage; 3742 3743 struct GstDevice 3744 { 3745 /** 3746 * The parent #GstObject strucuture. 3747 */ 3748 GstObject parent; 3749 GstDevicePrivate* priv; 3750 void*[4] GstReserved; 3751 } 3752 3753 /** 3754 * The class structure for a #GstDevice object. 3755 * 3756 * Since: 1.4 3757 */ 3758 struct GstDeviceClass 3759 { 3760 /** 3761 * The parent #GstObjectClass strucuture. 3762 */ 3763 GstObjectClass parentClass; 3764 /** 3765 * 3766 * Params: 3767 * device = a #GstDevice 3768 * name = name of new element, or %NULL to automatically 3769 * create a unique name. 3770 * Return: a new #GstElement configured to use this device 3771 */ 3772 extern(C) GstElement* function(GstDevice* device, const(char)* name) createElement; 3773 /** 3774 * 3775 * Params: 3776 * device = a #GstDevice 3777 * element = a #GstElement 3778 * Return: %TRUE if the element could be reconfigured to use this device, 3779 * %FALSE otherwise. 3780 */ 3781 extern(C) int function(GstDevice* device, GstElement* element) reconfigureElement; 3782 void*[4] GstReserved; 3783 } 3784 3785 struct GstDeviceMonitor 3786 { 3787 /** 3788 * the parent #GstObject structure 3789 */ 3790 GstObject parent; 3791 GstDeviceMonitorPrivate* priv; 3792 void*[4] GstReserved; 3793 } 3794 3795 /** 3796 * Opaque device monitor class structure. 3797 * 3798 * Since: 1.4 3799 */ 3800 struct GstDeviceMonitorClass 3801 { 3802 /** 3803 * the parent #GstObjectClass structure 3804 */ 3805 GstObjectClass parentClass; 3806 void*[4] GstReserved; 3807 } 3808 3809 struct GstDeviceMonitorPrivate; 3810 3811 struct GstDevicePrivate; 3812 3813 struct GstDeviceProvider 3814 { 3815 /** 3816 * The parent #GstObject 3817 */ 3818 GstObject parent; 3819 /** 3820 * a #GList of the #GstDevice objects 3821 */ 3822 GList* devices; 3823 GstDeviceProviderPrivate* priv; 3824 void*[4] GstReserved; 3825 } 3826 3827 struct GstDeviceProviderClass 3828 { 3829 /** 3830 * the parent #GstObjectClass structure 3831 */ 3832 GstObjectClass parentClass; 3833 /** 3834 * a pointer to the #GstDeviceProviderFactory that creates this 3835 * provider 3836 */ 3837 GstDeviceProviderFactory* factory; 3838 extern(C) GList* function(GstDeviceProvider* provider) probe; 3839 /** 3840 * 3841 * Params: 3842 * provider = A #GstDeviceProvider 3843 * Return: %TRUE if the device providering could be started 3844 */ 3845 extern(C) int function(GstDeviceProvider* provider) start; 3846 extern(C) void function(GstDeviceProvider* provider) stop; 3847 void* metadata; 3848 void*[4] GstReserved; 3849 } 3850 3851 struct GstDeviceProviderFactory; 3852 3853 /** 3854 * The opaque #GstDeviceProviderFactoryClass data structure. 3855 * 3856 * Since: 1.4 3857 */ 3858 struct GstDeviceProviderFactoryClass; 3859 3860 struct GstDeviceProviderPrivate; 3861 3862 3863 struct GstElement 3864 { 3865 GstObject object; 3866 /** 3867 * Used to serialize execution of gst_element_set_state() 3868 */ 3869 GRecMutex stateLock; 3870 /** 3871 * Used to signal completion of a state change 3872 */ 3873 GCond stateCond; 3874 /** 3875 * Used to detect concurrent execution of 3876 * gst_element_set_state() and gst_element_get_state() 3877 */ 3878 uint stateCookie; 3879 /** 3880 * the target state of an element as set by the application 3881 */ 3882 GstState targetState; 3883 /** 3884 * the current state of an element 3885 */ 3886 GstState currentState; 3887 /** 3888 * the next state of an element, can be #GST_STATE_VOID_PENDING if 3889 * the element is in the correct state. 3890 */ 3891 GstState nextState; 3892 /** 3893 * the final state the element should go to, can be 3894 * #GST_STATE_VOID_PENDING if the element is in the correct state 3895 */ 3896 GstState pendingState; 3897 /** 3898 * the last return value of an element state change 3899 */ 3900 GstStateChangeReturn lastReturn; 3901 /** 3902 * the bus of the element. This bus is provided to the element by the 3903 * parent element or the application. A #GstPipeline has a bus of its own. 3904 */ 3905 GstBus* bus; 3906 /** 3907 * the clock of the element. This clock is usually provided to the 3908 * element by the toplevel #GstPipeline. 3909 */ 3910 GstClock* clock; 3911 /** 3912 * the time of the clock right before the element is set to 3913 * PLAYING. Subtracting @base_time from the current clock time in the PLAYING 3914 * state will yield the running_time against the clock. 3915 */ 3916 GstClockTimeDiff baseTime; 3917 /** 3918 * the running_time of the last PAUSED state 3919 */ 3920 GstClockTime startTime; 3921 /** 3922 * number of pads of the element, includes both source and sink pads. 3923 */ 3924 ushort numpads; 3925 /** 3926 * list of pads 3927 */ 3928 GList* pads; 3929 /** 3930 * number of source pads of the element. 3931 */ 3932 ushort numsrcpads; 3933 /** 3934 * list of source pads 3935 */ 3936 GList* srcpads; 3937 /** 3938 * number of sink pads of the element. 3939 */ 3940 ushort numsinkpads; 3941 /** 3942 * list of sink pads 3943 */ 3944 GList* sinkpads; 3945 /** 3946 * updated whenever the a pad is added or removed 3947 */ 3948 uint padsCookie; 3949 void*[4] GstReserved; 3950 } 3951 3952 struct GstElementClass 3953 { 3954 /** 3955 * the parent class structure 3956 */ 3957 GstObjectClass parentClass; 3958 /** 3959 * metadata for elements of this class 3960 */ 3961 void* metadata; 3962 /** 3963 * the #GstElementFactory that creates these elements 3964 */ 3965 GstElementFactory* elementfactory; 3966 /** 3967 * a #GList of #GstPadTemplate 3968 */ 3969 GList* padtemplates; 3970 /** 3971 * the number of padtemplates 3972 */ 3973 int numpadtemplates; 3974 /** 3975 * changed whenever the padtemplates change 3976 */ 3977 uint padTemplCookie; 3978 extern(C) void function(GstElement* element, GstPad* pad) padAdded; 3979 extern(C) void function(GstElement* element, GstPad* pad) padRemoved; 3980 extern(C) void function(GstElement* element) noMorePads; 3981 /** 3982 * 3983 * Params: 3984 * element = a #GstElement to find a request pad of. 3985 * templ = a #GstPadTemplate of which we want a pad of. 3986 * name = the name of the request #GstPad 3987 * to retrieve. Can be %NULL. 3988 * caps = the caps of the pad we want to 3989 * request. Can be %NULL. 3990 * Return: requested #GstPad if found, 3991 * otherwise %NULL. Release after usage. 3992 */ 3993 extern(C) GstPad* function(GstElement* element, GstPadTemplate* templ, const(char)* name, GstCaps* caps) requestNewPad; 3994 extern(C) void function(GstElement* element, GstPad* pad) releasePad; 3995 /** 3996 * 3997 * Params: 3998 * element = a #GstElement to get the state of. 3999 * state = a pointer to #GstState to hold the state. 4000 * Can be %NULL. 4001 * pending = a pointer to #GstState to hold the pending 4002 * state. Can be %NULL. 4003 * timeout = a #GstClockTime to specify the timeout for an async 4004 * state change or %GST_CLOCK_TIME_NONE for infinite timeout. 4005 * Return: %GST_STATE_CHANGE_SUCCESS if the element has no more pending state 4006 * and the last state change succeeded, %GST_STATE_CHANGE_ASYNC if the 4007 * element is still performing a state change or 4008 * %GST_STATE_CHANGE_FAILURE if the last state change failed. 4009 * 4010 * MT safe. 4011 */ 4012 extern(C) GstStateChangeReturn function(GstElement* element, GstState* state, GstState* pending, GstClockTime timeout) getState; 4013 /** 4014 * 4015 * Params: 4016 * element = a #GstElement to change state of. 4017 * state = the element's new #GstState. 4018 * Return: Result of the state change using #GstStateChangeReturn. 4019 * 4020 * MT safe. 4021 */ 4022 extern(C) GstStateChangeReturn function(GstElement* element, GstState state) setState; 4023 /** 4024 * 4025 * Params: 4026 * element = a #GstElement 4027 * transition = the requested transition 4028 * Return: the #GstStateChangeReturn of the state transition. 4029 */ 4030 extern(C) GstStateChangeReturn function(GstElement* element, GstStateChange transition) changeState; 4031 extern(C) void function(GstElement* element, GstState oldstate, GstState newstate, GstState pending) stateChanged; 4032 extern(C) void function(GstElement* element, GstBus* bus) setBus; 4033 /** 4034 * 4035 * Params: 4036 * element = a #GstElement to query 4037 * Return: the GstClock provided by the 4038 * element or %NULL if no clock could be provided. Unref after usage. 4039 * 4040 * MT safe. 4041 */ 4042 extern(C) GstClock* function(GstElement* element) provideClock; 4043 /** 4044 * 4045 * Params: 4046 * element = a #GstElement to set the clock for. 4047 * clock = the #GstClock to set for the element. 4048 * Return: %TRUE if the element accepted the clock. An element can refuse a 4049 * clock when it, for example, is not able to slave its internal clock to the 4050 * @clock or when it requires a specific clock to operate. 4051 * 4052 * MT safe. 4053 */ 4054 extern(C) int function(GstElement* element, GstClock* clock) setClock; 4055 /** 4056 * 4057 * Params: 4058 * element = a #GstElement to send the event to. 4059 * event = the #GstEvent to send to the element. 4060 * Return: %TRUE if the event was handled. Events that trigger a preroll (such 4061 * as flushing seeks and steps) will emit %GST_MESSAGE_ASYNC_DONE. 4062 */ 4063 extern(C) int function(GstElement* element, GstEvent* event) sendEvent; 4064 /** 4065 * 4066 * Params: 4067 * element = a #GstElement to perform the query on. 4068 * query = the #GstQuery. 4069 * Return: %TRUE if the query could be performed. 4070 * 4071 * MT safe. 4072 */ 4073 extern(C) int function(GstElement* element, GstQuery* query) query; 4074 /** 4075 * 4076 * Params: 4077 * element = a #GstElement posting the message 4078 * message = a #GstMessage to post 4079 * Return: %TRUE if the message was successfully posted. The function returns 4080 * %FALSE if the element did not have a bus. 4081 * 4082 * MT safe. 4083 */ 4084 extern(C) int function(GstElement* element, GstMessage* message) postMessage; 4085 extern(C) void function(GstElement* element, GstContext* context) setContext; 4086 void*[18] GstReserved; 4087 } 4088 4089 struct GstElementFactory; 4090 4091 struct GstElementFactoryClass; 4092 4093 struct GstEvent 4094 { 4095 /** 4096 * the parent structure 4097 */ 4098 GstMiniObject miniObject; 4099 /** 4100 * the #GstEventType of the event 4101 */ 4102 GstEventType type; 4103 /** 4104 * the timestamp of the event 4105 */ 4106 ulong timestamp; 4107 /** 4108 * the sequence number of the event 4109 */ 4110 uint seqnum; 4111 } 4112 4113 4114 /** 4115 * A format definition 4116 */ 4117 struct GstFormatDefinition 4118 { 4119 /** 4120 * The unique id of this format 4121 */ 4122 GstFormat value; 4123 /** 4124 * A short nick of the format 4125 */ 4126 const(char)* nick; 4127 /** 4128 * A longer description of the format 4129 */ 4130 const(char)* description; 4131 /** 4132 * A quark for the nick 4133 */ 4134 GQuark quark; 4135 } 4136 4137 4138 4139 struct GstGhostPad 4140 { 4141 GstProxyPad pad; 4142 GstGhostPadPrivate* priv; 4143 } 4144 4145 struct GstGhostPadClass 4146 { 4147 GstProxyPadClass parentClass; 4148 void*[4] GstReserved; 4149 } 4150 4151 struct GstGhostPadPrivate; 4152 4153 4154 4155 struct GstIterator 4156 { 4157 /** 4158 * The function to copy the iterator 4159 */ 4160 GstIteratorCopyFunction copy; 4161 /** 4162 * The function to get the next item in the iterator 4163 */ 4164 GstIteratorNextFunction next; 4165 /** 4166 * The function to be called for each item retrieved 4167 */ 4168 GstIteratorItemFunction item; 4169 /** 4170 * The function to call when a resync is needed. 4171 */ 4172 GstIteratorResyncFunction resync; 4173 /** 4174 * The function to call when the iterator is freed 4175 */ 4176 GstIteratorFreeFunction free; 4177 /** 4178 * The iterator that is currently pushed with gst_iterator_push() 4179 */ 4180 GstIterator* pushed; 4181 /** 4182 * The type of the object that this iterator will return 4183 */ 4184 GType type; 4185 /** 4186 * The lock protecting the data structure and the cookie. 4187 */ 4188 GMutex* lock; 4189 /** 4190 * The cookie; the value of the master_cookie when this iterator was 4191 * created. 4192 */ 4193 uint cookie; 4194 /** 4195 * A pointer to the master cookie. 4196 */ 4197 uint* masterCookie; 4198 /** 4199 * the size of the iterator 4200 */ 4201 uint size; 4202 void*[4] GstReserved; 4203 } 4204 4205 /** 4206 * A structure containing the result of a map operation such as 4207 * gst_memory_map(). It contains the data and size. 4208 */ 4209 struct GstMapInfo 4210 { 4211 /** 4212 * a pointer to the mapped memory 4213 */ 4214 GstMemory* memory; 4215 /** 4216 * flags used when mapping the memory 4217 */ 4218 GstMapFlags flags; 4219 /** 4220 * a pointer to the mapped data 4221 */ 4222 ubyte* data; 4223 /** 4224 * the valid size in @data 4225 */ 4226 size_t size; 4227 /** 4228 * the maximum bytes in @data 4229 */ 4230 size_t maxsize; 4231 /** 4232 * extra private user_data that the implementation of the memory 4233 * can use to store extra info. 4234 */ 4235 void*[4] userData; 4236 void*[4] GstReserved; 4237 } 4238 4239 struct GstMemory 4240 { 4241 /** 4242 * parent structure 4243 */ 4244 GstMiniObject miniObject; 4245 /** 4246 * pointer to the #GstAllocator 4247 */ 4248 GstAllocator* allocator; 4249 /** 4250 * parent memory block 4251 */ 4252 GstMemory* parent; 4253 /** 4254 * the maximum size allocated 4255 */ 4256 size_t maxsize; 4257 /** 4258 * the alignment of the memory 4259 */ 4260 size_t alig; 4261 /** 4262 * the offset where valid data starts 4263 */ 4264 size_t offset; 4265 /** 4266 * the size of valid data 4267 */ 4268 size_t size; 4269 } 4270 4271 struct GstMessage 4272 { 4273 /** 4274 * the parent structure 4275 */ 4276 GstMiniObject miniObject; 4277 /** 4278 * the #GstMessageType of the message 4279 */ 4280 GstMessageType type; 4281 /** 4282 * the timestamp of the message 4283 */ 4284 ulong timestamp; 4285 /** 4286 * the src of the message 4287 */ 4288 GstObject* src; 4289 /** 4290 * the sequence number of the message 4291 */ 4292 uint seqnum; 4293 GMutex lock; 4294 GCond cond; 4295 } 4296 4297 /** 4298 * The #GstMeta structure should be included as the first member of a #GstBuffer 4299 * metadata structure. The structure defines the API of the metadata and should 4300 * be accessible to all elements using the metadata. 4301 * 4302 * A metadata API is registered with gst_meta_api_type_register() which takes a 4303 * name for the metadata API and some tags associated with the metadata. 4304 * With gst_meta_api_type_has_tag() one can check if a certain metadata API 4305 * contains a given tag. 4306 * 4307 * Multiple implementations of a metadata API can be registered. 4308 * To implement a metadata API, gst_meta_register() should be used. This 4309 * function takes all parameters needed to create, free and transform metadata 4310 * along with the size of the metadata. The function returns a #GstMetaInfo 4311 * structure that contains the information for the implementation of the API. 4312 * 4313 * A specific implementation can be retrieved by name with gst_meta_get_info(). 4314 * 4315 * See #GstBuffer for how the metadata can be added, retrieved and removed from 4316 * buffers. 4317 */ 4318 struct GstMeta 4319 { 4320 /** 4321 * extra flags for the metadata 4322 */ 4323 GstMetaFlags flags; 4324 /** 4325 * pointer to the #GstMetaInfo 4326 */ 4327 GstMetaInfo* info; 4328 } 4329 4330 /** 4331 * The #GstMetaInfo provides information about a specific metadata 4332 * structure. 4333 */ 4334 struct GstMetaInfo 4335 { 4336 /** 4337 * tag identifying the metadata structure and api 4338 */ 4339 GType api; 4340 /** 4341 * type identifying the implementor of the api 4342 */ 4343 GType type; 4344 /** 4345 * size of the metadata 4346 */ 4347 size_t size; 4348 /** 4349 * function for initializing the metadata 4350 */ 4351 GstMetaInitFunction initFunc; 4352 /** 4353 * function for freeing the metadata 4354 */ 4355 GstMetaFreeFunction freeFunc; 4356 /** 4357 * function for transforming the metadata 4358 */ 4359 GstMetaTransformFunction transformFunc; 4360 void*[4] GstReserved; 4361 } 4362 4363 /** 4364 * Extra data passed to a "gst-copy" transform #GstMetaTransformFunction. 4365 */ 4366 struct GstMetaTransformCopy 4367 { 4368 /** 4369 * %TRUE if only region is copied 4370 */ 4371 bool region; 4372 /** 4373 * the offset to copy, 0 if @region is %FALSE, otherwise > 0 4374 */ 4375 size_t offset; 4376 /** 4377 * the size to copy, -1 or the buffer size when @region is %FALSE 4378 */ 4379 size_t size; 4380 } 4381 4382 struct GstMiniObject 4383 { 4384 /** 4385 * the GType of the object 4386 */ 4387 GType type; 4388 /** 4389 * atomic refcount 4390 */ 4391 int refcount; 4392 /** 4393 * atomic state of the locks 4394 */ 4395 int lockstate; 4396 /** 4397 * extra flags. 4398 */ 4399 uint flags; 4400 /** 4401 * a copy function 4402 */ 4403 GstMiniObjectCopyFunction copy; 4404 /** 4405 * a dispose function 4406 */ 4407 GstMiniObjectDisposeFunction dispose; 4408 /** 4409 * the free function 4410 */ 4411 GstMiniObjectFreeFunction free; 4412 uint nQdata; 4413 void* qdata; 4414 } 4415 4416 struct GstObject 4417 { 4418 GObject object; 4419 /** 4420 * object LOCK 4421 */ 4422 GMutex lock; 4423 /** 4424 * The name of the object 4425 */ 4426 char* name; 4427 /** 4428 * this object's parent, weak ref 4429 */ 4430 GstObject* parent; 4431 /** 4432 * flags for this object 4433 */ 4434 uint flags; 4435 GList* controlBindings; 4436 ulong controlRate; 4437 ulong lastSync; 4438 void* GstReserved; 4439 } 4440 4441 /** 4442 * GStreamer base object class. 4443 */ 4444 struct GstObjectClass 4445 { 4446 /** 4447 * parent 4448 */ 4449 GObjectClass parentClass; 4450 /** 4451 * separator used by gst_object_get_path_string() 4452 */ 4453 const(char)* pathStringSeparator; 4454 extern(C) void function(GstObject* object, GstObject* orig, GParamSpec* pspec) deepNotify; 4455 void*[4] GstReserved; 4456 } 4457 4458 struct GstPad 4459 { 4460 GstObject object; 4461 /** 4462 * private data owned by the parent element 4463 */ 4464 void* elementPrivate; 4465 /** 4466 * padtemplate for this pad 4467 */ 4468 GstPadTemplate* padtemplate; 4469 /** 4470 * the direction of the pad, cannot change after creating 4471 * the pad. 4472 */ 4473 GstPadDirection direction; 4474 GRecMutex streamRecLock; 4475 GstTask* task; 4476 GCond blockCond; 4477 GHookList probes; 4478 GstPadMode mode; 4479 GstPadActivateFunction activatefunc; 4480 void* activatedata; 4481 GDestroyNotify activatenotify; 4482 GstPadActivateModeFunction activatemodefunc; 4483 void* activatemodedata; 4484 GDestroyNotify activatemodenotify; 4485 GstPad* peer; 4486 GstPadLinkFunction linkfunc; 4487 void* linkdata; 4488 GDestroyNotify linknotify; 4489 GstPadUnlinkFunction unlinkfunc; 4490 void* unlinkdata; 4491 GDestroyNotify unlinknotify; 4492 GstPadChainFunction chainfunc; 4493 void* chaindata; 4494 GDestroyNotify chainnotify; 4495 GstPadChainListFunction chainlistfunc; 4496 void* chainlistdata; 4497 GDestroyNotify chainlistnotify; 4498 GstPadGetRangeFunction getrangefunc; 4499 void* getrangedata; 4500 GDestroyNotify getrangenotify; 4501 GstPadEventFunction eventfunc; 4502 void* eventdata; 4503 GDestroyNotify eventnotify; 4504 long offset; 4505 GstPadQueryFunction queryfunc; 4506 void* querydata; 4507 GDestroyNotify querynotify; 4508 GstPadIterIntLinkFunction iterintlinkfunc; 4509 void* iterintlinkdata; 4510 GDestroyNotify iterintlinknotify; 4511 int numProbes; 4512 int numBlocked; 4513 GstPadPrivate* priv; 4514 union ABI 4515 { 4516 void*[4] GstReserved; 4517 struct Abi 4518 { 4519 GstFlowReturn lastFlowret; 4520 } 4521 Abi abi; 4522 } 4523 ABI abi; 4524 } 4525 4526 struct GstPadClass 4527 { 4528 GstObjectClass parentClass; 4529 extern(C) void function(GstPad* pad, GstPad* peer) linked; 4530 extern(C) void function(GstPad* pad, GstPad* peer) unlinked; 4531 void*[4] GstReserved; 4532 } 4533 4534 struct GstPadPrivate; 4535 4536 struct GstPadProbeInfo 4537 { 4538 /** 4539 * the current probe type 4540 */ 4541 GstPadProbeType type; 4542 /** 4543 * the id of the probe 4544 */ 4545 gulong id; 4546 /** 4547 * type specific data, check the @type field to know the 4548 * datatype. This field can be %NULL. 4549 */ 4550 void* data; 4551 /** 4552 * offset of pull probe, this field is valid when @type contains 4553 * #GST_PAD_PROBE_TYPE_PULL 4554 */ 4555 ulong offset; 4556 /** 4557 * size of pull probe, this field is valid when @type contains 4558 * #GST_PAD_PROBE_TYPE_PULL 4559 */ 4560 uint size; 4561 union ABI 4562 { 4563 void*[4] GstReserved; 4564 struct Abi 4565 { 4566 GstFlowReturn flowRet; 4567 } 4568 Abi abi; 4569 } 4570 ABI abi; 4571 } 4572 4573 struct GstPadTemplate 4574 { 4575 GstObject object; 4576 char* nameTemplate; 4577 GstPadDirection direction; 4578 GstPadPresence presence; 4579 GstCaps* caps; 4580 void*[4] GstReserved; 4581 } 4582 4583 struct GstPadTemplateClass 4584 { 4585 GstObjectClass parentClass; 4586 extern(C) void function(GstPadTemplate* templ, GstPad* pad) padCreated; 4587 void*[4] GstReserved; 4588 } 4589 4590 4591 /** 4592 * A GParamSpec derived structure that contains the meta data for fractional 4593 * properties. 4594 */ 4595 struct GstParamSpecFraction 4596 { 4597 /** 4598 * super class 4599 */ 4600 GParamSpec parentInstance; 4601 /** 4602 * minimal numerator 4603 */ 4604 int minNum; 4605 /** 4606 * minimal denominator 4607 */ 4608 int minDen; 4609 /** 4610 * maximal numerator 4611 */ 4612 int maxNum; 4613 /** 4614 * maximal denominator 4615 */ 4616 int maxDen; 4617 /** 4618 * default numerator 4619 */ 4620 int defNum; 4621 /** 4622 * default denominator 4623 */ 4624 int defDen; 4625 } 4626 4627 /** 4628 * The #GstParentBufferMeta is a #GstMeta which can be attached to a #GstBuffer 4629 * to hold a reference to another buffer that is only released when the child 4630 * #GstBuffer is released. 4631 * 4632 * Typically, #GstParentBufferMeta is used when the child buffer is directly 4633 * using the #GstMemory of the parent buffer, and wants to prevent the parent 4634 * buffer from being returned to a buffer pool until the #GstMemory is available 4635 * for re-use. 4636 * 4637 * Since: 1.6 4638 */ 4639 struct GstParentBufferMeta 4640 { 4641 /** 4642 * the parent #GstMeta structure 4643 */ 4644 GstMeta parent; 4645 /** 4646 * the #GstBuffer on which a reference is being held. 4647 */ 4648 GstBuffer* buffer; 4649 } 4650 4651 struct GstParseContext; 4652 4653 struct GstPipeline 4654 { 4655 GstBin bin; 4656 /** 4657 * The fixed clock of the pipeline, used when 4658 * GST_PIPELINE_FLAG_FIXED_CLOCK is set. 4659 */ 4660 GstClock* fixedClock; 4661 /** 4662 * The stream time of the pipeline. A better name for this 4663 * property would be the running_time, the total time spent in the 4664 * PLAYING state without being flushed. (deprecated, use the start_time 4665 * on GstElement). 4666 */ 4667 GstClockTime streamTime; 4668 /** 4669 * Extra delay added to base_time to compensate for computing delays 4670 * when setting elements to PLAYING. 4671 */ 4672 GstClockTime delay; 4673 GstPipelinePrivate* priv; 4674 void*[4] GstReserved; 4675 } 4676 4677 struct GstPipelineClass 4678 { 4679 GstBinClass parentClass; 4680 void*[4] GstReserved; 4681 } 4682 4683 struct GstPipelinePrivate; 4684 4685 struct GstPlugin; 4686 4687 struct GstPluginClass; 4688 4689 /** 4690 * A plugin should export a variable of this type called plugin_desc. The plugin 4691 * loader will use the data provided there to initialize the plugin. 4692 * 4693 * The @licence parameter must be one of: LGPL, GPL, QPL, GPL/QPL, MPL, 4694 * BSD, MIT/X11, Proprietary, unknown. 4695 */ 4696 struct GstPluginDesc 4697 { 4698 /** 4699 * the major version number of core that plugin was compiled for 4700 */ 4701 int majorVersion; 4702 /** 4703 * the minor version number of core that plugin was compiled for 4704 */ 4705 int minorVersion; 4706 /** 4707 * a unique name of the plugin 4708 */ 4709 const(char)* name; 4710 /** 4711 * description of plugin 4712 */ 4713 const(char)* description; 4714 /** 4715 * pointer to the init function of this plugin. 4716 */ 4717 GstPluginInitFunc pluginInit; 4718 /** 4719 * version of the plugin 4720 */ 4721 const(char)* versio; 4722 /** 4723 * effective license of plugin 4724 */ 4725 const(char)* license; 4726 /** 4727 * source module plugin belongs to 4728 */ 4729 const(char)* source; 4730 /** 4731 * shipped package plugin belongs to 4732 */ 4733 const(char)* p; 4734 /** 4735 * URL to provider of plugin 4736 */ 4737 const(char)* origin; 4738 /** 4739 * date time string in ISO 8601 4740 * format (or rather, a subset thereof), or %NULL. Allowed are the 4741 * following formats: "YYYY-MM-DD" and "YYY-MM-DDTHH:MMZ" (with 4742 * 'T' a separator and 'Z' indicating UTC/Zulu time). This field 4743 * should be set via the GST_PACKAGE_RELEASE_DATETIME 4744 * preprocessor macro. 4745 */ 4746 const(char)* releaseDatetime; 4747 void*[4] GstReserved; 4748 } 4749 4750 struct GstPluginFeature; 4751 4752 struct GstPluginFeatureClass; 4753 4754 struct GstPoll; 4755 4756 struct GstPollFD 4757 { 4758 /** 4759 * a file descriptor 4760 */ 4761 int fd; 4762 int idx; 4763 } 4764 4765 struct GstPreset; 4766 4767 /** 4768 * #GstPreset interface. 4769 */ 4770 struct GstPresetInterface 4771 { 4772 /** 4773 * parent interface type. 4774 */ 4775 GTypeInterface parent; 4776 /** 4777 * 4778 * Params: 4779 * preset = a #GObject that implements #GstPreset 4780 * Return: list with names, use g_strfreev() after usage. 4781 */ 4782 extern(C) char** function(GstPreset* preset) getPresetNames; 4783 /** 4784 * 4785 * Params: 4786 * preset = a #GObject that implements #GstPreset 4787 * Return: an 4788 * array of property names which should be freed with g_strfreev() after use. 4789 */ 4790 extern(C) char** function(GstPreset* preset) getPropertyNames; 4791 /** 4792 * 4793 * Params: 4794 * preset = a #GObject that implements #GstPreset 4795 * name = preset name to load 4796 * Return: %TRUE for success, %FALSE if e.g. there is no preset with that @name 4797 */ 4798 extern(C) int function(GstPreset* preset, const(char)* name) loadPreset; 4799 /** 4800 * 4801 * Params: 4802 * preset = a #GObject that implements #GstPreset 4803 * name = preset name to save 4804 * Return: %TRUE for success, %FALSE 4805 */ 4806 extern(C) int function(GstPreset* preset, const(char)* name) savePreset; 4807 /** 4808 * 4809 * Params: 4810 * preset = a #GObject that implements #GstPreset 4811 * oldName = current preset name 4812 * newName = new preset name 4813 * Return: %TRUE for success, %FALSE if e.g. there is no preset with @old_name 4814 */ 4815 extern(C) int function(GstPreset* preset, const(char)* oldName, const(char)* newName) renamePreset; 4816 /** 4817 * 4818 * Params: 4819 * preset = a #GObject that implements #GstPreset 4820 * name = preset name to remove 4821 * Return: %TRUE for success, %FALSE if e.g. there is no preset with that @name 4822 */ 4823 extern(C) int function(GstPreset* preset, const(char)* name) deletePreset; 4824 /** 4825 * 4826 * Params: 4827 * preset = a #GObject that implements #GstPreset 4828 * name = preset name 4829 * tag = meta data item name 4830 * value = new value 4831 * Return: %TRUE for success, %FALSE if e.g. there is no preset with that @name 4832 */ 4833 extern(C) int function(GstPreset* preset, const(char)* name, const(char)* tag, const(char)* value) setMeta; 4834 /** 4835 * 4836 * Params: 4837 * preset = a #GObject that implements #GstPreset 4838 * name = preset name 4839 * tag = meta data item name 4840 * value = value 4841 * Return: %TRUE for success, %FALSE if e.g. there is no preset with that @name 4842 * or no value for the given @tag 4843 */ 4844 extern(C) int function(GstPreset* preset, const(char)* name, const(char)* tag, char** value) getMeta; 4845 void*[4] GstReserved; 4846 } 4847 4848 /** 4849 * Metadata type that holds information about a sample from a protection-protected 4850 * track, including the information needed to decrypt it (if it is encrypted). 4851 * 4852 * Since: 1.6 4853 */ 4854 struct GstProtectionMeta 4855 { 4856 /** 4857 * the parent #GstMeta. 4858 */ 4859 GstMeta meta; 4860 /** 4861 * the cryptographic information needed to decrypt the sample. 4862 */ 4863 GstStructure* info; 4864 } 4865 4866 struct GstProxyPad 4867 { 4868 GstPad pad; 4869 GstProxyPadPrivate* priv; 4870 } 4871 4872 struct GstProxyPadClass 4873 { 4874 GstPadClass parentClass; 4875 void*[1] GstReserved; 4876 } 4877 4878 struct GstProxyPadPrivate; 4879 4880 struct GstQuery 4881 { 4882 /** 4883 * The parent #GstMiniObject type 4884 */ 4885 GstMiniObject miniObject; 4886 /** 4887 * the #GstQueryType 4888 */ 4889 GstQueryType type; 4890 } 4891 4892 struct GstRegistry 4893 { 4894 GstObject object; 4895 GstRegistryPrivate* priv; 4896 } 4897 4898 struct GstRegistryClass 4899 { 4900 GstObjectClass parentClass; 4901 } 4902 4903 struct GstRegistryPrivate; 4904 4905 struct GstSample; 4906 4907 struct GstSegment 4908 { 4909 /** 4910 * flags for this segment 4911 */ 4912 GstSegmentFlags flags; 4913 /** 4914 * the rate of the segment 4915 */ 4916 double rate; 4917 /** 4918 * the already applied rate to the segment 4919 */ 4920 double appliedRate; 4921 /** 4922 * the format of the segment values 4923 */ 4924 GstFormat format; 4925 /** 4926 * the base of the segment 4927 */ 4928 ulong base; 4929 /** 4930 * the offset to apply to @start or @stop 4931 */ 4932 ulong offset; 4933 /** 4934 * the start of the segment 4935 */ 4936 ulong start; 4937 /** 4938 * the stop of the segment 4939 */ 4940 ulong stop; 4941 /** 4942 * the stream time of the segment 4943 */ 4944 ulong time; 4945 /** 4946 * the position in the segment (used internally by elements 4947 * such as sources, demuxers or parsers to track progress) 4948 */ 4949 ulong position; 4950 /** 4951 * the duration of the segment 4952 */ 4953 ulong duration; 4954 void*[4] GstReserved; 4955 } 4956 4957 struct GstStaticCaps 4958 { 4959 /** 4960 * the cached #GstCaps 4961 */ 4962 GstCaps* caps; 4963 /** 4964 * a string describing a caps 4965 */ 4966 const(char)* str; 4967 void*[4] GstReserved; 4968 } 4969 4970 struct GstStaticPadTemplate 4971 { 4972 /** 4973 * the name of the template 4974 */ 4975 const(char)* nameTemplate; 4976 /** 4977 * the direction of the template 4978 */ 4979 GstPadDirection direction; 4980 /** 4981 * the presence of the template 4982 */ 4983 GstPadPresence presence; 4984 /** 4985 * the caps of the template. 4986 */ 4987 GstStaticCaps staticCaps; 4988 } 4989 4990 struct GstStructure 4991 { 4992 /** 4993 * the GType of a structure 4994 */ 4995 GType type; 4996 GQuark name; 4997 } 4998 4999 struct GstSystemClock 5000 { 5001 GstClock clock; 5002 GstSystemClockPrivate* priv; 5003 void*[4] GstReserved; 5004 } 5005 5006 struct GstSystemClockClass 5007 { 5008 GstClockClass parentClass; 5009 void*[4] GstReserved; 5010 } 5011 5012 struct GstSystemClockPrivate; 5013 5014 struct GstTagList 5015 { 5016 /** 5017 * the parent type 5018 */ 5019 GstMiniObject miniObject; 5020 } 5021 5022 struct GstTagSetter; 5023 5024 /** 5025 * #GstTagSetterInterface interface. 5026 */ 5027 struct GstTagSetterInterface 5028 { 5029 /** 5030 * parent interface type. 5031 */ 5032 GTypeInterface gIface; 5033 } 5034 5035 struct GstTask 5036 { 5037 GstObject object; 5038 /** 5039 * the state of the task 5040 */ 5041 GstTaskState state; 5042 /** 5043 * used to pause/resume the task 5044 */ 5045 GCond cond; 5046 /** 5047 * The lock taken when iterating the task function 5048 */ 5049 GRecMutex* lock; 5050 /** 5051 * the function executed by this task 5052 */ 5053 GstTaskFunction func; 5054 /** 5055 * user_data passed to the task function 5056 */ 5057 void* userData; 5058 /** 5059 * GDestroyNotify for @user_data 5060 */ 5061 GDestroyNotify notify; 5062 /** 5063 * a flag indicating that the task is running 5064 */ 5065 bool running; 5066 GThread* thread; 5067 GstTaskPrivate* priv; 5068 void*[4] GstReserved; 5069 } 5070 5071 struct GstTaskClass 5072 { 5073 GstObjectClass parentClass; 5074 GstTaskPool* pool; 5075 void*[4] GstReserved; 5076 } 5077 5078 struct GstTaskPool 5079 { 5080 GstObject object; 5081 GThreadPool* pool; 5082 void*[4] GstReserved; 5083 } 5084 5085 /** 5086 * The #GstTaskPoolClass object. 5087 */ 5088 struct GstTaskPoolClass 5089 { 5090 /** 5091 * the parent class structure 5092 */ 5093 GstObjectClass parentClass; 5094 extern(C) void function(GstTaskPool* pool, GError** err) prepare; 5095 extern(C) void function(GstTaskPool* pool) cleanup; 5096 /** 5097 * 5098 * Params: 5099 * pool = a #GstTaskPool 5100 * func = the function to call 5101 * userData = data to pass to @func 5102 * Return: a pointer that should be used 5103 * for the gst_task_pool_join function. This pointer can be %NULL, you 5104 * must check @error to detect errors. 5105 * 5106 * Throws: GException on failure. 5107 */ 5108 extern(C) void* function(GstTaskPool* pool, GstTaskPoolFunction func, void* userData, GError** err) push; 5109 extern(C) void function(GstTaskPool* pool, void* id) join; 5110 void*[4] GstReserved; 5111 } 5112 5113 struct GstTaskPrivate; 5114 5115 /** 5116 * Structure for saving a timestamp and a value. 5117 */ 5118 struct GstTimedValue 5119 { 5120 /** 5121 * timestamp of the value change 5122 */ 5123 GstClockTime timestamp; 5124 /** 5125 * the corresponding value 5126 */ 5127 double value; 5128 } 5129 5130 struct GstToc; 5131 5132 struct GstTocEntry; 5133 5134 struct GstTocSetter; 5135 5136 /** 5137 * #GstTocSetterInterface interface. 5138 */ 5139 struct GstTocSetterInterface 5140 { 5141 /** 5142 * parent interface type. 5143 */ 5144 GTypeInterface gIface; 5145 } 5146 5147 struct GstTypeFind 5148 { 5149 extern(C) ubyte* function(void* data, long offset, uint size) peek; 5150 extern(C) void function(void* data, uint probability, GstCaps* caps) suggest; 5151 /** 5152 * The data used by the caller of the typefinding function. 5153 */ 5154 void* data; 5155 extern(C) ulong function(void* data) getLength; 5156 void*[4] GstReserved; 5157 } 5158 5159 struct GstTypeFindFactory; 5160 5161 struct GstTypeFindFactoryClass; 5162 5163 struct GstURIHandler; 5164 5165 /** 5166 * Any #GstElement using this interface should implement these methods. 5167 */ 5168 struct GstURIHandlerInterface 5169 { 5170 /** 5171 * The parent interface type 5172 */ 5173 GTypeInterface parent; 5174 extern(C) GstURIType function(GType type) getType; 5175 extern(C) char** function(GType type) getProtocols; 5176 /** 5177 * 5178 * Params: 5179 * handler = A #GstURIHandler 5180 * Return: the URI currently handled by 5181 * the @handler. Returns %NULL if there are no URI currently 5182 * handled. The returned string must be freed with g_free() when no 5183 * longer needed. 5184 */ 5185 extern(C) char* function(GstURIHandler* handler) getUri; 5186 /** 5187 * 5188 * Params: 5189 * handler = A #GstURIHandler 5190 * uri = URI to set 5191 * Return: %TRUE if the URI was set successfully, else %FALSE. 5192 * 5193 * Throws: GException on failure. 5194 */ 5195 extern(C) int function(GstURIHandler* handler, const(char)* uri, GError** err) setUri; 5196 } 5197 5198 struct GstUri; 5199 5200 struct GstValueArray; 5201 5202 5203 /** 5204 * VTable for the #GValue @type. 5205 */ 5206 struct GstValueTable 5207 { 5208 /** 5209 * a #GType 5210 */ 5211 GType type; 5212 /** 5213 * a #GstValueCompareFunc 5214 */ 5215 GstValueCompareFunc compare; 5216 /** 5217 * a #GstValueSerializeFunc 5218 */ 5219 GstValueSerializeFunc serialize; 5220 /** 5221 * a #GstValueDeserializeFunc 5222 */ 5223 GstValueDeserializeFunc deserialize; 5224 void*[4] GstReserved; 5225 } 5226 5227 /** 5228 * A function that will be called from gst_buffer_foreach_meta(). The @meta 5229 * field will point to a the reference of the meta. 5230 * 5231 * @buffer should not be modified from this callback. 5232 * 5233 * When this function returns %TRUE, the next meta will be 5234 * returned. When %FALSE is returned, gst_buffer_foreach_meta() will return. 5235 * 5236 * When @meta is set to %NULL, the item will be removed from the buffer. 5237 * 5238 * Params: 5239 * buffer = a #GstBuffer 5240 * meta = a pointer to a #GstMeta 5241 * userData = user data passed to gst_buffer_foreach_meta() 5242 * 5243 * Return: %FALSE when gst_buffer_foreach_meta() should stop 5244 */ 5245 public alias extern(C) int function(GstBuffer* buffer, GstMeta** meta, void* userData) GstBufferForeachMetaFunc; 5246 5247 /** 5248 * A function that will be called from gst_buffer_list_foreach(). The @buffer 5249 * field will point to a the reference of the buffer at @idx. 5250 * 5251 * When this function returns %TRUE, the next buffer will be 5252 * returned. When %FALSE is returned, gst_buffer_list_foreach() will return. 5253 * 5254 * When @buffer is set to %NULL, the item will be removed from the bufferlist. 5255 * When @buffer has been made writable, the new buffer reference can be assigned 5256 * to @buffer. This function is responsible for unreffing the old buffer when 5257 * removing or modifying. 5258 * 5259 * Params: 5260 * buffer = pointer the buffer 5261 * idx = the index of @buffer 5262 * userData = user data passed to gst_buffer_list_foreach() 5263 * 5264 * Return: %FALSE when gst_buffer_list_foreach() should stop 5265 */ 5266 public alias extern(C) int function(GstBuffer** buffer, uint idx, void* userData) GstBufferListFunc; 5267 5268 /** 5269 * Specifies the type of function passed to gst_bus_add_watch() or 5270 * gst_bus_add_watch_full(), which is called from the mainloop when a message 5271 * is available on the bus. 5272 * 5273 * The message passed to the function will be unreffed after execution of this 5274 * function so it should not be freed in the function. 5275 * 5276 * Note that this function is used as a GSourceFunc which means that returning 5277 * %FALSE will remove the GSource from the mainloop. 5278 * 5279 * Params: 5280 * bus = the #GstBus that sent the message 5281 * message = the #GstMessage 5282 * userData = user data that has been given, when registering the handler 5283 * 5284 * Return: %FALSE if the event source should be removed. 5285 */ 5286 public alias extern(C) int function(GstBus* bus, GstMessage* message, void* userData) GstBusFunc; 5287 5288 /** 5289 * Handler will be invoked synchronously, when a new message has been injected 5290 * into the bus. This function is mostly used internally. Only one sync handler 5291 * can be attached to a given bus. 5292 * 5293 * If the handler returns GST_BUS_DROP, it should unref the message, else the 5294 * message should not be unreffed by the sync handler. 5295 * 5296 * Params: 5297 * bus = the #GstBus that sent the message 5298 * message = the #GstMessage 5299 * userData = user data that has been given, when registering the handler 5300 * 5301 * Return: #GstBusSyncReply stating what to do with the message 5302 */ 5303 public alias extern(C) GstBusSyncReply function(GstBus* bus, GstMessage* message, void* userData) GstBusSyncHandler; 5304 5305 /** 5306 * A function that will be called in gst_caps_filter_and_map_in_place(). 5307 * The function may modify @features and @structure, and both will be 5308 * removed from the caps if %FALSE is returned. 5309 * 5310 * Params: 5311 * features = the #GstCapsFeatures 5312 * structure = the #GstStructure 5313 * userData = user data 5314 * 5315 * Return: %TRUE if the features and structure should be preserved, 5316 * %FALSE if it should be removed. 5317 */ 5318 public alias extern(C) int function(GstCapsFeatures* features, GstStructure* structure, void* userData) GstCapsFilterMapFunc; 5319 5320 /** 5321 * A function that will be called in gst_caps_foreach(). The function may 5322 * not modify @features or @structure. 5323 * 5324 * Params: 5325 * features = the #GstCapsFeatures 5326 * structure = the #GstStructure 5327 * userData = user data 5328 * 5329 * Return: %TRUE if the foreach operation should continue, %FALSE if 5330 * the foreach operation should stop with %FALSE. 5331 * 5332 * Since: 1.6 5333 */ 5334 public alias extern(C) int function(GstCapsFeatures* features, GstStructure* structure, void* userData) GstCapsForeachFunc; 5335 5336 /** 5337 * A function that will be called in gst_caps_map_in_place(). The function 5338 * may modify @features and @structure. 5339 * 5340 * Params: 5341 * features = the #GstCapsFeatures 5342 * structure = the #GstStructure 5343 * userData = user data 5344 * 5345 * Return: %TRUE if the map operation should continue, %FALSE if 5346 * the map operation should stop with %FALSE. 5347 */ 5348 public alias extern(C) int function(GstCapsFeatures* features, GstStructure* structure, void* userData) GstCapsMapFunc; 5349 5350 /** 5351 * The function prototype of the callback. 5352 * 5353 * Params: 5354 * clock = The clock that triggered the callback 5355 * time = The time it was triggered 5356 * id = The #GstClockID that expired 5357 * userData = user data passed in the gst_clock_id_wait_async() function 5358 * 5359 * Return: %TRUE or %FALSE (currently unused) 5360 */ 5361 public alias extern(C) int function(GstClock* clock, GstClockTime time, GstClockID id, void* userData) GstClockCallback; 5362 5363 public alias extern(C) void function(GstControlBinding* binding, double srcValue, GValue* destValue) GstControlBindingConvert; 5364 5365 /** 5366 * Function for returning a value for a given timestamp. 5367 * 5368 * Params: 5369 * self = the #GstControlSource instance 5370 * timestamp = timestamp for which a value should be calculated 5371 * value = a #GValue which will be set to the result. It must be initialized to the correct type. 5372 * 5373 * Return: %TRUE if the value was successfully calculated. 5374 */ 5375 public alias extern(C) int function(GstControlSource* self, GstClockTime timestamp, double* value) GstControlSourceGetValue; 5376 5377 /** 5378 * Function for returning an array of values for starting at a given timestamp. 5379 * 5380 * Params: 5381 * self = the #GstControlSource instance 5382 * timestamp = timestamp for which a value should be calculated 5383 * interval = the time spacing between subsequent values 5384 * nValues = the number of values 5385 * values = array to put control-values in 5386 * 5387 * Return: %TRUE if the values were successfully calculated. 5388 */ 5389 public alias extern(C) int function(GstControlSource* self, GstClockTime timestamp, GstClockTime interval, uint nValues, double* values) GstControlSourceGetValueArray; 5390 5391 public alias extern(C) void function() GstDebugFuncPtr; 5392 5393 /** 5394 * This function will be called when creating a copy of @it and should 5395 * create a copy of all custom iterator fields or increase their 5396 * reference counts. 5397 * 5398 * Params: 5399 * it = The original iterator 5400 * copy = The copied iterator 5401 */ 5402 public alias extern(C) void function(GstIterator* it, GstIterator* copy) GstIteratorCopyFunction; 5403 5404 /** 5405 * A function to be passed to gst_iterator_fold(). 5406 * 5407 * Params: 5408 * item = the item to fold 5409 * ret = a #GValue collecting the result 5410 * userData = data passed to gst_iterator_fold() 5411 * 5412 * Return: %TRUE if the fold should continue, %FALSE if it should stop. 5413 */ 5414 public alias extern(C) int function(GValue* item, GValue* ret, void* userData) GstIteratorFoldFunction; 5415 5416 /** 5417 * A function that is called by gst_iterator_foreach() for every element. 5418 * 5419 * Params: 5420 * item = The item 5421 * userData = User data 5422 */ 5423 public alias extern(C) void function(GValue* item, void* userData) GstIteratorForeachFunction; 5424 5425 /** 5426 * This function will be called when the iterator is freed. 5427 * 5428 * Implementors of a #GstIterator should implement this 5429 * function and pass it to the constructor of the custom iterator. 5430 * The function will be called with the iterator lock held. 5431 * 5432 * Params: 5433 * it = the iterator 5434 */ 5435 public alias extern(C) void function(GstIterator* it) GstIteratorFreeFunction; 5436 5437 /** 5438 * The function that will be called after the next item of the iterator 5439 * has been retrieved. This function can be used to skip items or stop 5440 * the iterator. 5441 * 5442 * The function will be called with the iterator lock held. 5443 * 5444 * Params: 5445 * it = the iterator 5446 * item = the item being retrieved. 5447 * 5448 * Return: the result of the operation. 5449 */ 5450 public alias extern(C) GstIteratorItem function(GstIterator* it, GValue* item) GstIteratorItemFunction; 5451 5452 /** 5453 * The function that will be called when the next element of the iterator 5454 * should be retrieved. 5455 * 5456 * Implementors of a #GstIterator should implement this 5457 * function and pass it to the constructor of the custom iterator. 5458 * The function will be called with the iterator lock held. 5459 * 5460 * Params: 5461 * it = the iterator 5462 * result = a pointer to hold the next item 5463 * 5464 * Return: the result of the operation. 5465 */ 5466 public alias extern(C) GstIteratorResult function(GstIterator* it, GValue* result) GstIteratorNextFunction; 5467 5468 /** 5469 * This function will be called whenever a concurrent update happened 5470 * to the iterated datastructure. The implementor of the iterator should 5471 * restart the iterator from the beginning and clean up any state it might 5472 * have. 5473 * 5474 * Implementors of a #GstIterator should implement this 5475 * function and pass it to the constructor of the custom iterator. 5476 * The function will be called with the iterator lock held. 5477 * 5478 * Params: 5479 * it = the iterator 5480 */ 5481 public alias extern(C) void function(GstIterator* it) GstIteratorResyncFunction; 5482 5483 /** 5484 * Function prototype for a logging function that can be registered with 5485 * gst_debug_add_log_function(). 5486 * Use G_GNUC_NO_INSTRUMENT on that function. 5487 * 5488 * Params: 5489 * category = a #GstDebugCategory 5490 * level = a #GstDebugLevel 5491 * file = file name 5492 * funct = function name 5493 * line = line number 5494 * object = a #GObject 5495 * message = the message 5496 * userData = user data for the log function 5497 */ 5498 public alias extern(C) void function(GstDebugCategory* category, GstDebugLevel level, const(char)* file, const(char)* funct, int line, GObject* object, GstDebugMessage* message, void* userData) GstLogFunction; 5499 5500 /** 5501 * Copy @size bytes from @mem starting at @offset and return them wrapped in a 5502 * new GstMemory object. 5503 * If @size is set to -1, all bytes starting at @offset are copied. 5504 * 5505 * Params: 5506 * mem = a #GstMemory 5507 * offset = an offset 5508 * size = a size or -1 5509 * 5510 * Return: a new #GstMemory object wrapping a copy of the requested region in 5511 * @mem. 5512 */ 5513 public alias extern(C) GstMemory* function(GstMemory* mem, ptrdiff_t offset, ptrdiff_t size) GstMemoryCopyFunction; 5514 5515 /** 5516 * Check if @mem1 and @mem2 occupy contiguous memory and return the offset of 5517 * @mem1 in the parent buffer in @offset. 5518 * 5519 * Params: 5520 * mem1 = a #GstMemory 5521 * mem2 = a #GstMemory 5522 * offset = a result offset 5523 * 5524 * Return: %TRUE if @mem1 and @mem2 are in contiguous memory. 5525 */ 5526 public alias extern(C) int function(GstMemory* mem1, GstMemory* mem2, size_t* offset) GstMemoryIsSpanFunction; 5527 5528 /** 5529 * Get the memory of @mem that can be accessed according to the mode specified 5530 * in @info's flags. The function should return a pointer that contains at least 5531 * @maxsize bytes. 5532 * 5533 * Params: 5534 * mem = a #GstMemory 5535 * info = the #GstMapInfo to map with 5536 * maxsize = size to map 5537 * 5538 * Return: a pointer to memory of which at least @maxsize bytes can be 5539 * accessed according to the access pattern in @info's flags. 5540 */ 5541 public alias extern(C) void* function(GstMemory* mem, GstMapInfo* info, size_t maxsize) GstMemoryMapFullFunction; 5542 5543 /** 5544 * Get the memory of @mem that can be accessed according to the mode specified 5545 * in @flags. The function should return a pointer that contains at least 5546 * @maxsize bytes. 5547 * 5548 * Params: 5549 * mem = a #GstMemory 5550 * maxsize = size to map 5551 * flags = access mode for the memory 5552 * 5553 * Return: a pointer to memory of which at least @maxsize bytes can be 5554 * accessed according to the access pattern in @flags. 5555 */ 5556 public alias extern(C) void* function(GstMemory* mem, size_t maxsize, GstMapFlags flags) GstMemoryMapFunction; 5557 5558 /** 5559 * Share @size bytes from @mem starting at @offset and return them wrapped in a 5560 * new GstMemory object. If @size is set to -1, all bytes starting at @offset are 5561 * shared. This function does not make a copy of the bytes in @mem. 5562 * 5563 * Params: 5564 * mem = a #GstMemory 5565 * offset = an offset 5566 * size = a size or -1 5567 * 5568 * Return: a new #GstMemory object sharing the requested region in @mem. 5569 */ 5570 public alias extern(C) GstMemory* function(GstMemory* mem, ptrdiff_t offset, ptrdiff_t size) GstMemoryShareFunction; 5571 5572 /** 5573 * Return the pointer previously retrieved with gst_memory_map() with @info. 5574 * 5575 * Params: 5576 * mem = a #GstMemory 5577 * info = a #GstMapInfo 5578 */ 5579 public alias extern(C) void function(GstMemory* mem, GstMapInfo* info) GstMemoryUnmapFullFunction; 5580 5581 /** 5582 * Return the pointer previously retrieved with gst_memory_map(). 5583 * 5584 * Params: 5585 * mem = a #GstMemory 5586 */ 5587 public alias extern(C) void function(GstMemory* mem) GstMemoryUnmapFunction; 5588 5589 /** 5590 * Function called when @meta is freed in @buffer. 5591 * 5592 * Params: 5593 * meta = a #GstMeta 5594 * buffer = a #GstBuffer 5595 */ 5596 public alias extern(C) void function(GstMeta* meta, GstBuffer* buffer) GstMetaFreeFunction; 5597 5598 /** 5599 * Function called when @meta is initialized in @buffer. 5600 * 5601 * Params: 5602 * meta = a #GstMeta 5603 * params = parameters passed to the init function 5604 * buffer = a #GstBuffer 5605 */ 5606 public alias extern(C) int function(GstMeta* meta, void* params, GstBuffer* buffer) GstMetaInitFunction; 5607 5608 /** 5609 * Function called for each @meta in @buffer as a result of performing a 5610 * transformation on @transbuf. Additional @type specific transform data 5611 * is passed to the function as @data. 5612 * 5613 * Implementations should check the @type of the transform and parse 5614 * additional type specific fields in @data that should be used to update 5615 * the metadata on @transbuf. 5616 * 5617 * Params: 5618 * transbuf = a #GstBuffer 5619 * meta = a #GstMeta 5620 * buffer = a #GstBuffer 5621 * type = the transform type 5622 * data = transform specific data. 5623 * 5624 * Return: %TRUE if the transform could be performed 5625 */ 5626 public alias extern(C) int function(GstBuffer* transbuf, GstMeta* meta, GstBuffer* buffer, GQuark type, void* data) GstMetaTransformFunction; 5627 5628 /** 5629 * Function prototype for methods to create copies of instances. 5630 * 5631 * Params: 5632 * obj = MiniObject to copy 5633 * 5634 * Return: reference to cloned instance. 5635 */ 5636 public alias extern(C) GstMiniObject* function(GstMiniObject* obj) GstMiniObjectCopyFunction; 5637 5638 /** 5639 * Function prototype for when a miniobject has lost its last refcount. 5640 * Implementation of the mini object are allowed to revive the 5641 * passed object by doing a gst_mini_object_ref(). If the object is not 5642 * revived after the dispose function, the function should return %TRUE 5643 * and the memory associated with the object is freed. 5644 * 5645 * Params: 5646 * obj = MiniObject to dispose 5647 * 5648 * Return: %TRUE if the object should be cleaned up. 5649 */ 5650 public alias extern(C) int function(GstMiniObject* obj) GstMiniObjectDisposeFunction; 5651 5652 /** 5653 * Virtual function prototype for methods to free resources used by 5654 * mini-objects. 5655 * 5656 * Params: 5657 * obj = MiniObject to free 5658 */ 5659 public alias extern(C) void function(GstMiniObject* obj) GstMiniObjectFreeFunction; 5660 5661 /** 5662 * A #GstMiniObjectNotify function can be added to a mini object as a 5663 * callback that gets triggered when gst_mini_object_unref() drops the 5664 * last ref and @obj is about to be freed. 5665 * 5666 * Params: 5667 * userData = data that was provided when the notify was added 5668 * obj = the mini object 5669 */ 5670 public alias extern(C) void function(void* userData, GstMiniObject* obj) GstMiniObjectNotify; 5671 5672 /** 5673 * This function is called when the pad is activated during the element 5674 * READY to PAUSED state change. By default this function will call the 5675 * activate function that puts the pad in push mode but elements can 5676 * override this function to activate the pad in pull mode if they wish. 5677 * 5678 * Params: 5679 * pad = a #GstPad 5680 * parent = the parent of @pad 5681 * 5682 * Return: %TRUE if the pad could be activated. 5683 */ 5684 public alias extern(C) int function(GstPad* pad, GstObject* parent) GstPadActivateFunction; 5685 5686 /** 5687 * The prototype of the push and pull activate functions. 5688 * 5689 * Params: 5690 * pad = a #GstPad 5691 * parent = the parent of @pad 5692 * mode = the requested activation mode of @pad 5693 * active = activate or deactivate the pad. 5694 * 5695 * Return: %TRUE if the pad could be activated or deactivated. 5696 */ 5697 public alias extern(C) int function(GstPad* pad, GstObject* parent, GstPadMode mode, int active) GstPadActivateModeFunction; 5698 5699 /** 5700 * A function that will be called on sinkpads when chaining buffers. 5701 * The function typically processes the data contained in the buffer and 5702 * either consumes the data or passes it on to the internally linked pad(s). 5703 * 5704 * The implementer of this function receives a refcount to @buffer and should 5705 * gst_buffer_unref() when the buffer is no longer needed. 5706 * 5707 * When a chain function detects an error in the data stream, it must post an 5708 * error on the bus and return an appropriate #GstFlowReturn value. 5709 * 5710 * Params: 5711 * pad = the sink #GstPad that performed the chain. 5712 * parent = the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT 5713 * flag is set, @parent is guaranteed to be not-%NULL and remain valid 5714 * during the execution of this function. 5715 * buffer = the #GstBuffer that is chained, not %NULL. 5716 * 5717 * Return: #GST_FLOW_OK for success 5718 */ 5719 public alias extern(C) GstFlowReturn function(GstPad* pad, GstObject* parent, GstBuffer* buffer) GstPadChainFunction; 5720 5721 /** 5722 * A function that will be called on sinkpads when chaining buffer lists. 5723 * The function typically processes the data contained in the buffer list and 5724 * either consumes the data or passes it on to the internally linked pad(s). 5725 * 5726 * The implementer of this function receives a refcount to @list and 5727 * should gst_buffer_list_unref() when the list is no longer needed. 5728 * 5729 * When a chainlist function detects an error in the data stream, it must 5730 * post an error on the bus and return an appropriate #GstFlowReturn value. 5731 * 5732 * Params: 5733 * pad = the sink #GstPad that performed the chain. 5734 * parent = the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT 5735 * flag is set, @parent is guaranteed to be not-%NULL and remain valid 5736 * during the execution of this function. 5737 * list = the #GstBufferList that is chained, not %NULL. 5738 * 5739 * Return: #GST_FLOW_OK for success 5740 */ 5741 public alias extern(C) GstFlowReturn function(GstPad* pad, GstObject* parent, GstBufferList* list) GstPadChainListFunction; 5742 5743 /** 5744 * Function signature to handle an event for the pad. 5745 * 5746 * Params: 5747 * pad = the #GstPad to handle the event. 5748 * parent = the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT 5749 * flag is set, @parent is guaranteed to be not-%NULL and remain valid 5750 * during the execution of this function. 5751 * event = the #GstEvent to handle. 5752 * 5753 * Return: %TRUE if the pad could handle the event. 5754 */ 5755 public alias extern(C) int function(GstPad* pad, GstObject* parent, GstEvent* event) GstPadEventFunction; 5756 5757 /** 5758 * A forward function is called for all internally linked pads, see 5759 * gst_pad_forward(). 5760 * 5761 * Params: 5762 * pad = the #GstPad that is forwarded. 5763 * userData = the gpointer to optional user data. 5764 * 5765 * Return: %TRUE if the dispatching procedure has to be stopped. 5766 */ 5767 public alias extern(C) int function(GstPad* pad, void* userData) GstPadForwardFunction; 5768 5769 /** 5770 * This function will be called on source pads when a peer element 5771 * request a buffer at the specified @offset and @length. If this function 5772 * returns #GST_FLOW_OK, the result buffer will be stored in @buffer. The 5773 * contents of @buffer is invalid for any other return value. 5774 * 5775 * This function is installed on a source pad with 5776 * gst_pad_set_getrange_function() and can only be called on source pads after 5777 * they are successfully activated with gst_pad_activate_mode() with the 5778 * #GST_PAD_MODE_PULL. 5779 * 5780 * @offset and @length are always given in byte units. @offset must normally be a value 5781 * between 0 and the length in bytes of the data available on @pad. The 5782 * length (duration in bytes) can be retrieved with a #GST_QUERY_DURATION or with a 5783 * #GST_QUERY_SEEKING. 5784 * 5785 * Any @offset larger or equal than the length will make the function return 5786 * #GST_FLOW_EOS, which corresponds to EOS. In this case @buffer does not 5787 * contain a valid buffer. 5788 * 5789 * The buffer size of @buffer will only be smaller than @length when @offset is 5790 * near the end of the stream. In all other cases, the size of @buffer must be 5791 * exactly the requested size. 5792 * 5793 * It is allowed to call this function with a 0 @length and valid @offset, in 5794 * which case @buffer will contain a 0-sized buffer and the function returns 5795 * #GST_FLOW_OK. 5796 * 5797 * When this function is called with a -1 @offset, the sequentially next buffer 5798 * of length @length in the stream is returned. 5799 * 5800 * When this function is called with a -1 @length, a buffer with a default 5801 * optimal length is returned in @buffer. The length might depend on the value 5802 * of @offset. 5803 * 5804 * Params: 5805 * pad = the src #GstPad to perform the getrange on. 5806 * parent = the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT 5807 * flag is set, @parent is guaranteed to be not-%NULL and remain valid 5808 * during the execution of this function. 5809 * offset = the offset of the range 5810 * length = the length of the range 5811 * buffer = a memory location to hold the result buffer, cannot be %NULL. 5812 * 5813 * Return: #GST_FLOW_OK for success and a valid buffer in @buffer. Any other 5814 * return value leaves @buffer undefined. 5815 */ 5816 public alias extern(C) GstFlowReturn function(GstPad* pad, GstObject* parent, ulong offset, uint length, GstBuffer** buffer) GstPadGetRangeFunction; 5817 5818 /** 5819 * The signature of the internal pad link iterator function. 5820 * 5821 * Params: 5822 * pad = The #GstPad to query. 5823 * parent = the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT 5824 * flag is set, @parent is guaranteed to be not-%NULL and remain valid 5825 * during the execution of this function. 5826 * 5827 * Return: a new #GstIterator that will iterate over all pads that are 5828 * linked to the given pad on the inside of the parent element. 5829 * 5830 * the caller must call gst_iterator_free() after usage. 5831 */ 5832 public alias extern(C) GstIterator* function(GstPad* pad, GstObject* parent) GstPadIterIntLinkFunction; 5833 5834 /** 5835 * Function signature to handle a new link on the pad. 5836 * 5837 * Params: 5838 * pad = the #GstPad that is linked. 5839 * parent = the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT 5840 * flag is set, @parent is guaranteed to be not-%NULL and remain valid 5841 * during the execution of this function. 5842 * peer = the peer #GstPad of the link 5843 * 5844 * Return: the result of the link with the specified peer. 5845 */ 5846 public alias extern(C) GstPadLinkReturn function(GstPad* pad, GstObject* parent, GstPad* peer) GstPadLinkFunction; 5847 5848 /** 5849 * Callback used by gst_pad_add_probe(). Gets called to notify about the current 5850 * blocking type. 5851 * 5852 * The callback is allowed to modify the data pointer in @info. 5853 * 5854 * Params: 5855 * pad = the #GstPad that is blocked 5856 * info = #GstPadProbeInfo 5857 * userData = the gpointer to optional user data. 5858 * 5859 * Return: a #GstPadProbeReturn 5860 */ 5861 public alias extern(C) GstPadProbeReturn function(GstPad* pad, GstPadProbeInfo* info, void* userData) GstPadProbeCallback; 5862 5863 /** 5864 * The signature of the query function. 5865 * 5866 * Params: 5867 * pad = the #GstPad to query. 5868 * parent = the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT 5869 * flag is set, @parent is guaranteed to be not-%NULL and remain valid 5870 * during the execution of this function. 5871 * query = the #GstQuery object to execute 5872 * 5873 * Return: %TRUE if the query could be performed. 5874 */ 5875 public alias extern(C) int function(GstPad* pad, GstObject* parent, GstQuery* query) GstPadQueryFunction; 5876 5877 /** 5878 * Callback used by gst_pad_sticky_events_foreach(). 5879 * 5880 * When this function returns %TRUE, the next event will be 5881 * returned. When %FALSE is returned, gst_pad_sticky_events_foreach() will return. 5882 * 5883 * When @event is set to %NULL, the item will be removed from the list of sticky events. 5884 * @event can be replaced by assigning a new reference to it. 5885 * This function is responsible for unreffing the old event when 5886 * removing or modifying. 5887 * 5888 * Params: 5889 * pad = the #GstPad. 5890 * event = a sticky #GstEvent. 5891 * userData = the #gpointer to optional user data. 5892 * 5893 * Return: %TRUE if the iteration should continue 5894 */ 5895 public alias extern(C) int function(GstPad* pad, GstEvent** event, void* userData) GstPadStickyEventsForeachFunction; 5896 5897 /** 5898 * Function signature to handle a unlinking the pad prom its peer. 5899 * 5900 * Params: 5901 * pad = the #GstPad that is linked. 5902 * parent = the parent of @pad. If the #GST_PAD_FLAG_NEED_PARENT 5903 * flag is set, @parent is guaranteed to be not-%NULL and remain valid 5904 * during the execution of this function. 5905 */ 5906 public alias extern(C) void function(GstPad* pad, GstObject* parent) GstPadUnlinkFunction; 5907 5908 /** 5909 * A function that can be used with e.g. gst_registry_feature_filter() 5910 * to get a list of pluginfeature that match certain criteria. 5911 * 5912 * Params: 5913 * feature = the pluginfeature to check 5914 * userData = the user_data that has been passed on e.g. 5915 * gst_registry_feature_filter() 5916 * 5917 * Return: %TRUE for a positive match, %FALSE otherwise 5918 */ 5919 public alias extern(C) int function(GstPluginFeature* feature, void* userData) GstPluginFeatureFilter; 5920 5921 /** 5922 * A function that can be used with e.g. gst_registry_plugin_filter() 5923 * to get a list of plugins that match certain criteria. 5924 * 5925 * Params: 5926 * plugin = the plugin to check 5927 * userData = the user_data that has been passed on e.g. gst_registry_plugin_filter() 5928 * 5929 * Return: %TRUE for a positive match, %FALSE otherwise 5930 */ 5931 public alias extern(C) int function(GstPlugin* plugin, void* userData) GstPluginFilter; 5932 5933 /** 5934 * A plugin should provide a pointer to a function of either #GstPluginInitFunc 5935 * or this type in the plugin_desc struct. 5936 * The function will be called by the loader at startup. One would then 5937 * register each #GstPluginFeature. This version allows 5938 * user data to be passed to init function (useful for bindings). 5939 * 5940 * Params: 5941 * plugin = The plugin object 5942 * userData = extra data 5943 * 5944 * Return: %TRUE if plugin initialised successfully 5945 */ 5946 public alias extern(C) int function(GstPlugin* plugin, void* userData) GstPluginInitFullFunc; 5947 5948 /** 5949 * A plugin should provide a pointer to a function of this type in the 5950 * plugin_desc struct. 5951 * This function will be called by the loader at startup. One would then 5952 * register each #GstPluginFeature. 5953 * 5954 * Params: 5955 * plugin = The plugin object 5956 * 5957 * Return: %TRUE if plugin initialised successfully 5958 */ 5959 public alias extern(C) int function(GstPlugin* plugin) GstPluginInitFunc; 5960 5961 /** 5962 * A function that will be called in gst_structure_filter_and_map_in_place(). 5963 * The function may modify @value, and the value will be removed from 5964 * the structure if %FALSE is returned. 5965 * 5966 * Params: 5967 * fieldId = the #GQuark of the field name 5968 * value = the #GValue of the field 5969 * userData = user data 5970 * 5971 * Return: %TRUE if the field should be preserved, %FALSE if it 5972 * should be removed. 5973 */ 5974 public alias extern(C) int function(GQuark fieldId, GValue* value, void* userData) GstStructureFilterMapFunc; 5975 5976 /** 5977 * A function that will be called in gst_structure_foreach(). The function may 5978 * not modify @value. 5979 * 5980 * Params: 5981 * fieldId = the #GQuark of the field name 5982 * value = the #GValue of the field 5983 * userData = user data 5984 * 5985 * Return: %TRUE if the foreach operation should continue, %FALSE if 5986 * the foreach operation should stop with %FALSE. 5987 */ 5988 public alias extern(C) int function(GQuark fieldId, GValue* value, void* userData) GstStructureForeachFunc; 5989 5990 /** 5991 * A function that will be called in gst_structure_map_in_place(). The function 5992 * may modify @value. 5993 * 5994 * Params: 5995 * fieldId = the #GQuark of the field name 5996 * value = the #GValue of the field 5997 * userData = user data 5998 * 5999 * Return: %TRUE if the map operation should continue, %FALSE if 6000 * the map operation should stop with %FALSE. 6001 */ 6002 public alias extern(C) int function(GQuark fieldId, GValue* value, void* userData) GstStructureMapFunc; 6003 6004 /** 6005 * A function that will be called in gst_tag_list_foreach(). The function may 6006 * not modify the tag list. 6007 * 6008 * Params: 6009 * list = the #GstTagList 6010 * tag = a name of a tag in @list 6011 * userData = user data 6012 */ 6013 public alias extern(C) void function(GstTagList* list, const(char)* tag, void* userData) GstTagForeachFunc; 6014 6015 /** 6016 * A function for merging multiple values of a tag used when registering 6017 * tags. 6018 * 6019 * Params: 6020 * dest = the destination #GValue 6021 * src = the source #GValue 6022 */ 6023 public alias extern(C) void function(GValue* dest, GValue* src) GstTagMergeFunc; 6024 6025 /** 6026 * A function that will repeatedly be called in the thread created by 6027 * a #GstTask. 6028 * 6029 * Params: 6030 * userData = user data passed to the function 6031 */ 6032 public alias extern(C) void function(void* userData) GstTaskFunction; 6033 6034 /** 6035 * Task function, see gst_task_pool_push(). 6036 * 6037 * Params: 6038 * userData = user data for the task function 6039 */ 6040 public alias extern(C) void function(void* userData) GstTaskPoolFunction; 6041 6042 /** 6043 * Custom GstTask thread callback functions that can be installed. 6044 * 6045 * Params: 6046 * task = The #GstTask 6047 * thread = The #GThread 6048 * userData = user data 6049 */ 6050 public alias extern(C) void function(GstTask* task, GThread* thread, void* userData) GstTaskThreadFunc; 6051 6052 /** 6053 * A function that will be called by typefinding. 6054 * 6055 * Params: 6056 * find = A #GstTypeFind structure 6057 * userData = optional data to pass to the function 6058 */ 6059 public alias extern(C) void function(GstTypeFind* find, void* userData) GstTypeFindFunction; 6060 6061 /** 6062 * Used together with gst_value_compare() to compare #GValue items. 6063 * 6064 * Params: 6065 * value1 = first value for comparison 6066 * value2 = second value for comparison 6067 * 6068 * Return: one of GST_VALUE_LESS_THAN, GST_VALUE_EQUAL, GST_VALUE_GREATER_THAN 6069 * or GST_VALUE_UNORDERED 6070 */ 6071 public alias extern(C) int function(GValue* value1, GValue* value2) GstValueCompareFunc; 6072 6073 /** 6074 * Used by gst_value_deserialize() to parse a non-binary form into the #GValue. 6075 * 6076 * Params: 6077 * dest = a #GValue 6078 * s = a string 6079 * 6080 * Return: %TRUE for success 6081 */ 6082 public alias extern(C) int function(GValue* dest, const(char)* s) GstValueDeserializeFunc; 6083 6084 /** 6085 * Used by gst_value_serialize() to obtain a non-binary form of the #GValue. 6086 * 6087 * Free-function: g_free 6088 * 6089 * Params: 6090 * value1 = a #GValue 6091 * 6092 * Return: the string representation of the value 6093 */ 6094 public alias extern(C) char* function(GValue* value1) GstValueSerializeFunc;