vapi/gstreamer-base-0.10.vapi

   1 /* gstreamer-base-0.10.vapi generated by vapigen, do not modify. */
   2
   3 [CCode (cprefix = "Gst", gir_namespace = "GstBase", gir_version = "0.10", lower_case_cprefix = "gst_")]
   4 namespace Gst {
   5         [CCode (cheader_filename = "gst/base/gstadapter.h")]
   6         public class Adapter : GLib.Object {
   7                 [CCode (has_construct_function = false)]
   8                 public Adapter ();
   9                 public uint available ();
  10                 public uint available_fast ();
  11                 public void clear ();
  12                 public void copy (uchar dest, uint offset, uint size);
  13                 public void flush (uint flush);
  14                 public uint masked_scan_uint32 (uint32 mask, uint32 pattern, uint offset, uint size);
  15                 public uint masked_scan_uint32_peek (uint32 mask, uint32 pattern, uint offset, uint size, uint32 value);
  16                 [CCode (array_length = false)]
  17                 public unowned uchar[] peek (uint size);
  18                 public Gst.ClockTime prev_timestamp (uint64 distance);
  19                 public void push (owned Gst.Buffer buf);
  20                 public uchar take (uint nbytes);
  21                 public Gst.Buffer take_buffer (uint nbytes);
  22                 public unowned GLib.List take_list (uint nbytes);
  23         }
  24         [CCode (cheader_filename = "gst/gst.h")]
  25         public class BaseParse : Gst.Element {
  26                 public uint flags;
  27                 public weak Gst.Segment segment;
  28                 public weak Gst.Pad sinkpad;
  29                 public weak Gst.Pad srcpad;
  30                 [CCode (has_construct_function = false)]
  31                 protected BaseParse ();
  32                 public bool add_index_entry (uint64 offset, Gst.ClockTime ts, bool key, bool force);
  33                 [NoWrapper]
  34                 public virtual bool check_valid_frame (Gst.BaseParseFrame frame, uint framesize, int skipsize);
  35                 [NoWrapper]
  36                 public virtual bool convert (Gst.Format src_format, int64 src_value, Gst.Format dest_format, int64 dest_value);
  37                 public bool convert_default (Gst.Format src_format, int64 src_value, Gst.Format dest_format, int64 dest_value);
  38                 [NoWrapper]
  39                 public virtual bool event (Gst.Event event);
  40                 [NoWrapper]
  41                 public virtual Gst.FlowReturn parse_frame (Gst.BaseParseFrame frame);
  42                 [NoWrapper]
  43                 public virtual Gst.FlowReturn pre_push_frame (Gst.BaseParseFrame frame);
  44                 public Gst.FlowReturn push_frame (Gst.BaseParseFrame frame);
  45                 public void set_average_bitrate (uint bitrate);
  46                 public void set_duration (Gst.Format fmt, int64 duration, int interval);
  47                 public void set_frame_rate (uint fps_num, uint fps_den, uint lead_in, uint lead_out);
  48                 public void set_has_timing_info (bool has_timing);
  49                 public void set_latency (Gst.ClockTime min_latency, Gst.ClockTime max_latency);
  50                 public void set_min_frame_size (uint min_size);
  51                 public void set_passthrough (bool passthrough);
  52                 [NoWrapper]
  53                 public virtual bool set_sink_caps (Gst.Caps caps);
  54                 public void set_syncable (bool syncable);
  55                 [NoWrapper]
  56                 public virtual bool src_event (Gst.Event event);
  57                 [NoWrapper]
  58                 public virtual bool start ();
  59                 [NoWrapper]
  60                 public virtual bool stop ();
  61         }
  62         [CCode (cheader_filename = "gst/gst.h", type_id = "gst_base_parse_frame_get_type ()")]
  63         [Compact]
  64         public class BaseParseFrame {
  65                 public weak Gst.Buffer buffer;
  66                 public uint flags;
  67                 public int overhead;
  68                 [CCode (has_construct_function = false)]
  69                 public BaseParseFrame (Gst.Buffer buffer, Gst.BaseParseFrameFlags flags, int overhead);
  70                 public void init ();
  71         }
  72         [CCode (cheader_filename = "gst/base/gstbasesink.h")]
  73         public class BaseSink : Gst.Element {
  74                 public int buffers_queued;
  75                 public bool can_activate_pull;
  76                 public bool can_activate_push;
  77                 public Gst.ClockID clock_id;
  78                 public Gst.ClockTime end_time;
  79                 public bool eos;
  80                 public bool eos_queued;
  81                 public int events_queued;
  82                 public bool flushing;
  83                 public bool have_newsegment;
  84                 public bool have_preroll;
  85                 public bool need_preroll;
  86                 public uint64 offset;
  87                 public Gst.ActivateMode pad_mode;
  88                 public bool playing_async;
  89                 public GLib.Queue preroll_queue;
  90                 public int preroll_queue_max_len;
  91                 public int preroll_queued;
  92                 public Gst.Segment segment;
  93                 public Gst.Pad sinkpad;
  94                 [CCode (has_construct_function = false)]
  95                 protected BaseSink ();
  96                 [NoWrapper]
  97                 public virtual bool activate_pull (bool active);
  98                 [NoWrapper]
  99                 public virtual Gst.StateChangeReturn async_play ();
 100                 [NoWrapper]
 101                 public virtual Gst.FlowReturn buffer_alloc (uint64 offset, uint size, Gst.Caps caps, out unowned Gst.Buffer buf);
 102                 public Gst.FlowReturn do_preroll (Gst.MiniObject obj);
 103                 [NoWrapper]
 104                 public virtual bool event (Gst.Event event);
 105                 [NoWrapper]
 106                 public virtual void fixate (Gst.Caps caps);
 107                 public uint get_blocksize ();
 108                 [NoWrapper]
 109                 public virtual unowned Gst.Caps get_caps ();
 110                 public unowned Gst.Buffer get_last_buffer ();
 111                 public Gst.ClockTime get_latency ();
 112                 public int64 get_max_lateness ();
 113                 public Gst.ClockTime get_render_delay ();
 114                 public bool get_sync ();
 115                 public uint64 get_throttle_time ();
 116                 [NoWrapper]
 117                 public virtual void get_times (Gst.Buffer buffer, out Gst.ClockTime start, out Gst.ClockTime end);
 118                 public Gst.ClockTimeDiff get_ts_offset ();
 119                 public bool is_async_enabled ();
 120                 public bool is_last_buffer_enabled ();
 121                 public bool is_qos_enabled ();
 122                 [NoWrapper]
 123                 public virtual Gst.FlowReturn preroll (Gst.Buffer buffer);
 124                 public bool query_latency (bool live, bool upstream_live, out Gst.ClockTime min_latency, out Gst.ClockTime max_latency);
 125                 [NoWrapper]
 126                 public virtual Gst.FlowReturn render (Gst.Buffer buffer);
 127                 [NoWrapper]
 128                 public virtual Gst.FlowReturn render_list (Gst.BufferList buffer_list);
 129                 public void set_async_enabled (bool enabled);
 130                 public void set_blocksize (uint blocksize);
 131                 [NoWrapper]
 132                 public virtual bool set_caps (Gst.Caps caps);
 133                 public void set_last_buffer_enabled (bool enabled);
 134                 public void set_max_lateness (int64 max_lateness);
 135                 public void set_qos_enabled (bool enabled);
 136                 public void set_render_delay (Gst.ClockTime delay);
 137                 public void set_sync (bool sync);
 138                 public void set_throttle_time (uint64 throttle);
 139                 public void set_ts_offset (Gst.ClockTimeDiff offset);
 140                 [NoWrapper]
 141                 public virtual bool start ();
 142                 [NoWrapper]
 143                 public virtual bool stop ();
 144                 [NoWrapper]
 145                 public virtual bool unlock ();
 146                 [NoWrapper]
 147                 public virtual bool unlock_stop ();
 148                 public Gst.ClockReturn wait_clock (Gst.ClockTime time, out Gst.ClockTimeDiff jitter);
 149                 public Gst.FlowReturn wait_eos (Gst.ClockTime time, out Gst.ClockTimeDiff jitter);
 150                 public Gst.FlowReturn wait_preroll ();
 151                 [NoAccessorMethod]
 152                 public bool @async { get; set; }
 153                 public uint blocksize { get; set; }
 154                 [NoAccessorMethod]
 155                 public bool enable_last_buffer { get; set; }
 156                 public Gst.Buffer last_buffer { get; }
 157                 public int64 max_lateness { get; set; }
 158                 [NoAccessorMethod]
 159                 public uint preroll_queue_len { get; set construct; }
 160                 [NoAccessorMethod]
 161                 public bool qos { get; set; }
 162                 public uint64 render_delay { get; set; }
 163                 public bool sync { get; set; }
 164                 public uint64 throttle_time { get; set; }
 165                 public int64 ts_offset { get; set; }
 166         }
 167         [CCode (cheader_filename = "gst/base/gstbasesrc.h")]
 168         public class BaseSrc : Gst.Element {
 169                 public bool can_activate_push;
 170                 public Gst.ClockID clock_id;
 171                 public void* data;
 172                 public Gst.ClockTime end_time;
 173                 public GLib.Cond live_cond;
 174                 public GLib.Mutex live_lock;
 175                 public bool live_running;
 176                 public bool need_newsegment;
 177                 public int num_buffers_left;
 178                 public uint64 offset;
 179                 public Gst.ActivateMode pad_mode;
 180                 public bool random_access;
 181                 public bool seekable;
 182                 public Gst.Segment segment;
 183                 public uint64 size;
 184                 public Gst.Pad srcpad;
 185                 [CCode (has_construct_function = false)]
 186                 protected BaseSrc ();
 187                 [NoWrapper]
 188                 public virtual bool check_get_range ();
 189                 [NoWrapper]
 190                 public virtual Gst.FlowReturn create (uint64 offset, uint size, out unowned Gst.Buffer buf);
 191                 [NoWrapper]
 192                 public virtual bool do_seek (Gst.Segment segment);
 193                 [NoWrapper]
 194                 public virtual bool event (Gst.Event event);
 195                 [NoWrapper]
 196                 public virtual void fixate (Gst.Caps caps);
 197                 public ulong get_blocksize ();
 198                 [NoWrapper]
 199                 public virtual unowned Gst.Caps get_caps ();
 200                 public bool get_do_timestamp ();
 201                 [NoWrapper]
 202                 public virtual bool get_size (uint64 size);
 203                 [NoWrapper]
 204                 public virtual void get_times (Gst.Buffer buffer, out Gst.ClockTime start, out Gst.ClockTime end);
 205                 public bool is_live ();
 206                 [NoWrapper]
 207                 public virtual bool is_seekable ();
 208                 [NoWrapper]
 209                 public virtual bool negotiate ();
 210                 [NoWrapper]
 211                 public virtual bool newsegment ();
 212                 [NoWrapper]
 213                 public virtual bool prepare_seek_segment (Gst.Event seek, Gst.Segment segment);
 214                 [NoWrapper]
 215                 public virtual bool query (Gst.Query query);
 216                 public bool query_latency (bool live, out Gst.ClockTime min_latency, out Gst.ClockTime max_latency);
 217                 [CCode (has_construct_function = false, type = "gboolean")]
 218                 public BaseSrc.seamless_segment (Gst.BaseSrc src, int64 start, int64 stop, int64 position);
 219                 public void set_blocksize (ulong blocksize);
 220                 [NoWrapper]
 221                 public virtual bool set_caps (Gst.Caps caps);
 222                 public void set_do_timestamp (bool timestamp);
 223                 public void set_dynamic_size (bool @dynamic);
 224                 public void set_format (Gst.Format format);
 225                 public void set_live (bool live);
 226                 [NoWrapper]
 227                 public virtual bool start ();
 228                 [NoWrapper]
 229                 public virtual bool stop ();
 230                 [NoWrapper]
 231                 public virtual bool unlock ();
 232                 [NoWrapper]
 233                 public virtual bool unlock_stop ();
 234                 public Gst.FlowReturn wait_playing ();
 235                 public ulong blocksize { get; set; }
 236                 public bool do_timestamp { get; set; }
 237                 [NoAccessorMethod]
 238                 public int num_buffers { get; set; }
 239                 [NoAccessorMethod]
 240                 public bool typefind { get; set; }
 241         }
 242         [CCode (cheader_filename = "gst/base/gstbasetransform.h")]
 243         public class BaseTransform : Gst.Element {
 244                 public bool always_in_place;
 245                 public Gst.Caps cache_caps1;
 246                 public uint cache_caps1_size;
 247                 public Gst.Caps cache_caps2;
 248                 public uint cache_caps2_size;
 249                 public bool delay_configure;
 250                 public bool have_newsegment;
 251                 public bool have_same_caps;
 252                 public bool negotiated;
 253                 public bool passthrough;
 254                 public bool pending_configure;
 255                 public Gst.Segment segment;
 256                 public Gst.Pad sinkpad;
 257                 public Gst.Pad srcpad;
 258                 public GLib.Mutex transform_lock;
 259                 [CCode (cname = "GST_BASE_TRANSFORM_SINK_NAME")]
 260                 public const string SINK_NAME;
 261                 [CCode (cname = "GST_BASE_TRANSFORM_SRC_NAME")]
 262                 public const string SRC_NAME;
 263                 [CCode (has_construct_function = false)]
 264                 protected BaseTransform ();
 265                 [NoWrapper]
 266                 public virtual bool accept_caps (Gst.PadDirection direction, Gst.Caps caps);
 267                 [NoWrapper]
 268                 public virtual void before_transform (Gst.Buffer buffer);
 269                 [NoWrapper]
 270                 public virtual bool event (Gst.Event event);
 271                 [NoWrapper]
 272                 public virtual void fixate_caps (Gst.PadDirection direction, Gst.Caps caps, Gst.Caps othercaps);
 273                 [NoWrapper]
 274                 public virtual bool get_unit_size (Gst.Caps caps, out uint size);
 275                 public bool is_in_place ();
 276                 public bool is_passthrough ();
 277                 public bool is_qos_enabled ();
 278                 [NoWrapper]
 279                 public virtual Gst.FlowReturn prepare_output_buffer (Gst.Buffer input, int size, Gst.Caps caps, out unowned Gst.Buffer buf);
 280                 public void reconfigure ();
 281                 [NoWrapper]
 282                 public virtual bool set_caps (Gst.Caps incaps, Gst.Caps outcaps);
 283                 public void set_gap_aware (bool gap_aware);
 284                 public void set_in_place (bool in_place);
 285                 public void set_passthrough (bool passthrough);
 286                 public void set_qos_enabled (bool enabled);
 287                 [NoWrapper]
 288                 public virtual bool src_event (Gst.Event event);
 289                 [NoWrapper]
 290                 public virtual bool start ();
 291                 [NoWrapper]
 292                 public virtual bool stop ();
 293                 public void suggest (Gst.Caps caps, uint size);
 294                 [NoWrapper]
 295                 public virtual Gst.FlowReturn transform (Gst.Buffer inbuf, Gst.Buffer outbuf);
 296                 [NoWrapper]
 297                 public virtual Gst.Caps transform_caps (Gst.PadDirection direction, Gst.Caps caps);
 298                 [NoWrapper]
 299                 public virtual Gst.FlowReturn transform_ip (Gst.Buffer buf);
 300                 [NoWrapper]
 301                 public virtual bool transform_size (Gst.PadDirection direction, Gst.Caps caps, uint size, Gst.Caps othercaps, out uint othersize);
 302                 public void update_qos (double proportion, Gst.ClockTimeDiff diff, Gst.ClockTime timestamp);
 303                 [NoAccessorMethod]
 304                 public bool qos { get; set; }
 305         }
 306         [CCode (cheader_filename = "gst/base/gstbitreader.h")]
 307         [Compact]
 308         public class BitReader {
 309                 public uint bit;
 310                 public uint byte;
 311                 public uchar data;
 312                 public uint size;
 313                 [CCode (has_construct_function = false)]
 314                 public BitReader (uchar data, uint size);
 315                 [CCode (has_construct_function = false)]
 316                 public BitReader.from_buffer (Gst.Buffer buffer);
 317                 public bool get_bits_uint16 (out uint16 val, uint nbits);
 318                 public bool get_bits_uint32 (out uint32 val, uint nbits);
 319                 public bool get_bits_uint64 (out uint64 val, uint nbits);
 320                 public bool get_bits_uint8 (out uchar val, uint nbits);
 321                 public uint get_pos ();
 322                 public uint get_remaining ();
 323                 public uint get_size ();
 324                 public void init (uchar data, uint size);
 325                 public void init_from_buffer (Gst.Buffer buffer);
 326                 public bool peek_bits_uint16 (out uint16 val, uint nbits);
 327                 public bool peek_bits_uint32 (out uint32 val, uint nbits);
 328                 public bool peek_bits_uint64 (out uint64 val, uint nbits);
 329                 public bool peek_bits_uint8 (out uchar val, uint nbits);
 330                 public bool set_pos (uint pos);
 331                 public bool skip (uint nbits);
 332                 public bool skip_to_byte ();
 333         }
 334         [CCode (cheader_filename = "gst/base/gstbytereader.h")]
 335         [Compact]
 336         public class ByteReader {
 337                 public uint byte;
 338                 public uchar data;
 339                 public uint size;
 340                 [CCode (has_construct_function = false)]
 341                 public ByteReader (uchar data, uint size);
 342                 public bool dup_data (uint size, uchar val);
 343                 public bool dup_string_utf16 (uint16 str);
 344                 public bool dup_string_utf32 (uint32 str);
 345                 public bool dup_string_utf8 (string str);
 346                 [CCode (has_construct_function = false)]
 347                 public ByteReader.from_buffer (Gst.Buffer buffer);
 348                 public bool get_data (uint size, out uchar val);
 349                 public bool get_float32_be (out float val);
 350                 public bool get_float32_le (out float val);
 351                 public bool get_float64_be (out double val);
 352                 public bool get_float64_le (out double val);
 353                 public bool get_int16_be (out int16 val);
 354                 public bool get_int16_le (out int16 val);
 355                 public bool get_int24_be (out int32 val);
 356                 public bool get_int24_le (out int32 val);
 357                 public bool get_int32_be (out int32 val);
 358                 public bool get_int32_le (out int32 val);
 359                 public bool get_int64_be (out int64 val);
 360                 public bool get_int64_le (out int64 val);
 361                 public bool get_int8 (out char val);
 362                 public uint get_pos ();
 363                 public uint get_remaining ();
 364                 public uint get_size ();
 365                 public bool get_string_utf8 (string str);
 366                 public bool get_uint16_be (out uint16 val);
 367                 public bool get_uint16_le (out uint16 val);
 368                 public bool get_uint24_be (out uint32 val);
 369                 public bool get_uint24_le (out uint32 val);
 370                 public bool get_uint32_be (out uint32 val);
 371                 public bool get_uint32_le (out uint32 val);
 372                 public bool get_uint64_be (out uint64 val);
 373                 public bool get_uint64_le (out uint64 val);
 374                 public bool get_uint8 (out uchar val);
 375                 public void init (uchar data, uint size);
 376                 public void init_from_buffer (Gst.Buffer buffer);
 377                 public uint masked_scan_uint32 (uint32 mask, uint32 pattern, uint offset, uint size);
 378                 public bool peek_data (uint size, out uchar val);
 379                 public bool peek_float32_be (out float val);
 380                 public bool peek_float32_le (out float val);
 381                 public bool peek_float64_be (out double val);
 382                 public bool peek_float64_le (out double val);
 383                 public bool peek_int16_be (out int16 val);
 384                 public bool peek_int16_le (out int16 val);
 385                 public bool peek_int24_be (out int32 val);
 386                 public bool peek_int24_le (out int32 val);
 387                 public bool peek_int32_be (out int32 val);
 388                 public bool peek_int32_le (out int32 val);
 389                 public bool peek_int64_be (out int64 val);
 390                 public bool peek_int64_le (out int64 val);
 391                 public bool peek_int8 (out char val);
 392                 public bool peek_string_utf8 (string str);
 393                 public bool peek_uint16_be (out uint16 val);
 394                 public bool peek_uint16_le (out uint16 val);
 395                 public bool peek_uint24_be (out uint32 val);
 396                 public bool peek_uint24_le (out uint32 val);
 397                 public bool peek_uint32_be (out uint32 val);
 398                 public bool peek_uint32_le (out uint32 val);
 399                 public bool peek_uint64_be (out uint64 val);
 400                 public bool peek_uint64_le (out uint64 val);
 401                 public bool peek_uint8 (out uchar val);
 402                 public bool set_pos (uint pos);
 403                 public bool skip (uint nbytes);
 404                 public bool skip_string_utf16 ();
 405                 public bool skip_string_utf32 ();
 406                 public bool skip_string_utf8 ();
 407         }
 408         [CCode (cheader_filename = "gst/base/gstbytewriter.h")]
 409         public class ByteWriter : Gst.ByteReader {
 410                 public uint alloc_size;
 411                 public bool fixed;
 412                 public bool @owned;
 413                 [CCode (has_construct_function = false)]
 414                 public ByteWriter ();
 415                 public bool ensure_free_space (uint size);
 416                 public bool fill (uchar value, uint size);
 417                 public unowned Gst.Buffer free_and_get_buffer ();
 418                 public uchar free_and_get_data ();
 419                 public uint get_remaining ();
 420                 public void init ();
 421                 public void init_with_buffer (Gst.Buffer buffer, bool initialized);
 422                 public void init_with_data (uchar data, uint size, bool initialized);
 423                 public void init_with_size (uint size, bool fixed);
 424                 public bool put_data (uchar data, uint size);
 425                 public bool put_float32_be (float val);
 426                 public bool put_float32_le (float val);
 427                 public bool put_float64_be (double val);
 428                 public bool put_float64_le (double val);
 429                 public bool put_int16_be (int16 val);
 430                 public bool put_int16_le (int16 val);
 431                 public bool put_int24_be (int32 val);
 432                 public bool put_int24_le (int32 val);
 433                 public bool put_int32_be (int32 val);
 434                 public bool put_int32_le (int32 val);
 435                 public bool put_int64_be (int64 val);
 436                 public bool put_int64_le (int64 val);
 437                 public bool put_int8 (char val);
 438                 public bool put_string_utf16 (uint16 data);
 439                 public bool put_string_utf32 (uint32 data);
 440                 public bool put_string_utf8 (string data);
 441                 public bool put_uint16_be (uint16 val);
 442                 public bool put_uint16_le (uint16 val);
 443                 public bool put_uint24_be (uint32 val);
 444                 public bool put_uint24_le (uint32 val);
 445                 public bool put_uint32_be (uint32 val);
 446                 public bool put_uint32_le (uint32 val);
 447                 public bool put_uint64_be (uint64 val);
 448                 public bool put_uint64_le (uint64 val);
 449                 public bool put_uint8 (uchar val);
 450                 public void reset ();
 451                 public unowned Gst.Buffer reset_and_get_buffer ();
 452                 public uchar reset_and_get_data ();
 453                 [CCode (has_construct_function = false)]
 454                 public ByteWriter.with_buffer (Gst.Buffer buffer, bool initialized);
 455                 [CCode (has_construct_function = false)]
 456                 public ByteWriter.with_data (uchar data, uint size, bool initialized);
 457                 [CCode (has_construct_function = false)]
 458                 public ByteWriter.with_size (uint size, bool fixed);
 459         }
 460         [CCode (cheader_filename = "gst/base/gstcollectpads.h")]
 461         [Compact]
 462         public class CollectData {
 463                 public Gst.Buffer buffer;
 464                 public weak Gst.CollectPads collect;
 465                 public Gst.Pad pad;
 466                 public uint pos;
 467                 public weak Gst.Segment segment;
 468         }
 469         [CCode (cheader_filename = "gst/base/gstcollectpads.h")]
 470         public class CollectPads : Gst.Object {
 471                 public weak GLib.Cond cond;
 472                 public uint32 cookie;
 473                 public weak GLib.SList<Gst.CollectData> data;
 474                 public uint eospads;
 475                 public weak Gst.CollectPadsFunction func;
 476                 public uint numpads;
 477                 public uint queuedpads;
 478                 public bool started;
 479                 public void* user_data;
 480                 [CCode (has_construct_function = false)]
 481                 public CollectPads ();
 482                 public unowned Gst.CollectData add_pad (Gst.Pad pad, uint size);
 483                 public unowned Gst.CollectData add_pad_full (Gst.Pad pad, uint size, Gst.CollectDataDestroyNotify destroy_notify);
 484                 public uint available ();
 485                 public Gst.FlowReturn collect ();
 486                 public Gst.FlowReturn collect_range (uint64 offset, uint length);
 487                 public uint flush (Gst.CollectData data, uint size);
 488                 public bool is_active (Gst.Pad pad);
 489                 public unowned Gst.Buffer peek (Gst.CollectData data);
 490                 public unowned Gst.Buffer pop (Gst.CollectData data);
 491                 public uint read (Gst.CollectData data, uchar bytes, uint size);
 492                 public unowned Gst.Buffer read_buffer (Gst.CollectData data, uint size);
 493                 public bool remove_pad (Gst.Pad pad);
 494                 public void set_clip_function (Gst.CollectPadsClipFunction clipfunc);
 495                 public void set_flushing (bool flushing);
 496                 public void set_function (Gst.CollectPadsFunction func);
 497                 public void start ();
 498                 public void stop ();
 499                 public Gst.Buffer take_buffer (Gst.CollectData data, uint size);
 500         }
 501         [CCode (cheader_filename = "gst/base/gstdataqueue.h")]
 502         public class DataQueue : GLib.Object {
 503                 public void* abidata;
 504                 public void* checkdata;
 505                 public weak Gst.DataQueueCheckFullFunction checkfull;
 506                 public weak Gst.DataQueueSize cur_level;
 507                 public weak Gst.DataQueueEmptyCallback emptycallback;
 508                 public bool flushing;
 509                 public weak Gst.DataQueueFullCallback fullcallback;
 510                 public weak GLib.Cond item_add;
 511                 public weak GLib.Cond item_del;
 512                 public weak GLib.Mutex qlock;
 513                 public weak GLib.Queue queue;
 514                 [CCode (has_construct_function = false)]
 515                 public DataQueue (Gst.DataQueueCheckFullFunction checkfull, void* checkdata);
 516                 public bool drop_head (GLib.Type type);
 517                 public void flush ();
 518                 public void get_level (Gst.DataQueueSize level);
 519                 public bool is_empty ();
 520                 public bool is_full ();
 521                 public void limits_changed ();
 522                 [CCode (cname = "gst_data_queue_new_full", has_construct_function = false)]
 523                 public DataQueue.new_with_callbacks (Gst.DataQueueCheckFullFunction checkfull, Gst.DataQueueFullCallback fullcallback, Gst.DataQueueEmptyCallback emptycallback, void* checkdata);
 524                 public bool pop (out unowned Gst.DataQueueItem item);
 525                 public bool push (Gst.DataQueueItem item);
 526                 public void set_flushing (bool flushing);
 527                 [NoAccessorMethod]
 528                 public uint current_level_bytes { get; }
 529                 [NoAccessorMethod]
 530                 public uint64 current_level_time { get; }
 531                 [NoAccessorMethod]
 532                 public uint current_level_visible { get; }
 533                 public virtual signal void empty ();
 534                 public virtual signal void full ();
 535         }
 536         [CCode (cheader_filename = "gst/base/gstdataqueue.h")]
 537         [Compact]
 538         public class DataQueueItem {
 539                 public weak GLib.DestroyNotify destroy;
 540                 public uint64 duration;
 541                 public weak Gst.MiniObject object;
 542                 public uint size;
 543                 public bool visible;
 544         }
 545         [CCode (cheader_filename = "gst/base/gstdataqueue.h")]
 546         [Compact]
 547         public class DataQueueSize {
 548                 public uint bytes;
 549                 public uint64 time;
 550                 public uint visible;
 551         }
 552         [CCode (cheader_filename = "gst/base/gstpushsrc.h")]
 553         public class PushSrc : Gst.BaseSrc {
 554                 [CCode (has_construct_function = false)]
 555                 protected PushSrc ();
 556                 [NoWrapper]
 557                 public virtual Gst.FlowReturn create (out Gst.Buffer buf);
 558         }
 559         [CCode (cheader_filename = "gst/gst.h", cprefix = "GST_BASE_PARSE_FRAME_FLAG_", has_type_id = false)]
 560         public enum BaseParseFrameFlags {
 561                 NONE,
 562                 NO_FRAME,
 563                 CLIP
 564         }
 565         [CCode (cheader_filename = "gst/base/gstbasesrc.h", cprefix = "GST_BASE_SRC_", has_type_id = false)]
 566         public enum BaseSrcFlags {
 567                 STARTED,
 568                 FLAG_LAST
 569         }
 570         [CCode (cheader_filename = "gst/base/gstcollectpads.h")]
 571         public delegate void CollectDataDestroyNotify ();
 572         [CCode (cheader_filename = "gst/base/gstcollectpads.h")]
 573         public delegate unowned Gst.Buffer CollectPadsClipFunction (Gst.CollectPads pads, Gst.CollectData data, Gst.Buffer buffer);
 574         [CCode (cheader_filename = "gst/base/gstcollectpads.h")]
 575         public delegate Gst.FlowReturn CollectPadsFunction (Gst.CollectPads pads);
 576         [CCode (cheader_filename = "gst/base/gstdataqueue.h", has_target = false)]
 577         public delegate bool DataQueueCheckFullFunction (Gst.DataQueue queue, uint visible, uint bytes, uint64 time, void* checkdata);
 578         [CCode (cheader_filename = "gst/base/gstdataqueue.h", has_target = false)]
 579         public delegate void DataQueueEmptyCallback (Gst.DataQueue queue, void* checkdata);
 580         [CCode (cheader_filename = "gst/base/gstdataqueue.h", has_target = false)]
 581         public delegate void DataQueueFullCallback (Gst.DataQueue queue, void* checkdata);
 582         [CCode (cheader_filename = "gst/base/gsttypefindhelper.h", has_target = false)]
 583         public delegate Gst.FlowReturn TypeFindHelperGetRangeFunction (Gst.Object obj, uint64 offset, uint length, out unowned Gst.Buffer buffer);
 584         [CCode (cheader_filename = "gst/gst.h")]
 585         public const int BASE_PARSE_FLAG_DRAINING;
 586         [CCode (cheader_filename = "gst/gst.h")]
 587         public const int BASE_PARSE_FLAG_LOST_SYNC;
 588         [CCode (cheader_filename = "gst/base/gsttypefindhelper.h")]
 589         public static unowned Gst.Caps type_find_helper (Gst.Pad src, uint64 size);
 590         [CCode (cheader_filename = "gst/base/gsttypefindhelper.h")]
 591         public static unowned Gst.Caps type_find_helper_for_buffer (Gst.Object obj, Gst.Buffer buf, Gst.TypeFindProbability prob);
 592         [CCode (cheader_filename = "gst/base/gsttypefindhelper.h")]
 593         public static Gst.Caps type_find_helper_for_extension (Gst.Object obj, string extension);
 594         [CCode (cheader_filename = "gst/base/gsttypefindhelper.h")]
 595         public static unowned Gst.Caps type_find_helper_get_range (Gst.Object obj, Gst.TypeFindHelperGetRangeFunction func, uint64 size, Gst.TypeFindProbability prob);
 596         [CCode (cheader_filename = "gst/base/gsttypefindhelper.h")]
 597         public static unowned Gst.Caps type_find_helper_get_range_ext (Gst.Object obj, Gst.TypeFindHelperGetRangeFunction func, uint64 size, string extension, Gst.TypeFindProbability prob);
 598 }