From d178fff215c5ce05df0ead5d9523ad67b7c7c375 Mon Sep 17 00:00:00 2001 From: Johan Dahlin Date: Mon, 23 Feb 2004 20:24:53 +0000 Subject: [PATCH] gstreamer/gstreamer.defs (element_link_many): This is function and not a method, despite popular belief Original commit message from CVS: * gstreamer/gstreamer.defs (element_link_many): This is function and not a method, despite popular belief (gst_element_factory_make): Make it the constructor of GstElement, so we can avoid dirty hacks. * gstreamer/gstreamer.override (_wrap_gst_element_link_many): Wrap (_wrap_gst_element_link_many): Wrap * gstreamer/common.defs: * gstreamer/common.override: * gstreamer/Makefile.am: Beginning of reorganization, to include gstreamer.defs and override (eg, not auto generate them) * examples/gstreamer/cp.py: Prettify and pythonify. Will do the other examples later * gstreamer/gstreamer.py: Backwards compatibility module * gstreamer/gstreamermodule.c: * gstreamer/Makefile.am: Rename the module to gst --- ChangeLog | 16 + examples/gst/cp.py | 89 +- examples/gstreamer/cp.py | 89 +- gst/Makefile.am | 17 +- gst/common.defs | 14 +- gst/common.override | 36 + gst/gst.defs | 6968 +++++++++++++++++++++++++++++++++++++ gst/gstreamer.defs | 6968 +++++++++++++++++++++++++++++++++++++ gstreamer/Makefile.am | 17 +- gstreamer/common.defs | 14 +- gstreamer/common.override | 36 + gstreamer/gst.defs | 6968 +++++++++++++++++++++++++++++++++++++ gstreamer/gstreamer.defs | 6968 +++++++++++++++++++++++++++++++++++++ 13 files changed, 28042 insertions(+), 158 deletions(-) create mode 100644 gst/gst.defs create mode 100644 gst/gstreamer.defs create mode 100644 gstreamer/gst.defs create mode 100644 gstreamer/gstreamer.defs diff --git a/ChangeLog b/ChangeLog index 171e0bd2d5..d44422822d 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,21 @@ 2004-02-23 Johan Dahlin + * gstreamer/gstreamer.defs (element_link_many): This is function + and not a method, despite popular belief + (gst_element_factory_make): Make it the constructor of GstElement, + so we can avoid dirty hacks. + + * gstreamer/gstreamer.override (_wrap_gst_element_link_many): Wrap + (_wrap_gst_element_link_many): Wrap + + * gstreamer/common.defs: + * gstreamer/common.override: + * gstreamer/Makefile.am: Beginning of reorganization, to include + gstreamer.defs and override (eg, not auto generate them) + + * examples/gstreamer/cp.py: Prettify and pythonify. Will do the + other examples later + * gstreamer/gstreamer.py: Backwards compatibility module * gstreamer/gstreamermodule.c: diff --git a/examples/gst/cp.py b/examples/gst/cp.py index b328ffa198..0b82c59e6e 100755 --- a/examples/gst/cp.py +++ b/examples/gst/cp.py @@ -1,7 +1,8 @@ #!/usr/bin/env python # # gst-python -# Copyright (C) 2002 David I. Lehn +# Copyright (C) 2002 David I. Lehn +# 2004 Johan Dahlin # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -22,63 +23,45 @@ # import sys -from gstreamer import * -from gobject import GObject +import gst -def update(sender, *args): - print sender.get_name(), args - -def filter(filters): +def filter(input, output): "A GStreamer copy pipeline which can add arbitrary filters" - if len(sys.argv) != 3: + # create a new bin to hold the elements + bin = gst.Pipeline('pipeline') + + filesrc = gst.Element('filesrc', 'source'); + filesrc.set_property('location', input) + + stats = gst.Element('statistics', 'stats'); + stats.set_property('silent', False) + stats.set_property('buffer_update_freq', True) + stats.set_property('update_on_eos', True) + + filesink = gst.Element('filesink', 'sink') + filesink.set_property('location', output) + + bin.add_many(filesrc, stats, filesink) + gst.element_link_many(filesrc, stats, filesink) + + # start playing + bin.set_state(gst.STATE_PLAYING); + + while bin.iterate(): + pass + + # stop the bin + bin.set_state(gst.STATE_NULL) + +def main(args): + "A GStreamer based cp(1) with stats" + + if len(args) != 3: print 'usage: %s source dest' % (sys.argv[0]) return -1 - # create a new bin to hold the elements - bin = Pipeline('pipeline') - - filesrc = Element('filesrc', 'source'); - filesrc.set_property('location', sys.argv[1]) - - filesink = Element('filesink', 'sink') - filesink.set_property('location', sys.argv[2]) - - elements = [filesrc] + filters + [filesink] - # add objects to the main pipeline - for e in elements: - bin.add(e) - - # link the elements - previous = None - for e in elements: - if previous: - previous.link(e) - previous = e - - # start playing - bin.set_state(STATE_PLAYING); - - while bin.iterate(): pass - - # stop the bin - bin.set_state(STATE_NULL) - - return 0 - -def main(): - "A GStreamer based cp(1) with stats" - #gst_info_set_categories(-1) - #gst_debug_set_categories(-1) - - stats = Element ('statistics', 'stats'); - stats.set_property('silent', 0) - stats.set_property('buffer_update_freq', 1) - stats.set_property('update_on_eos', 1) - #stats.connect('update', update) - - return filter([stats]) + return filter(args[1], args[2]) if __name__ == '__main__': - ret = main() - sys.exit (ret) + sys.exit(main(sys.argv)) diff --git a/examples/gstreamer/cp.py b/examples/gstreamer/cp.py index b328ffa198..0b82c59e6e 100755 --- a/examples/gstreamer/cp.py +++ b/examples/gstreamer/cp.py @@ -1,7 +1,8 @@ #!/usr/bin/env python # # gst-python -# Copyright (C) 2002 David I. Lehn +# Copyright (C) 2002 David I. Lehn +# 2004 Johan Dahlin # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -22,63 +23,45 @@ # import sys -from gstreamer import * -from gobject import GObject +import gst -def update(sender, *args): - print sender.get_name(), args - -def filter(filters): +def filter(input, output): "A GStreamer copy pipeline which can add arbitrary filters" - if len(sys.argv) != 3: + # create a new bin to hold the elements + bin = gst.Pipeline('pipeline') + + filesrc = gst.Element('filesrc', 'source'); + filesrc.set_property('location', input) + + stats = gst.Element('statistics', 'stats'); + stats.set_property('silent', False) + stats.set_property('buffer_update_freq', True) + stats.set_property('update_on_eos', True) + + filesink = gst.Element('filesink', 'sink') + filesink.set_property('location', output) + + bin.add_many(filesrc, stats, filesink) + gst.element_link_many(filesrc, stats, filesink) + + # start playing + bin.set_state(gst.STATE_PLAYING); + + while bin.iterate(): + pass + + # stop the bin + bin.set_state(gst.STATE_NULL) + +def main(args): + "A GStreamer based cp(1) with stats" + + if len(args) != 3: print 'usage: %s source dest' % (sys.argv[0]) return -1 - # create a new bin to hold the elements - bin = Pipeline('pipeline') - - filesrc = Element('filesrc', 'source'); - filesrc.set_property('location', sys.argv[1]) - - filesink = Element('filesink', 'sink') - filesink.set_property('location', sys.argv[2]) - - elements = [filesrc] + filters + [filesink] - # add objects to the main pipeline - for e in elements: - bin.add(e) - - # link the elements - previous = None - for e in elements: - if previous: - previous.link(e) - previous = e - - # start playing - bin.set_state(STATE_PLAYING); - - while bin.iterate(): pass - - # stop the bin - bin.set_state(STATE_NULL) - - return 0 - -def main(): - "A GStreamer based cp(1) with stats" - #gst_info_set_categories(-1) - #gst_debug_set_categories(-1) - - stats = Element ('statistics', 'stats'); - stats.set_property('silent', 0) - stats.set_property('buffer_update_freq', 1) - stats.set_property('update_on_eos', 1) - #stats.connect('update', update) - - return filter([stats]) + return filter(args[1], args[2]) if __name__ == '__main__': - ret = main() - sys.exit (ret) + sys.exit(main(sys.argv)) diff --git a/gst/Makefile.am b/gst/Makefile.am index b2c83e8d81..e81eb16654 100644 --- a/gst/Makefile.am +++ b/gst/Makefile.am @@ -42,26 +42,17 @@ _gstmodule_la_SOURCES = \ _gstmodule_la_CFLAGS = $(GST_CFLAGS) -fno-strict-aliasing _gstmodule_la_LIBADD = $(GST_LIBS) _gstmodule_la_LDFLAGS = -module -avoid-version -export-symbols-regex init_gst -nodist__gstmodule_la_SOURCES = gstreamer.c +nodist__gstmodule_la_SOURCES = $(MODULE).c -CLEANFILES = $(MODULE).c h2def.defs $(MODULE).defs $(MODULE).override -EXTRA_DIST = $(GST_OVERRIDES) $(GST_DEFS) $(GST_CODE) arg-types.py +CLEANFILES = $(MODULE).c +EXTRA_DIST = $(MODULE).defs $(GST_OVERRIDES) $(GST_DEFS) $(GST_CODE) arg-types.py GST_EXCLUDE_INCLUDES=\ $(GST_INCLUDEDIR)/gst/gstatomic_impl.h \ $(GST_INCLUDEDIR)/gst/gstcompat.h GST_INCLUDES=$(filter-out $(GST_EXCLUDE_INCLUDES),$(wildcard $(GST_INCLUDEDIR)/gst/*.h)) -gstreamer.override: common.override $(GST_MAJORMINOR).override - cat $+ > $@ - -h2def.defs: $(GST_INCLUDES) - $(PYTHON) $(PYGTK_H2DEF) $(GST_INCLUDES) > $@ - -gstreamer.defs: h2def.defs common.defs $(GST_MAJORMINOR).defs - cat $+ > $@ - -gstreamer.c: $(MODULE).defs arg-types.py $(MODULE).override +gstreamer.c: $(srcdir)/$(MODULE).defs $(srcdir)/arg-types.py $(srcdir)/$(MODULE).override $(PYGTK_CODEGEN) \ --load-types $(srcdir)/arg-types.py \ --override $(srcdir)/$(MODULE).override \ diff --git a/gst/common.defs b/gst/common.defs index 11117cd603..8215a6a158 100644 --- a/gst/common.defs +++ b/gst/common.defs @@ -1,3 +1,4 @@ +;; -*- scheme -*- ;; ;; Boxed types ;; @@ -67,17 +68,4 @@ ) ) -;; -;; Element constructor override; uses a nonexistant make_element -;; which is defined in gstreamer.overrides -;; -(define-function gst_element_factory_make_element - (is-constructor-of "GstElement") - (c-name "gst_element_factory_make_element") - (return-type "GstElement*") - (parameters - '("const-gchar*" "elementname") - '("const-gchar*" "name") - ) -) diff --git a/gst/common.override b/gst/common.override index 8dfb39dd9b..be4491fe2a 100644 --- a/gst/common.override +++ b/gst/common.override @@ -369,3 +369,39 @@ _wrap_gst_version(void) return Py_BuildValue("(iii)", major, minor, micro); } +%% +override gst_bin_add_many args +static PyObject * +_wrap_gst_bin_add_many(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + PyGObject *element; + int i; + int len; + + len = PyList_Size(args); + if (len == 0) + { + PyErr_SetString(PyExc_TypeError, "GstBin.add requires at least one argument"); + return NULL; + } + + + for (i = 0; i < len; i++) + { + element = (PyGObject*)PyList_GetItem(args, i); + if (!pygobject_check(element, &PyGstElement_Type)) + { + PyErr_SetString(PyExc_TypeError, "argument must be a GstElement"); + return NULL; + } + } + + for (i = 0; i < len; i++) + { + element = (PyGObject*)PyList_GetItem(args, i); + gst_bin_add(GST_BIN(self->obj), GST_ELEMENT(element->obj)); + } + + Py_INCREF(Py_None); + return Py_None; +} diff --git a/gst/gst.defs b/gst/gst.defs new file mode 100644 index 0000000000..0dafc62c87 --- /dev/null +++ b/gst/gst.defs @@ -0,0 +1,6968 @@ +;; -*- scheme -*- +; object definitions ... +(define-object Object + (in-module "Gst") + (parent "GObject") + (c-name "GstObject") + (gtype-id "GST_TYPE_OBJECT") +) + +(define-object Index + (in-module "Gst") + (parent "GstObject") + (c-name "GstIndex") + (gtype-id "GST_TYPE_INDEX") +) + +(define-object Element + (in-module "Gst") + (parent "GstObject") + (c-name "GstElement") + (gtype-id "GST_TYPE_ELEMENT") +) + +(define-object Bin + (in-module "Gst") + (parent "GstElement") + (c-name "GstBin") + (gtype-id "GST_TYPE_BIN") +) + +(define-object Clock + (in-module "Gst") + (parent "GstObject") + (c-name "GstClock") + (gtype-id "GST_TYPE_CLOCK") +) + +(define-object Pad + (in-module "Gst") + (parent "GstObject") + (c-name "GstPad") + (gtype-id "GST_TYPE_PAD") +) + +(define-object GhostPad + (in-module "Gst") + (parent "GstPad") + (c-name "GstGhostPad") + (gtype-id "GST_TYPE_GHOST_PAD") +) + +(define-object PadTemplate + (in-module "Gst") + (parent "GstObject") + (c-name "GstPadTemplate") + (gtype-id "GST_TYPE_PAD_TEMPLATE") +) + +(define-object Pipeline + (in-module "Gst") + (parent "GstBin") + (c-name "GstPipeline") + (gtype-id "GST_TYPE_PIPELINE") +) + +(define-object PluginFeature + (in-module "Gst") + (parent "GObject") + (c-name "GstPluginFeature") + (gtype-id "GST_TYPE_PLUGIN_FEATURE") +) + +(define-object IndexFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstIndexFactory") + (gtype-id "GST_TYPE_INDEX_FACTORY") +) + +(define-object ElementFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstElementFactory") + (gtype-id "GST_TYPE_ELEMENT_FACTORY") +) + +(define-object Queue + (in-module "Gst") + (parent "GstElement") + (c-name "GstQueue") + (gtype-id "GST_TYPE_QUEUE") +) + +(define-object RealPad + (in-module "Gst") + (parent "GstPad") + (c-name "GstRealPad") + (gtype-id "GST_TYPE_REAL_PAD") +) + +(define-object Registry + (in-module "Gst") + (parent "GObject") + (c-name "GstRegistry") + (gtype-id "GST_TYPE_REGISTRY") +) + +(define-object Scheduler + (in-module "Gst") + (parent "GstObject") + (c-name "GstScheduler") + (gtype-id "GST_TYPE_SCHEDULER") +) + +(define-object SchedulerFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstSchedulerFactory") + (gtype-id "GST_TYPE_SCHEDULER_FACTORY") +) + +(define-object SystemClock + (in-module "Gst") + (parent "GstClock") + (c-name "GstSystemClock") + (gtype-id "GST_TYPE_SYSTEM_CLOCK") +) + +(define-object Thread + (in-module "Gst") + (parent "GstBin") + (c-name "GstThread") + (gtype-id "GST_TYPE_THREAD") +) + +(define-object TypeFindFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstTypeFindFactory") + (gtype-id "GST_TYPE_TYPE_FIND_FACTORY") +) + +(define-object XML + (in-module "Gst") + (parent "GstObject") + (c-name "GstXML") + (gtype-id "GST_TYPE_XML") +) + +;; Enumerations and flags ... + +(define-enum BinFlags + (in-module "Gst") + (c-name "GstBinFlags") + (gtype-id "GST_TYPE_BIN_FLAGS") + (values + '("flag-manager" "GST_BIN_FLAG_MANAGER") + '("self-schedulable" "GST_BIN_SELF_SCHEDULABLE") + '("flag-prefer-cothreads" "GST_BIN_FLAG_PREFER_COTHREADS") + '("flag-fixed-clock" "GST_BIN_FLAG_FIXED_CLOCK") + '("flag-last" "GST_BIN_FLAG_LAST") + ) +) + +(define-enum BufferFlag + (in-module "Gst") + (c-name "GstBufferFlag") + (gtype-id "GST_TYPE_BUFFER_FLAG") + (values + '("readonly" "GST_BUFFER_READONLY") + '("subbuffer" "GST_BUFFER_SUBBUFFER") + '("original" "GST_BUFFER_ORIGINAL") + '("dontfree" "GST_BUFFER_DONTFREE") + '("key-unit" "GST_BUFFER_KEY_UNIT") + '("dontkeep" "GST_BUFFER_DONTKEEP") + '("flag-last" "GST_BUFFER_FLAG_LAST") + ) +) + +(define-enum ClockEntryStatus + (in-module "Gst") + (c-name "GstClockEntryStatus") + (gtype-id "GST_TYPE_CLOCK_ENTRY_STATUS") + (values + '("ok" "GST_CLOCK_ENTRY_OK") + '("early" "GST_CLOCK_ENTRY_EARLY") + '("restart" "GST_CLOCK_ENTRY_RESTART") + ) +) + +(define-enum ClockEntryType + (in-module "Gst") + (c-name "GstClockEntryType") + (gtype-id "GST_TYPE_CLOCK_ENTRY_TYPE") + (values + '("single" "GST_CLOCK_ENTRY_SINGLE") + '("periodic" "GST_CLOCK_ENTRY_PERIODIC") + ) +) + +(define-enum ClockReturn + (in-module "Gst") + (c-name "GstClockReturn") + (gtype-id "GST_TYPE_CLOCK_RETURN") + (values + '("stopped" "GST_CLOCK_STOPPED") + '("timeout" "GST_CLOCK_TIMEOUT") + '("early" "GST_CLOCK_EARLY") + '("error" "GST_CLOCK_ERROR") + '("unsupported" "GST_CLOCK_UNSUPPORTED") + ) +) + +(define-flags ClockFlags + (in-module "Gst") + (c-name "GstClockFlags") + (gtype-id "GST_TYPE_CLOCK_FLAGS") + (values + '("do-single-sync" "GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC") + '("do-single-async" "GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC") + '("do-periodic-sync" "GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC") + '("do-periodic-async" "GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC") + '("set-resolution" "GST_CLOCK_FLAG_CAN_SET_RESOLUTION") + '("set-speed" "GST_CLOCK_FLAG_CAN_SET_SPEED") + ) +) + +(define-flags CPUFlags + (in-module "Gst") + (c-name "GstCPUFlags") + (gtype-id "GST_TYPE_CPU_FLAGS") + (values + '("mmx" "GST_CPU_FLAG_MMX") + '("sse" "GST_CPU_FLAG_SSE") + '("mmxext" "GST_CPU_FLAG_MMXEXT") + '("3dnow" "GST_CPU_FLAG_3DNOW") + ) +) + +(define-enum DataFlags + (in-module "Gst") + (c-name "GstDataFlags") + (gtype-id "GST_TYPE_DATA_FLAGS") + (values + '("readonly" "GST_DATA_READONLY") + '("flag-last" "GST_DATA_FLAG_LAST") + ) +) + +(define-enum ElementFlags + (in-module "Gst") + (c-name "GstElementFlags") + (gtype-id "GST_TYPE_ELEMENT_FLAGS") + (values + '("complex" "GST_ELEMENT_COMPLEX") + '("decoupled" "GST_ELEMENT_DECOUPLED") + '("thread-suggested" "GST_ELEMENT_THREAD_SUGGESTED") + '("infinite-loop" "GST_ELEMENT_INFINITE_LOOP") + '("new-loopfunc" "GST_ELEMENT_NEW_LOOPFUNC") + '("event-aware" "GST_ELEMENT_EVENT_AWARE") + '("use-threadsafe-properties" "GST_ELEMENT_USE_THREADSAFE_PROPERTIES") + '("scheduler-private1" "GST_ELEMENT_SCHEDULER_PRIVATE1") + '("scheduler-private2" "GST_ELEMENT_SCHEDULER_PRIVATE2") + '("locked-state" "GST_ELEMENT_LOCKED_STATE") + '("in-error" "GST_ELEMENT_IN_ERROR") + '("flag-last" "GST_ELEMENT_FLAG_LAST") + ) +) + +(define-enum CoreError + (in-module "Gst") + (c-name "GstCoreError") + (gtype-id "GST_TYPE_CORE_ERROR") + (values + '("failed" "GST_CORE_ERROR_FAILED") + '("too-lazy" "GST_CORE_ERROR_TOO_LAZY") + '("not-implemented" "GST_CORE_ERROR_NOT_IMPLEMENTED") + '("state-change" "GST_CORE_ERROR_STATE_CHANGE") + '("pad" "GST_CORE_ERROR_PAD") + '("thread" "GST_CORE_ERROR_THREAD") + '("scheduler" "GST_CORE_ERROR_SCHEDULER") + '("negotiation" "GST_CORE_ERROR_NEGOTIATION") + '("event" "GST_CORE_ERROR_EVENT") + '("seek" "GST_CORE_ERROR_SEEK") + '("caps" "GST_CORE_ERROR_CAPS") + '("tag" "GST_CORE_ERROR_TAG") + '("num-errors" "GST_CORE_ERROR_NUM_ERRORS") + ) +) + +(define-enum LibraryError + (in-module "Gst") + (c-name "GstLibraryError") + (gtype-id "GST_TYPE_LIBRARY_ERROR") + (values + '("failed" "GST_LIBRARY_ERROR_FAILED") + '("too-lazy" "GST_LIBRARY_ERROR_TOO_LAZY") + '("init" "GST_LIBRARY_ERROR_INIT") + '("shutdown" "GST_LIBRARY_ERROR_SHUTDOWN") + '("settings" "GST_LIBRARY_ERROR_SETTINGS") + '("encode" "GST_LIBRARY_ERROR_ENCODE") + '("num-errors" "GST_LIBRARY_ERROR_NUM_ERRORS") + ) +) + +(define-enum ResourceError + (in-module "Gst") + (c-name "GstResourceError") + (gtype-id "GST_TYPE_RESOURCE_ERROR") + (values + '("failed" "GST_RESOURCE_ERROR_FAILED") + '("too-lazy" "GST_RESOURCE_ERROR_TOO_LAZY") + '("not-found" "GST_RESOURCE_ERROR_NOT_FOUND") + '("busy" "GST_RESOURCE_ERROR_BUSY") + '("open-read" "GST_RESOURCE_ERROR_OPEN_READ") + '("open-write" "GST_RESOURCE_ERROR_OPEN_WRITE") + '("open-read-write" "GST_RESOURCE_ERROR_OPEN_READ_WRITE") + '("close" "GST_RESOURCE_ERROR_CLOSE") + '("read" "GST_RESOURCE_ERROR_READ") + '("write" "GST_RESOURCE_ERROR_WRITE") + '("seek" "GST_RESOURCE_ERROR_SEEK") + '("sync" "GST_RESOURCE_ERROR_SYNC") + '("settings" "GST_RESOURCE_ERROR_SETTINGS") + '("num-errors" "GST_RESOURCE_ERROR_NUM_ERRORS") + ) +) + +(define-enum StreamError + (in-module "Gst") + (c-name "GstStreamError") + (gtype-id "GST_TYPE_STREAM_ERROR") + (values + '("failed" "GST_STREAM_ERROR_FAILED") + '("too-lazy" "GST_STREAM_ERROR_TOO_LAZY") + '("not-implemented" "GST_STREAM_ERROR_NOT_IMPLEMENTED") + '("type-not-found" "GST_STREAM_ERROR_TYPE_NOT_FOUND") + '("wrong-type" "GST_STREAM_ERROR_WRONG_TYPE") + '("codec-not-found" "GST_STREAM_ERROR_CODEC_NOT_FOUND") + '("decode" "GST_STREAM_ERROR_DECODE") + '("encode" "GST_STREAM_ERROR_ENCODE") + '("demux" "GST_STREAM_ERROR_DEMUX") + '("mux" "GST_STREAM_ERROR_MUX") + '("format" "GST_STREAM_ERROR_FORMAT") + '("num-errors" "GST_STREAM_ERROR_NUM_ERRORS") + ) +) + +(define-enum EventType + (in-module "Gst") + (c-name "GstEventType") + (gtype-id "GST_TYPE_EVENT_TYPE") + (values + '("unknown" "GST_EVENT_UNKNOWN") + '("eos" "GST_EVENT_EOS") + '("flush" "GST_EVENT_FLUSH") + '("empty" "GST_EVENT_EMPTY") + '("discontinuous" "GST_EVENT_DISCONTINUOUS") + '("qos" "GST_EVENT_QOS") + '("seek" "GST_EVENT_SEEK") + '("seek-segment" "GST_EVENT_SEEK_SEGMENT") + '("segment-done" "GST_EVENT_SEGMENT_DONE") + '("size" "GST_EVENT_SIZE") + '("rate" "GST_EVENT_RATE") + '("filler" "GST_EVENT_FILLER") + '("ts-offset" "GST_EVENT_TS_OFFSET") + '("interrupt" "GST_EVENT_INTERRUPT") + '("navigation" "GST_EVENT_NAVIGATION") + '("tag" "GST_EVENT_TAG") + ) +) + +(define-flags EventFlag + (in-module "Gst") + (c-name "GstEventFlag") + (gtype-id "GST_TYPE_EVENT_FLAG") + (values + '("event-flag-none" "GST_EVENT_FLAG_NONE") + '("rate-flag-negative" "GST_RATE_FLAG_NEGATIVE") + ) +) + +(define-flags SeekType + (in-module "Gst") + (c-name "GstSeekType") + (gtype-id "GST_TYPE_SEEK_TYPE") + (values + '("method-cur" "GST_SEEK_METHOD_CUR") + '("method-set" "GST_SEEK_METHOD_SET") + '("method-end" "GST_SEEK_METHOD_END") + '("flag-flush" "GST_SEEK_FLAG_FLUSH") + '("flag-accurate" "GST_SEEK_FLAG_ACCURATE") + '("flag-key-unit" "GST_SEEK_FLAG_KEY_UNIT") + '("flag-segment-loop" "GST_SEEK_FLAG_SEGMENT_LOOP") + ) +) + +(define-enum SeekAccuracy + (in-module "Gst") + (c-name "GstSeekAccuracy") + (gtype-id "GST_TYPE_SEEK_ACCURACY") + (values + '("certain" "GST_SEEK_CERTAIN") + '("fuzzy" "GST_SEEK_FUZZY") + ) +) + +(define-enum Format + (in-module "Gst") + (c-name "GstFormat") + (gtype-id "GST_TYPE_FORMAT") + (values + '("undefined" "GST_FORMAT_UNDEFINED") + '("default" "GST_FORMAT_DEFAULT") + '("bytes" "GST_FORMAT_BYTES") + '("time" "GST_FORMAT_TIME") + '("buffers" "GST_FORMAT_BUFFERS") + '("percent" "GST_FORMAT_PERCENT") + ) +) + +(define-enum IndexCertainty + (in-module "Gst") + (c-name "GstIndexCertainty") + (gtype-id "GST_TYPE_INDEX_CERTAINTY") + (values + '("unknown" "GST_INDEX_UNKNOWN") + '("certain" "GST_INDEX_CERTAIN") + '("fuzzy" "GST_INDEX_FUZZY") + ) +) + +(define-enum IndexEntryType + (in-module "Gst") + (c-name "GstIndexEntryType") + (gtype-id "GST_TYPE_INDEX_ENTRY_TYPE") + (values + '("id" "GST_INDEX_ENTRY_ID") + '("association" "GST_INDEX_ENTRY_ASSOCIATION") + '("object" "GST_INDEX_ENTRY_OBJECT") + '("format" "GST_INDEX_ENTRY_FORMAT") + ) +) + +(define-enum IndexLookupMethod + (in-module "Gst") + (c-name "GstIndexLookupMethod") + (gtype-id "GST_TYPE_INDEX_LOOKUP_METHOD") + (values + '("exact" "GST_INDEX_LOOKUP_EXACT") + '("before" "GST_INDEX_LOOKUP_BEFORE") + '("after" "GST_INDEX_LOOKUP_AFTER") + ) +) + +(define-flags AssocFlags + (in-module "Gst") + (c-name "GstAssocFlags") + (gtype-id "GST_TYPE_ASSOC_FLAGS") + (values + '("none" "GST_ASSOCIATION_FLAG_NONE") + '("key-unit" "GST_ASSOCIATION_FLAG_KEY_UNIT") + '("last" "GST_ASSOCIATION_FLAG_LAST") + ) +) + +(define-enum IndexResolverMethod + (in-module "Gst") + (c-name "GstIndexResolverMethod") + (gtype-id "GST_TYPE_INDEX_RESOLVER_METHOD") + (values + '("custom" "GST_INDEX_RESOLVER_CUSTOM") + '("gtype" "GST_INDEX_RESOLVER_GTYPE") + '("path" "GST_INDEX_RESOLVER_PATH") + ) +) + +(define-enum IndexFlags + (in-module "Gst") + (c-name "GstIndexFlags") + (gtype-id "GST_TYPE_INDEX_FLAGS") + (values + '("writable" "GST_INDEX_WRITABLE") + '("readable" "GST_INDEX_READABLE") + '("flag-last" "GST_INDEX_FLAG_LAST") + ) +) + +(define-enum DebugLevel + (in-module "Gst") + (c-name "GstDebugLevel") + (gtype-id "GST_TYPE_DEBUG_LEVEL") + (values + '("none" "GST_LEVEL_NONE") + '("error" "GST_LEVEL_ERROR") + '("warning" "GST_LEVEL_WARNING") + '("info" "GST_LEVEL_INFO") + '("debug" "GST_LEVEL_DEBUG") + '("log" "GST_LEVEL_LOG") + '("count" "GST_LEVEL_COUNT") + ) +) + +(define-enum DebugColorFlags + (in-module "Gst") + (c-name "GstDebugColorFlags") + (gtype-id "GST_TYPE_DEBUG_COLOR_FLAGS") + (values + '("fg-black" "GST_DEBUG_FG_BLACK") + '("fg-red" "GST_DEBUG_FG_RED") + '("fg-green" "GST_DEBUG_FG_GREEN") + '("fg-yellow" "GST_DEBUG_FG_YELLOW") + '("fg-blue" "GST_DEBUG_FG_BLUE") + '("fg-magenta" "GST_DEBUG_FG_MAGENTA") + '("fg-cyan" "GST_DEBUG_FG_CYAN") + '("fg-white" "GST_DEBUG_FG_WHITE") + '("bg-black" "GST_DEBUG_BG_BLACK") + '("bg-red" "GST_DEBUG_BG_RED") + '("bg-green" "GST_DEBUG_BG_GREEN") + '("bg-yellow" "GST_DEBUG_BG_YELLOW") + '("bg-blue" "GST_DEBUG_BG_BLUE") + '("bg-magenta" "GST_DEBUG_BG_MAGENTA") + '("bg-cyan" "GST_DEBUG_BG_CYAN") + '("bg-white" "GST_DEBUG_BG_WHITE") + '("bold" "GST_DEBUG_BOLD") + '("underline" "GST_DEBUG_UNDERLINE") + ) +) + +(define-enum ObjectFlags + (in-module "Gst") + (c-name "GstObjectFlags") + (gtype-id "GST_TYPE_OBJECT_FLAGS") + (values + '("destroyed" "GST_DESTROYED") + '("floating" "GST_FLOATING") + '("object-flag-last" "GST_OBJECT_FLAG_LAST") + ) +) + +(define-enum PadLinkReturn + (in-module "Gst") + (c-name "GstPadLinkReturn") + (gtype-id "GST_TYPE_PAD_LINK_RETURN") + (values + '("refused" "GST_PAD_LINK_REFUSED") + '("delayed" "GST_PAD_LINK_DELAYED") + '("ok" "GST_PAD_LINK_OK") + '("done" "GST_PAD_LINK_DONE") + ) +) + +(define-enum PadDirection + (in-module "Gst") + (c-name "GstPadDirection") + (gtype-id "GST_TYPE_PAD_DIRECTION") + (values + '("unknown" "GST_PAD_UNKNOWN") + '("src" "GST_PAD_SRC") + '("sink" "GST_PAD_SINK") + ) +) + +(define-enum PadFlags + (in-module "Gst") + (c-name "GstPadFlags") + (gtype-id "GST_TYPE_PAD_FLAGS") + (values + '("disabled" "GST_PAD_DISABLED") + '("negotiating" "GST_PAD_NEGOTIATING") + '("flag-last" "GST_PAD_FLAG_LAST") + ) +) + +(define-enum PadPresence + (in-module "Gst") + (c-name "GstPadPresence") + (gtype-id "GST_TYPE_PAD_PRESENCE") + (values + '("always" "GST_PAD_ALWAYS") + '("sometimes" "GST_PAD_SOMETIMES") + '("request" "GST_PAD_REQUEST") + ) +) + +(define-enum PadTemplateFlags + (in-module "Gst") + (c-name "GstPadTemplateFlags") + (gtype-id "GST_TYPE_PAD_TEMPLATE_FLAGS") + (values + '("ixed" "GST_PAD_TEMPLATE_FIXED") + '("lag-last" "GST_PAD_TEMPLATE_FLAG_LAST") + ) +) + +(define-enum ParseError + (in-module "Gst") + (c-name "GstParseError") + (gtype-id "GST_TYPE_PARSE_ERROR") + (values + '("syntax" "GST_PARSE_ERROR_SYNTAX") + '("no-such-element" "GST_PARSE_ERROR_NO_SUCH_ELEMENT") + '("no-such-property" "GST_PARSE_ERROR_NO_SUCH_PROPERTY") + '("link" "GST_PARSE_ERROR_LINK") + '("could-not-set-property" "GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY") + '("empty-bin" "GST_PARSE_ERROR_EMPTY_BIN") + '("empty" "GST_PARSE_ERROR_EMPTY") + ) +) + +(define-enum PluginError + (in-module "Gst") + (c-name "GstPluginError") + (gtype-id "GST_TYPE_PLUGIN_ERROR") + (values + '("module" "GST_PLUGIN_ERROR_MODULE") + '("dependencies" "GST_PLUGIN_ERROR_DEPENDENCIES") + '("name-mismatch" "GST_PLUGIN_ERROR_NAME_MISMATCH") + ) +) + +(define-enum QueryType + (in-module "Gst") + (c-name "GstQueryType") + (gtype-id "GST_TYPE_QUERY_TYPE") + (values + '("none" "GST_QUERY_NONE") + '("total" "GST_QUERY_TOTAL") + '("position" "GST_QUERY_POSITION") + '("latency" "GST_QUERY_LATENCY") + '("jitter" "GST_QUERY_JITTER") + '("start" "GST_QUERY_START") + '("segment-end" "GST_QUERY_SEGMENT_END") + '("rate" "GST_QUERY_RATE") + ) +) + +(define-flags RegistryReturn + (in-module "Gst") + (c-name "GstRegistryReturn") + (gtype-id "GST_TYPE_REGISTRY_RETURN") + (values + '("ok" "GST_REGISTRY_OK") + '("load-error" "GST_REGISTRY_LOAD_ERROR") + '("save-error" "GST_REGISTRY_SAVE_ERROR") + '("plugin-load-error" "GST_REGISTRY_PLUGIN_LOAD_ERROR") + '("plugin-signature-error" "GST_REGISTRY_PLUGIN_SIGNATURE_ERROR") + ) +) + +(define-flags RegistryFlags + (in-module "Gst") + (c-name "GstRegistryFlags") + (gtype-id "GST_TYPE_REGISTRY_FLAGS") + (values + '("readable" "GST_REGISTRY_READABLE") + '("writable" "GST_REGISTRY_WRITABLE") + '("exists" "GST_REGISTRY_EXISTS") + '("remote" "GST_REGISTRY_REMOTE") + '("delayed-loading" "GST_REGISTRY_DELAYED_LOADING") + ) +) + +(define-enum SchedulerFlags + (in-module "Gst") + (c-name "GstSchedulerFlags") + (gtype-id "GST_TYPE_SCHEDULER_FLAGS") + (values + '("fixed-clock" "GST_SCHEDULER_FLAG_FIXED_CLOCK") + '("last" "GST_SCHEDULER_FLAG_LAST") + ) +) + +(define-enum SchedulerState + (in-module "Gst") + (c-name "GstSchedulerState") + (gtype-id "GST_TYPE_SCHEDULER_STATE") + (values + '("none" "GST_SCHEDULER_STATE_NONE") + '("running" "GST_SCHEDULER_STATE_RUNNING") + '("stopped" "GST_SCHEDULER_STATE_STOPPED") + '("error" "GST_SCHEDULER_STATE_ERROR") + ) +) + +(define-enum TagMergeMode + (in-module "Gst") + (c-name "GstTagMergeMode") + (gtype-id "GST_TYPE_TAG_MERGE_MODE") + (values + '("undefined" "GST_TAG_MERGE_UNDEFINED") + '("replace-all" "GST_TAG_MERGE_REPLACE_ALL") + '("replace" "GST_TAG_MERGE_REPLACE") + '("append" "GST_TAG_MERGE_APPEND") + '("prepend" "GST_TAG_MERGE_PREPEND") + '("keep" "GST_TAG_MERGE_KEEP") + '("keep-all" "GST_TAG_MERGE_KEEP_ALL") + '("count" "GST_TAG_MERGE_COUNT") + ) +) + +(define-enum TagFlag + (in-module "Gst") + (c-name "GstTagFlag") + (gtype-id "GST_TYPE_TAG_FLAG") + (values + '("undefined" "GST_TAG_FLAG_UNDEFINED") + '("meta" "GST_TAG_FLAG_META") + '("encoded" "GST_TAG_FLAG_ENCODED") + '("decoded" "GST_TAG_FLAG_DECODED") + '("count" "GST_TAG_FLAG_COUNT") + ) +) + +(define-enum ThreadState + (in-module "Gst") + (c-name "GstThreadState") + (gtype-id "GST_TYPE_THREAD_STATE") + (values + '("state-spinning" "GST_THREAD_STATE_SPINNING") + '("state-reaping" "GST_THREAD_STATE_REAPING") + '("mutex-locked" "GST_THREAD_MUTEX_LOCKED") + '("flag-last" "GST_THREAD_FLAG_LAST") + ) +) + +(define-flags AllocTraceFlags + (in-module "Gst") + (c-name "GstAllocTraceFlags") + (gtype-id "GST_TYPE_ALLOC_TRACE_FLAGS") + (values + '("live" "GST_ALLOC_TRACE_LIVE") + '("mem-live" "GST_ALLOC_TRACE_MEM_LIVE") + ) +) + +(define-enum TypeFindProbability + (in-module "Gst") + (c-name "GstTypeFindProbability") + (gtype-id "GST_TYPE_TYPE_FIND_PROBABILITY") + (values + '("minimum" "GST_TYPE_FIND_MINIMUM") + '("possible" "GST_TYPE_FIND_POSSIBLE") + '("likely" "GST_TYPE_FIND_LIKELY") + '("nearly-certain" "GST_TYPE_FIND_NEARLY_CERTAIN") + '("maximum" "GST_TYPE_FIND_MAXIMUM") + ) +) + +(define-flags ElementState + (in-module "Gst") + (c-name "GstElementState") + (gtype-id "GST_TYPE_ELEMENT_STATE") + (values + '("void-pending" "GST_STATE_VOID_PENDING") + '("null" "GST_STATE_NULL") + '("ready" "GST_STATE_READY") + '("paused" "GST_STATE_PAUSED") + '("playing" "GST_STATE_PLAYING") + ) +) + +(define-enum ElementStateReturn + (in-module "Gst") + (c-name "GstElementStateReturn") + (gtype-id "GST_TYPE_ELEMENT_STATE_RETURN") + (values + '("failure" "GST_STATE_FAILURE") + '("success" "GST_STATE_SUCCESS") + '("async" "GST_STATE_ASYNC") + ) +) + +(define-enum Result + (in-module "Gst") + (c-name "GstResult") + (gtype-id "GST_TYPE_RESULT") + (values + '("ok" "GST_RESULT_OK") + '("nok" "GST_RESULT_NOK") + '("not-impl" "GST_RESULT_NOT_IMPL") + ) +) + +(define-enum URIType + (in-module "Gst") + (c-name "GstURIType") + (gtype-id "GST_TYPE_URI_TYPE") + (values + '("unknown" "GST_URI_UNKNOWN") + '("sink" "GST_URI_SINK") + '("src" "GST_URI_SRC") + ) +) + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstatomic.h + +(define-method init + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_init") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method destroy + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_destroy") + (return-type "none") +) + +(define-method set + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_set") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method read + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_read") + (return-type "gint") +) + +(define-method add + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_add") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method inc + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_inc") + (return-type "none") +) + +(define-method dec_and_test + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_dec_and_test") + (return-type "gboolean") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstbin.h + +(define-function gst_bin_get_type + (c-name "gst_bin_get_type") + (return-type "GType") +) + +(define-function gst_bin_new + (c-name "gst_bin_new") + (is-constructor-of "GstBin") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method add + (of-object "GstBin") + (c-name "gst_bin_add") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method add_many + (of-object "GstBin") + (c-name "gst_bin_add_many") + (return-type "none") + (parameters + '("GstElement*" "element_1") + ) + (varargs #t) +) + +(define-method remove + (of-object "GstBin") + (c-name "gst_bin_remove") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method remove_many + (of-object "GstBin") + (c-name "gst_bin_remove_many") + (return-type "none") + (parameters + '("GstElement*" "element_1") + ) + (varargs #t) +) + +(define-method get_by_name + (of-object "GstBin") + (c-name "gst_bin_get_by_name") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_by_name_recurse_up + (of-object "GstBin") + (c-name "gst_bin_get_by_name_recurse_up") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_list + (of-object "GstBin") + (c-name "gst_bin_get_list") + (return-type "const-GList*") +) + +(define-method get_by_interface + (of-object "GstBin") + (c-name "gst_bin_get_by_interface") + (return-type "GstElement*") + (parameters + '("GType" "interface") + ) +) + +(define-method get_all_by_interface + (of-object "GstBin") + (c-name "gst_bin_get_all_by_interface") + (return-type "GList*") + (parameters + '("GType" "interface") + ) +) + +(define-method iterate + (of-object "GstBin") + (c-name "gst_bin_iterate") + (return-type "gboolean") +) + +(define-method use_clock + (of-object "GstBin") + (c-name "gst_bin_use_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method get_clock + (of-object "GstBin") + (c-name "gst_bin_get_clock") + (return-type "GstClock*") +) + +(define-method auto_clock + (of-object "GstBin") + (c-name "gst_bin_auto_clock") + (return-type "none") +) + +(define-method sync_children_state + (of-object "GstBin") + (c-name "gst_bin_sync_children_state") + (return-type "GstElementStateReturn") +) + +(define-method child_state_change + (of-object "GstBin") + (c-name "gst_bin_child_state_change") + (return-type "none") + (parameters + '("GstElementState" "oldstate") + '("GstElementState" "newstate") + '("GstElement*" "child") + ) +) + +(define-method set_pre_iterate_function + (of-object "GstBin") + (c-name "gst_bin_set_pre_iterate_function") + (return-type "none") + (parameters + '("GstBinPrePostIterateFunction" "func") + '("gpointer" "user_data") + ) +) + +(define-method set_post_iterate_function + (of-object "GstBin") + (c-name "gst_bin_set_post_iterate_function") + (return-type "none") + (parameters + '("GstBinPrePostIterateFunction" "func") + '("gpointer" "user_data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstbuffer.h + +(define-function gst_buffer_get_type + (c-name "gst_buffer_get_type") + (return-type "GType") +) + +(define-function gst_buffer_new + (c-name "gst_buffer_new") + (is-constructor-of "GstBuffer") + (return-type "GstBuffer*") +) + +(define-function gst_buffer_new_and_alloc + (c-name "gst_buffer_new_and_alloc") + (return-type "GstBuffer*") + (parameters + '("guint" "size") + ) +) + +(define-method stamp + (of-object "GstBuffer") + (c-name "gst_buffer_stamp") + (return-type "none") + (parameters + '("const-GstBuffer*" "src") + ) +) + +(define-method create_sub + (of-object "GstBuffer") + (c-name "gst_buffer_create_sub") + (return-type "GstBuffer*") + (parameters + '("guint" "offset") + '("guint" "size") + ) +) + +(define-method merge + (of-object "GstBuffer") + (c-name "gst_buffer_merge") + (return-type "GstBuffer*") + (parameters + '("GstBuffer*" "buf2") + ) +) + +(define-method is_span_fast + (of-object "GstBuffer") + (c-name "gst_buffer_is_span_fast") + (return-type "gboolean") + (parameters + '("GstBuffer*" "buf2") + ) +) + +(define-method span + (of-object "GstBuffer") + (c-name "gst_buffer_span") + (return-type "GstBuffer*") + (parameters + '("guint32" "offset") + '("GstBuffer*" "buf2") + '("guint32" "len") + ) +) + +(define-function _gst_buffer_initialize + (c-name "_gst_buffer_initialize") + (return-type "none") +) + +(define-method default_free + (of-object "GstBuffer") + (c-name "gst_buffer_default_free") + (return-type "none") +) + +(define-method default_copy + (of-object "GstBuffer") + (c-name "gst_buffer_default_copy") + (return-type "GstBuffer*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstcaps.h + +(define-function _gst_caps_initialize + (c-name "_gst_caps_initialize") + (return-type "none") +) + +(define-function gst_caps_get_type + (c-name "gst_caps_get_type") + (return-type "GType") +) + +(define-function gst_caps_new_empty + (c-name "gst_caps_new_empty") + (return-type "GstCaps*") +) + +(define-function gst_caps_new_any + (c-name "gst_caps_new_any") + (return-type "GstCaps*") +) + +(define-function gst_caps_new_simple + (c-name "gst_caps_new_simple") + (return-type "GstCaps*") + (parameters + '("const-char*" "media_type") + '("const-char*" "fieldname") + ) + (varargs #t) +) + +(define-function gst_caps_new_full + (c-name "gst_caps_new_full") + (return-type "GstCaps*") + (parameters + '("GstStructure*" "struct1") + ) + (varargs #t) +) + +(define-function gst_caps_new_full_valist + (c-name "gst_caps_new_full_valist") + (return-type "GstCaps*") + (parameters + '("GstStructure*" "structure") + '("va_list" "var_args") + ) +) + +(define-method copy + (of-object "GstCaps") + (c-name "gst_caps_copy") + (return-type "GstCaps*") +) + +(define-method free + (of-object "GstCaps") + (c-name "gst_caps_free") + (return-type "none") +) + +(define-method get + (of-object "GstStaticCaps") + (c-name "gst_static_caps_get") + (return-type "const-GstCaps*") +) + +(define-method append + (of-object "GstCaps") + (c-name "gst_caps_append") + (return-type "none") + (parameters + '("GstCaps*" "caps2") + ) +) + +(define-method append_structure + (of-object "GstCaps") + (c-name "gst_caps_append_structure") + (return-type "none") + (parameters + '("GstStructure*" "structure") + ) +) + +(define-method split_one + (of-object "GstCaps") + (c-name "gst_caps_split_one") + (return-type "GstCaps*") +) + +(define-method get_size + (of-object "GstCaps") + (c-name "gst_caps_get_size") + (return-type "int") +) + +(define-method get_structure + (of-object "GstCaps") + (c-name "gst_caps_get_structure") + (return-type "GstStructure*") + (parameters + '("int" "index") + ) +) + +(define-method copy_1 + (of-object "GstCaps") + (c-name "gst_caps_copy_1") + (return-type "GstCaps*") +) + +(define-method set_simple + (of-object "GstCaps") + (c-name "gst_caps_set_simple") + (return-type "none") + (parameters + '("char*" "field") + ) + (varargs #t) +) + +(define-method set_simple_valist + (of-object "GstCaps") + (c-name "gst_caps_set_simple_valist") + (return-type "none") + (parameters + '("char*" "field") + '("va_list" "varargs") + ) +) + +(define-method is_any + (of-object "GstCaps") + (c-name "gst_caps_is_any") + (return-type "gboolean") +) + +(define-method is_empty + (of-object "GstCaps") + (c-name "gst_caps_is_empty") + (return-type "gboolean") +) + +(define-method is_chained + (of-object "GstCaps") + (c-name "gst_caps_is_chained") + (return-type "gboolean") +) + +(define-method is_fixed + (of-object "GstCaps") + (c-name "gst_caps_is_fixed") + (return-type "gboolean") +) + +(define-method is_equal_fixed + (of-object "GstCaps") + (c-name "gst_caps_is_equal_fixed") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method is_always_compatible + (of-object "GstCaps") + (c-name "gst_caps_is_always_compatible") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method intersect + (of-object "GstCaps") + (c-name "gst_caps_intersect") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method union + (of-object "GstCaps") + (c-name "gst_caps_union") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method normalize + (of-object "GstCaps") + (c-name "gst_caps_normalize") + (return-type "GstCaps*") +) + +(define-method simplify + (of-object "GstCaps") + (c-name "gst_caps_simplify") + (return-type "GstCaps*") +) + +(define-method save_thyself + (of-object "GstCaps") + (c-name "gst_caps_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-function gst_caps_load_thyself + (c-name "gst_caps_load_thyself") + (return-type "GstCaps*") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-function gst_caps_replace + (c-name "gst_caps_replace") + (return-type "none") + (parameters + '("GstCaps**" "caps") + '("GstCaps*" "newcaps") + ) +) + +(define-method to_string + (of-object "GstCaps") + (c-name "gst_caps_to_string") + (return-type "gchar*") +) + +(define-function gst_caps_from_string + (c-name "gst_caps_from_string") + (return-type "GstCaps*") + (parameters + '("const-gchar*" "string") + ) +) + +(define-function gst_caps_structure_fixate_field_nearest_int + (c-name "gst_caps_structure_fixate_field_nearest_int") + (return-type "gboolean") + (parameters + '("GstStructure*" "structure") + '("const-char*" "field_name") + '("int" "target") + ) +) + +(define-function gst_caps_structure_fixate_field_nearest_double + (c-name "gst_caps_structure_fixate_field_nearest_double") + (return-type "gboolean") + (parameters + '("GstStructure*" "structure") + '("const-char*" "field_name") + '("double" "target") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstclock.h + +(define-function gst_clock_get_type + (c-name "gst_clock_get_type") + (return-type "GType") +) + +(define-method set_speed + (of-object "GstClock") + (c-name "gst_clock_set_speed") + (return-type "gdouble") + (parameters + '("gdouble" "speed") + ) +) + +(define-method get_speed + (of-object "GstClock") + (c-name "gst_clock_get_speed") + (return-type "gdouble") +) + +(define-method set_resolution + (of-object "GstClock") + (c-name "gst_clock_set_resolution") + (return-type "guint64") + (parameters + '("guint64" "resolution") + ) +) + +(define-method get_resolution + (of-object "GstClock") + (c-name "gst_clock_get_resolution") + (return-type "guint64") +) + +(define-method set_active + (of-object "GstClock") + (c-name "gst_clock_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method is_active + (of-object "GstClock") + (c-name "gst_clock_is_active") + (return-type "gboolean") +) + +(define-method reset + (of-object "GstClock") + (c-name "gst_clock_reset") + (return-type "none") +) + +(define-method handle_discont + (of-object "GstClock") + (c-name "gst_clock_handle_discont") + (return-type "gboolean") + (parameters + '("guint64" "time") + ) +) + +(define-method get_time + (of-object "GstClock") + (c-name "gst_clock_get_time") + (return-type "GstClockTime") +) + +(define-method get_event_time + (of-object "GstClock") + (c-name "gst_clock_get_event_time") + (return-type "GstClockTime") +) + +(define-method get_next_id + (of-object "GstClock") + (c-name "gst_clock_get_next_id") + (return-type "GstClockID") +) + +(define-method new_single_shot_id + (of-object "GstClock") + (c-name "gst_clock_new_single_shot_id") + (return-type "GstClockID") + (parameters + '("GstClockTime" "time") + ) +) + +(define-method new_periodic_id + (of-object "GstClock") + (c-name "gst_clock_new_periodic_id") + (return-type "GstClockID") + (parameters + '("GstClockTime" "start_time") + '("GstClockTime" "interval") + ) +) + +(define-method get_time + (of-object "GstClockID") + (c-name "gst_clock_id_get_time") + (return-type "GstClockTime") +) + +(define-method wait + (of-object "GstClockID") + (c-name "gst_clock_id_wait") + (return-type "GstClockReturn") + (parameters + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method wait_async + (of-object "GstClockID") + (c-name "gst_clock_id_wait_async") + (return-type "GstClockReturn") + (parameters + '("GstClockCallback" "func") + '("gpointer" "user_data") + ) +) + +(define-method unschedule + (of-object "GstClockID") + (c-name "gst_clock_id_unschedule") + (return-type "none") +) + +(define-method unlock + (of-object "GstClockID") + (c-name "gst_clock_id_unlock") + (return-type "none") +) + +(define-method free + (of-object "GstClockID") + (c-name "gst_clock_id_free") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstconfig.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstcpu.h + +(define-function _gst_cpu_initialize + (c-name "_gst_cpu_initialize") + (return-type "none") + (parameters + '("gboolean" "useopt") + ) +) + +(define-function gst_cpu_get_flags + (c-name "gst_cpu_get_flags") + (return-type "GstCPUFlags") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstdata.h + +(define-method init + (of-object "GstData") + (c-name "gst_data_init") + (return-type "none") + (parameters + '("GType" "type") + '("guint16" "flags") + '("GstDataFreeFunction" "free") + '("GstDataCopyFunction" "copy") + ) +) + +(define-method dispose + (of-object "GstData") + (c-name "gst_data_dispose") + (return-type "none") +) + +(define-method copy_into + (of-object "GstData") + (c-name "gst_data_copy_into") + (return-type "none") + (parameters + '("GstData*" "target") + ) +) + +(define-method copy + (of-object "GstData") + (c-name "gst_data_copy") + (return-type "GstData*") +) + +(define-method is_writable + (of-object "GstData") + (c-name "gst_data_is_writable") + (return-type "gboolean") +) + +(define-method copy_on_write + (of-object "GstData") + (c-name "gst_data_copy_on_write") + (return-type "GstData*") +) + +(define-method free + (of-object "GstData") + (c-name "gst_data_free") + (return-type "none") +) + +(define-method ref + (of-object "GstData") + (c-name "gst_data_ref") + (return-type "GstData*") +) + +(define-method ref_by_count + (of-object "GstData") + (c-name "gst_data_ref_by_count") + (return-type "GstData*") + (parameters + '("gint" "count") + ) +) + +(define-method unref + (of-object "GstData") + (c-name "gst_data_unref") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstelement.h + +(define-method add_pad_template + (of-object "GstElementClass") + (c-name "gst_element_class_add_pad_template") + (return-type "none") + (parameters + '("GstPadTemplate*" "templ") + ) +) + +(define-method install_std_props + (of-object "GstElementClass") + (c-name "gst_element_class_install_std_props") + (return-type "none") + (parameters + '("const-gchar*" "first_name") + ) + (varargs #t) +) + +(define-method set_details + (of-object "GstElementClass") + (c-name "gst_element_class_set_details") + (return-type "none") + (parameters + '("const-GstElementDetails*" "details") + ) +) + +(define-function gst_element_default_error + (c-name "gst_element_default_error") + (return-type "none") + (parameters + '("GObject*" "object") + '("GstObject*" "orig") + '("GError*" "error") + '("gchar*" "debug") + ) +) + +(define-function gst_element_get_type + (c-name "gst_element_get_type") + (return-type "GType") +) + +(define-method set_loop_function + (of-object "GstElement") + (c-name "gst_element_set_loop_function") + (return-type "none") + (parameters + '("GstElementLoopFunction" "loop") + ) +) + +(define-method set + (of-object "GstElement") + (c-name "gst_element_set") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + ) + (varargs #t) +) + +(define-method get + (of-object "GstElement") + (c-name "gst_element_get") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + ) + (varargs #t) +) + +(define-method set_valist + (of-object "GstElement") + (c-name "gst_element_set_valist") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + '("va_list" "var_args") + ) +) + +(define-method get_valist + (of-object "GstElement") + (c-name "gst_element_get_valist") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + '("va_list" "var_args") + ) +) + +(define-method set_property + (of-object "GstElement") + (c-name "gst_element_set_property") + (return-type "none") + (parameters + '("const-gchar*" "property_name") + '("const-GValue*" "value") + ) +) + +(define-method get_property + (of-object "GstElement") + (c-name "gst_element_get_property") + (return-type "none") + (parameters + '("const-gchar*" "property_name") + '("GValue*" "value") + ) +) + +(define-method enable_threadsafe_properties + (of-object "GstElement") + (c-name "gst_element_enable_threadsafe_properties") + (return-type "none") +) + +(define-method disable_threadsafe_properties + (of-object "GstElement") + (c-name "gst_element_disable_threadsafe_properties") + (return-type "none") +) + +(define-method set_pending_properties + (of-object "GstElement") + (c-name "gst_element_set_pending_properties") + (return-type "none") +) + +(define-method requires_clock + (of-object "GstElement") + (c-name "gst_element_requires_clock") + (return-type "gboolean") +) + +(define-method provides_clock + (of-object "GstElement") + (c-name "gst_element_provides_clock") + (return-type "gboolean") +) + +(define-method get_clock + (of-object "GstElement") + (c-name "gst_element_get_clock") + (return-type "GstClock*") +) + +(define-method set_clock + (of-object "GstElement") + (c-name "gst_element_set_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method clock_wait + (of-object "GstElement") + (c-name "gst_element_clock_wait") + (return-type "GstClockReturn") + (parameters + '("GstClockID" "id") + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method get_time + (of-object "GstElement") + (c-name "gst_element_get_time") + (return-type "GstClockTime") +) + +(define-method wait + (of-object "GstElement") + (c-name "gst_element_wait") + (return-type "gboolean") + (parameters + '("GstClockTime" "timestamp") + ) +) + +(define-method set_time + (of-object "GstElement") + (c-name "gst_element_set_time") + (return-type "none") + (parameters + '("GstClockTime" "time") + ) +) + +(define-method adjust_time + (of-object "GstElement") + (c-name "gst_element_adjust_time") + (return-type "none") + (parameters + '("GstClockTimeDiff" "diff") + ) +) + +(define-method is_indexable + (of-object "GstElement") + (c-name "gst_element_is_indexable") + (return-type "gboolean") +) + +(define-method set_index + (of-object "GstElement") + (c-name "gst_element_set_index") + (return-type "none") + (parameters + '("GstIndex*" "index") + ) +) + +(define-method get_index + (of-object "GstElement") + (c-name "gst_element_get_index") + (return-type "GstIndex*") +) + +(define-method release_locks + (of-object "GstElement") + (c-name "gst_element_release_locks") + (return-type "gboolean") +) + +(define-method yield + (of-object "GstElement") + (c-name "gst_element_yield") + (return-type "none") +) + +(define-method interrupt + (of-object "GstElement") + (c-name "gst_element_interrupt") + (return-type "gboolean") +) + +(define-method set_scheduler + (of-object "GstElement") + (c-name "gst_element_set_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched") + ) +) + +(define-method get_scheduler + (of-object "GstElement") + (c-name "gst_element_get_scheduler") + (return-type "GstScheduler*") +) + +(define-method add_pad + (of-object "GstElement") + (c-name "gst_element_add_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method remove_pad + (of-object "GstElement") + (c-name "gst_element_remove_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method add_ghost_pad + (of-object "GstElement") + (c-name "gst_element_add_ghost_pad") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + '("const-gchar*" "name") + ) +) + +(define-method remove_ghost_pad + (of-object "GstElement") + (c-name "gst_element_remove_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_pad + (of-object "GstElement") + (c-name "gst_element_get_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_static_pad + (of-object "GstElement") + (c-name "gst_element_get_static_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_request_pad + (of-object "GstElement") + (c-name "gst_element_get_request_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method release_request_pad + (of-object "GstElement") + (c-name "gst_element_release_request_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_pad_list + (of-object "GstElement") + (c-name "gst_element_get_pad_list") + (return-type "const-GList*") +) + +(define-method get_compatible_pad + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_compatible_pad_filtered + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad_filtered") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method get_pad_template + (of-object "GstElementClass") + (c-name "gst_element_class_get_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_pad_template_list + (of-object "GstElementClass") + (c-name "gst_element_class_get_pad_template_list") + (return-type "GList*") +) + +(define-method get_pad_template + (of-object "GstElement") + (c-name "gst_element_get_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_pad_template_list + (of-object "GstElement") + (c-name "gst_element_get_pad_template_list") + (return-type "GList*") +) + +(define-method get_compatible_pad_template + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("GstPadTemplate*" "compattempl") + ) +) + +(define-method link + (of-object "GstElement") + (c-name "gst_element_link") + (return-type "gboolean") + (parameters + '("GstElement*" "dest") + ) +) + +(define-method link_filtered + (of-object "GstElement") + (c-name "gst_element_link_filtered") + (return-type "gboolean") + (parameters + '("GstElement*" "dest") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-function element_link_many + (c-name "gst_element_link_many") + (return-type "gboolean") + (parameters + '("GstElement*" "element_1") + '("GstElement*" "element_2") + ) + (varargs #t) +) + +(define-method unlink + (of-object "GstElement") + (c-name "gst_element_unlink") + (return-type "none") + (parameters + '("GstElement*" "dest") + ) +) + +(define-method unlink_many + (of-object "GstElement") + (c-name "gst_element_unlink_many") + (return-type "none") + (parameters + '("GstElement*" "element_2") + ) + (varargs #t) +) + +(define-method link_pads + (of-object "GstElement") + (c-name "gst_element_link_pads") + (return-type "gboolean") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + ) +) + +(define-method link_pads_filtered + (of-object "GstElement") + (c-name "gst_element_link_pads_filtered") + (return-type "gboolean") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method unlink_pads + (of-object "GstElement") + (c-name "gst_element_unlink_pads") + (return-type "none") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + ) +) + +(define-method get_event_masks + (of-object "GstElement") + (c-name "gst_element_get_event_masks") + (return-type "const-GstEventMask*") +) + +(define-method send_event + (of-object "GstElement") + (c-name "gst_element_send_event") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-method seek + (of-object "GstElement") + (c-name "gst_element_seek") + (return-type "gboolean") + (parameters + '("GstSeekType" "seek_type") + '("guint64" "offset") + ) +) + +(define-method get_query_types + (of-object "GstElement") + (c-name "gst_element_get_query_types") + (return-type "const-GstQueryType*") +) + +(define-method query + (of-object "GstElement") + (c-name "gst_element_query") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method get_formats + (of-object "GstElement") + (c-name "gst_element_get_formats") + (return-type "const-GstFormat*") +) + +(define-method convert + (of-object "GstElement") + (c-name "gst_element_convert") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method found_tags + (of-object "GstElement") + (c-name "gst_element_found_tags") + (return-type "none") + (parameters + '("const-GstTagList*" "tag_list") + ) +) + +(define-method found_tags_for_pad + (of-object "GstElement") + (c-name "gst_element_found_tags_for_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + '("GstClockTime" "timestamp") + '("GstTagList*" "list") + ) +) + +(define-method set_eos + (of-object "GstElement") + (c-name "gst_element_set_eos") + (return-type "none") +) + +(define-function _gst_element_error_printf + (c-name "_gst_element_error_printf") + (return-type "gchar*") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-method error_full + (of-object "GstElement") + (c-name "gst_element_error_full") + (return-type "none") + (parameters + '("GQuark" "domain") + '("gint" "code") + '("gchar*" "message") + '("gchar*" "debug") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + ) +) + +(define-method is_locked_state + (of-object "GstElement") + (c-name "gst_element_is_locked_state") + (return-type "gboolean") +) + +(define-method set_locked_state + (of-object "GstElement") + (c-name "gst_element_set_locked_state") + (return-type "none") + (parameters + '("gboolean" "locked_state") + ) +) + +(define-method sync_state_with_parent + (of-object "GstElement") + (c-name "gst_element_sync_state_with_parent") + (return-type "gboolean") +) + +(define-method get_state + (of-object "GstElement") + (c-name "gst_element_get_state") + (return-type "GstElementState") +) + +(define-method set_state + (of-object "GstElement") + (c-name "gst_element_set_state") + (return-type "GstElementStateReturn") + (parameters + '("GstElementState" "state") + ) +) + +(define-method wait_state_change + (of-object "GstElement") + (c-name "gst_element_wait_state_change") + (return-type "none") +) + +(define-method get_name + (of-object "GstElementState") + (c-name "gst_element_state_get_name") + (return-type "const-gchar*") +) + +(define-method get_factory + (of-object "GstElement") + (c-name "gst_element_get_factory") + (return-type "GstElementFactory*") +) + +(define-method get_managing_bin + (of-object "GstElement") + (c-name "gst_element_get_managing_bin") + (return-type "GstBin*") +) + +(define-function gst_element_factory_get_type + (c-name "gst_element_factory_get_type") + (return-type "GType") +) + +(define-function gst_element_register + (c-name "gst_element_register") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + '("const-gchar*" "elementname") + '("guint" "rank") + '("GType" "type") + ) +) + +(define-function gst_element_factory_find + (c-name "gst_element_factory_find") + (return-type "GstElementFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_element_type + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_element_type") + (return-type "GType") +) + +(define-method get_longname + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_longname") + (return-type "const-gchar*") +) + +(define-method get_klass + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_klass") + (return-type "const-gchar*") +) + +(define-method get_description + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_description") + (return-type "const-gchar*") +) + +(define-method get_author + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_author") + (return-type "const-gchar*") +) + +(define-method get_num_pad_templates + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_num_pad_templates") + (return-type "guint") +) + +(define-method get_pad_templates + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_pad_templates") + (return-type "const-GList*") +) + +(define-method get_uri_type + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_uri_type") + (return-type "guint") +) + +(define-method get_uri_protocols + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_uri_protocols") + (return-type "gchar**") +) + +(define-method create + (of-object "GstElementFactory") + (c-name "gst_element_factory_create") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_element_factory_make + (is-constructor-of "GstElement") + (c-name "gst_element_factory_make") + (return-type "GstElement*") + (parameters + '("const-gchar*" "factoryname") + '("const-gchar*" "name") + ) +) + +(define-method can_src_caps + (of-object "GstElementFactory") + (c-name "gst_element_factory_can_src_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method can_sink_caps + (of-object "GstElementFactory") + (c-name "gst_element_factory_can_sink_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method __add_pad_template + (of-object "GstElementFactory") + (c-name "__gst_element_factory_add_pad_template") + (return-type "none") + (parameters + '("GstPadTemplate*" "templ") + ) +) + +(define-method __add_interface + (of-object "GstElementFactory") + (c-name "__gst_element_factory_add_interface") + (return-type "none") + (parameters + '("const-gchar*" "interfacename") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstenumtypes.h + +(define-function gst_object_flags_get_type + (c-name "gst_object_flags_get_type") + (return-type "GType") +) + +(define-function gst_bin_flags_get_type + (c-name "gst_bin_flags_get_type") + (return-type "GType") +) + +(define-function gst_buffer_flag_get_type + (c-name "gst_buffer_flag_get_type") + (return-type "GType") +) + +(define-function gst_clock_entry_status_get_type + (c-name "gst_clock_entry_status_get_type") + (return-type "GType") +) + +(define-function gst_clock_entry_type_get_type + (c-name "gst_clock_entry_type_get_type") + (return-type "GType") +) + +(define-function gst_clock_return_get_type + (c-name "gst_clock_return_get_type") + (return-type "GType") +) + +(define-function gst_clock_flags_get_type + (c-name "gst_clock_flags_get_type") + (return-type "GType") +) + +(define-function gst_cpu_flags_get_type + (c-name "gst_cpu_flags_get_type") + (return-type "GType") +) + +(define-function gst_data_flags_get_type + (c-name "gst_data_flags_get_type") + (return-type "GType") +) + +(define-function gst_element_flags_get_type + (c-name "gst_element_flags_get_type") + (return-type "GType") +) + +(define-function gst_core_error_get_type + (c-name "gst_core_error_get_type") + (return-type "GType") +) + +(define-function gst_library_error_get_type + (c-name "gst_library_error_get_type") + (return-type "GType") +) + +(define-function gst_resource_error_get_type + (c-name "gst_resource_error_get_type") + (return-type "GType") +) + +(define-function gst_stream_error_get_type + (c-name "gst_stream_error_get_type") + (return-type "GType") +) + +(define-function gst_event_type_get_type + (c-name "gst_event_type_get_type") + (return-type "GType") +) + +(define-function gst_event_flag_get_type + (c-name "gst_event_flag_get_type") + (return-type "GType") +) + +(define-function gst_seek_type_get_type + (c-name "gst_seek_type_get_type") + (return-type "GType") +) + +(define-function gst_seek_accuracy_get_type + (c-name "gst_seek_accuracy_get_type") + (return-type "GType") +) + +(define-function gst_format_get_type + (c-name "gst_format_get_type") + (return-type "GType") +) + +(define-function gst_index_certainty_get_type + (c-name "gst_index_certainty_get_type") + (return-type "GType") +) + +(define-function gst_index_entry_type_get_type + (c-name "gst_index_entry_type_get_type") + (return-type "GType") +) + +(define-function gst_index_lookup_method_get_type + (c-name "gst_index_lookup_method_get_type") + (return-type "GType") +) + +(define-function gst_assoc_flags_get_type + (c-name "gst_assoc_flags_get_type") + (return-type "GType") +) + +(define-function gst_index_resolver_method_get_type + (c-name "gst_index_resolver_method_get_type") + (return-type "GType") +) + +(define-function gst_index_flags_get_type + (c-name "gst_index_flags_get_type") + (return-type "GType") +) + +(define-function gst_debug_level_get_type + (c-name "gst_debug_level_get_type") + (return-type "GType") +) + +(define-function gst_debug_color_flags_get_type + (c-name "gst_debug_color_flags_get_type") + (return-type "GType") +) + +(define-function gst_pad_link_return_get_type + (c-name "gst_pad_link_return_get_type") + (return-type "GType") +) + +(define-function gst_pad_direction_get_type + (c-name "gst_pad_direction_get_type") + (return-type "GType") +) + +(define-function gst_pad_flags_get_type + (c-name "gst_pad_flags_get_type") + (return-type "GType") +) + +(define-function gst_pad_presence_get_type + (c-name "gst_pad_presence_get_type") + (return-type "GType") +) + +(define-function gst_pad_template_flags_get_type + (c-name "gst_pad_template_flags_get_type") + (return-type "GType") +) + +(define-function gst_plugin_error_get_type + (c-name "gst_plugin_error_get_type") + (return-type "GType") +) + +(define-function gst_query_type_get_type + (c-name "gst_query_type_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_flags_get_type + (c-name "gst_scheduler_flags_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_state_get_type + (c-name "gst_scheduler_state_get_type") + (return-type "GType") +) + +(define-function gst_tag_merge_mode_get_type + (c-name "gst_tag_merge_mode_get_type") + (return-type "GType") +) + +(define-function gst_tag_flag_get_type + (c-name "gst_tag_flag_get_type") + (return-type "GType") +) + +(define-function gst_thread_state_get_type + (c-name "gst_thread_state_get_type") + (return-type "GType") +) + +(define-function gst_alloc_trace_flags_get_type + (c-name "gst_alloc_trace_flags_get_type") + (return-type "GType") +) + +(define-function gst_type_find_probability_get_type + (c-name "gst_type_find_probability_get_type") + (return-type "GType") +) + +(define-function gst_element_state_get_type + (c-name "gst_element_state_get_type") + (return-type "GType") +) + +(define-function gst_element_state_return_get_type + (c-name "gst_element_state_return_get_type") + (return-type "GType") +) + +(define-function gst_result_get_type + (c-name "gst_result_get_type") + (return-type "GType") +) + +(define-function gst_uri_type_get_type + (c-name "gst_uri_type_get_type") + (return-type "GType") +) + +(define-function gst_registry_return_get_type + (c-name "gst_registry_return_get_type") + (return-type "GType") +) + +(define-function gst_registry_flags_get_type + (c-name "gst_registry_flags_get_type") + (return-type "GType") +) + +(define-function gst_parse_error_get_type + (c-name "gst_parse_error_get_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsterror.h + +(define-function gst_core_error_quark + (c-name "gst_core_error_quark") + (return-type "GQuark") +) + +(define-function gst_library_error_quark + (c-name "gst_library_error_quark") + (return-type "GQuark") +) + +(define-function gst_resource_error_quark + (c-name "gst_resource_error_quark") + (return-type "GQuark") +) + +(define-function gst_stream_error_quark + (c-name "gst_stream_error_quark") + (return-type "GQuark") +) + +(define-function gst_error_get_message + (c-name "gst_error_get_message") + (return-type "gchar*") + (parameters + '("GQuark" "domain") + '("gint" "code") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstevent.h + +(define-function _gst_event_initialize + (c-name "_gst_event_initialize") + (return-type "none") +) + +(define-function gst_event_get_type + (c-name "gst_event_get_type") + (return-type "GType") +) + +(define-function gst_event_new + (c-name "gst_event_new") + (is-constructor-of "GstEvent") + (return-type "GstEvent*") + (parameters + '("GstEventType" "type") + ) +) + +(define-method s_contains + (of-object "GstEventMask") + (c-name "gst_event_masks_contains") + (return-type "gboolean") + (parameters + '("GstEventMask*" "mask") + ) +) + +(define-function gst_event_new_seek + (c-name "gst_event_new_seek") + (return-type "GstEvent*") + (parameters + '("GstSeekType" "type") + '("gint64" "offset") + ) +) + +(define-function gst_event_new_segment_seek + (c-name "gst_event_new_segment_seek") + (return-type "GstEvent*") + (parameters + '("GstSeekType" "type") + '("gint64" "start") + '("gint64" "stop") + ) +) + +(define-function gst_event_new_size + (c-name "gst_event_new_size") + (return-type "GstEvent*") + (parameters + '("GstFormat" "format") + '("gint64" "value") + ) +) + +(define-function gst_event_new_discontinuous + (c-name "gst_event_new_discontinuous") + (return-type "GstEvent*") + (parameters + '("gboolean" "new_media") + '("GstFormat" "format1") + ) + (varargs #t) +) + +(define-function gst_event_new_discontinuous_valist + (c-name "gst_event_new_discontinuous_valist") + (return-type "GstEvent*") + (parameters + '("gboolean" "new_media") + '("GstFormat" "format1") + '("va_list" "var_args") + ) +) + +(define-method discont_get_value + (of-object "GstEvent") + (c-name "gst_event_discont_get_value") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + '("gint64*" "value") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstfilter.h + +(define-function gst_filter_run + (c-name "gst_filter_run") + (return-type "GList*") + (parameters + '("const-GList*" "list") + '("GstFilterFunc" "func") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstformat.h + +(define-function _gst_format_initialize + (c-name "_gst_format_initialize") + (return-type "none") +) + +(define-function gst_format_register + (c-name "gst_format_register") + (return-type "GstFormat") + (parameters + '("const-gchar*" "nick") + '("const-gchar*" "description") + ) +) + +(define-function gst_format_get_by_nick + (c-name "gst_format_get_by_nick") + (return-type "GstFormat") + (parameters + '("const-gchar*" "nick") + ) +) + +(define-method s_contains + (of-object "GstFormat") + (c-name "gst_formats_contains") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + ) +) + +(define-method get_details + (of-object "GstFormat") + (c-name "gst_format_get_details") + (return-type "const-GstFormatDefinition*") +) + +(define-function gst_format_get_definitions + (c-name "gst_format_get_definitions") + (return-type "const-GList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gst.h + +(define-function gst_init + (c-name "gst_init") + (return-type "none") + (parameters + '("int*" "argc") + '("char**[]" "argv") + ) +) + +(define-function gst_init_check + (c-name "gst_init_check") + (return-type "gboolean") + (parameters + '("int*" "argc") + '("char**[]" "argv") + ) +) + +(define-function gst_init_with_popt_table + (c-name "gst_init_with_popt_table") + (return-type "none") + (parameters + '("int*" "argc") + '("char**[]" "argv") + '("const-GstPoptOption*" "popt_options") + ) +) + +(define-function gst_init_check_with_popt_table + (c-name "gst_init_check_with_popt_table") + (return-type "gboolean") + (parameters + '("int*" "argc") + '("char**[]" "argv") + '("const-GstPoptOption*" "popt_options") + ) +) + +(define-function gst_init_get_popt_table + (c-name "gst_init_get_popt_table") + (return-type "const-GstPoptOption*") +) + +(define-function gst_use_threads + (c-name "gst_use_threads") + (return-type "none") + (parameters + '("gboolean" "use_threads") + ) +) + +(define-function gst_has_threads + (c-name "gst_has_threads") + (return-type "gboolean") +) + +(define-function gst_main + (c-name "gst_main") + (return-type "none") +) + +(define-function gst_main_quit + (c-name "gst_main_quit") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstindex.h + +(define-function gst_index_get_type + (c-name "gst_index_get_type") + (return-type "GType") +) + +(define-function gst_index_new + (c-name "gst_index_new") + (is-constructor-of "GstIndex") + (return-type "GstIndex*") +) + +(define-method commit + (of-object "GstIndex") + (c-name "gst_index_commit") + (return-type "none") + (parameters + '("gint" "id") + ) +) + +(define-method get_group + (of-object "GstIndex") + (c-name "gst_index_get_group") + (return-type "gint") +) + +(define-method new_group + (of-object "GstIndex") + (c-name "gst_index_new_group") + (return-type "gint") +) + +(define-method set_group + (of-object "GstIndex") + (c-name "gst_index_set_group") + (return-type "gboolean") + (parameters + '("gint" "groupnum") + ) +) + +(define-method set_certainty + (of-object "GstIndex") + (c-name "gst_index_set_certainty") + (return-type "none") + (parameters + '("GstIndexCertainty" "certainty") + ) +) + +(define-method get_certainty + (of-object "GstIndex") + (c-name "gst_index_get_certainty") + (return-type "GstIndexCertainty") +) + +(define-method set_filter + (of-object "GstIndex") + (c-name "gst_index_set_filter") + (return-type "none") + (parameters + '("GstIndexFilter" "filter") + '("gpointer" "user_data") + ) +) + +(define-method set_resolver + (of-object "GstIndex") + (c-name "gst_index_set_resolver") + (return-type "none") + (parameters + '("GstIndexResolver" "resolver") + '("gpointer" "user_data") + ) +) + +(define-method get_writer_id + (of-object "GstIndex") + (c-name "gst_index_get_writer_id") + (return-type "gboolean") + (parameters + '("GstObject*" "writer") + '("gint*" "id") + ) +) + +(define-method add_format + (of-object "GstIndex") + (c-name "gst_index_add_format") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstFormat" "format") + ) +) + +(define-method add_association + (of-object "GstIndex") + (c-name "gst_index_add_association") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + ) + (varargs #t) +) + +(define-method add_object + (of-object "GstIndex") + (c-name "gst_index_add_object") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("gchar*" "key") + '("GType" "type") + '("gpointer" "object") + ) +) + +(define-method add_id + (of-object "GstIndex") + (c-name "gst_index_add_id") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("gchar*" "description") + ) +) + +(define-method get_assoc_entry + (of-object "GstIndex") + (c-name "gst_index_get_assoc_entry") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstIndexLookupMethod" "method") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + ) +) + +(define-method get_assoc_entry_full + (of-object "GstIndex") + (c-name "gst_index_get_assoc_entry_full") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstIndexLookupMethod" "method") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + '("GCompareDataFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-function gst_index_entry_get_type + (c-name "gst_index_entry_get_type") + (return-type "GType") +) + +(define-method copy + (of-object "GstIndexEntry") + (c-name "gst_index_entry_copy") + (return-type "GstIndexEntry*") +) + +(define-method free + (of-object "GstIndexEntry") + (c-name "gst_index_entry_free") + (return-type "none") +) + +(define-method assoc_map + (of-object "GstIndexEntry") + (c-name "gst_index_entry_assoc_map") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + '("gint64*" "value") + ) +) + +(define-function gst_index_factory_get_type + (c-name "gst_index_factory_get_type") + (return-type "GType") +) + +(define-function gst_index_factory_new + (c-name "gst_index_factory_new") + (is-constructor-of "GstIndexFactory") + (return-type "GstIndexFactory*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "longdesc") + '("GType" "type") + ) +) + +(define-method destroy + (of-object "GstIndexFactory") + (c-name "gst_index_factory_destroy") + (return-type "none") +) + +(define-function gst_index_factory_find + (c-name "gst_index_factory_find") + (return-type "GstIndexFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method create + (of-object "GstIndexFactory") + (c-name "gst_index_factory_create") + (return-type "GstIndex*") +) + +(define-function gst_index_factory_make + (c-name "gst_index_factory_make") + (return-type "GstIndex*") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstinfo.h + +(define-function _gst_debug_init + (c-name "_gst_debug_init") + (return-type "none") +) + +(define-function gst_debug_log + (c-name "gst_debug_log") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function gst_debug_log_valist + (c-name "gst_debug_log_valist") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("const-gchar*" "format") + '("va_list" "args") + ) +) + +(define-method get + (of-object "GstDebugMessage") + (c-name "gst_debug_message_get") + (return-type "const-gchar*") +) + +(define-function gst_debug_log_default + (c-name "gst_debug_log_default") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("GstDebugMessage*" "message") + '("gpointer" "unused") + ) +) + +(define-method get_name + (of-object "GstDebugLevel") + (c-name "gst_debug_level_get_name") + (return-type "const-gchar*") +) + +(define-function gst_debug_add_log_function + (c-name "gst_debug_add_log_function") + (return-type "none") + (parameters + '("GstLogFunction" "func") + '("gpointer" "data") + ) +) + +(define-function gst_debug_remove_log_function + (c-name "gst_debug_remove_log_function") + (return-type "guint") + (parameters + '("GstLogFunction" "func") + ) +) + +(define-function gst_debug_remove_log_function_by_data + (c-name "gst_debug_remove_log_function_by_data") + (return-type "guint") + (parameters + '("gpointer" "data") + ) +) + +(define-function gst_debug_set_active + (c-name "gst_debug_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-function gst_debug_is_active + (c-name "gst_debug_is_active") + (return-type "gboolean") +) + +(define-function gst_debug_set_colored + (c-name "gst_debug_set_colored") + (return-type "none") + (parameters + '("gboolean" "colored") + ) +) + +(define-function gst_debug_is_colored + (c-name "gst_debug_is_colored") + (return-type "gboolean") +) + +(define-function gst_debug_set_default_threshold + (c-name "gst_debug_set_default_threshold") + (return-type "none") + (parameters + '("GstDebugLevel" "level") + ) +) + +(define-function gst_debug_get_default_threshold + (c-name "gst_debug_get_default_threshold") + (return-type "GstDebugLevel") +) + +(define-function gst_debug_set_threshold_for_name + (c-name "gst_debug_set_threshold_for_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("GstDebugLevel" "level") + ) +) + +(define-function gst_debug_unset_threshold_for_name + (c-name "gst_debug_unset_threshold_for_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function _gst_debug_category_new + (c-name "_gst_debug_category_new") + (is-constructor-of "GstDebugCategory") + (return-type "GstDebugCategory*") + (parameters + '("gchar*" "name") + '("guint" "color") + '("gchar*" "description") + ) +) + +(define-method free + (of-object "GstDebugCategory") + (c-name "gst_debug_category_free") + (return-type "none") +) + +(define-method set_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_set_threshold") + (return-type "none") + (parameters + '("GstDebugLevel" "level") + ) +) + +(define-method reset_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_reset_threshold") + (return-type "none") +) + +(define-method get_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_threshold") + (return-type "GstDebugLevel") +) + +(define-method get_name + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_name") + (return-type "const-gchar*") +) + +(define-method get_color + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_color") + (return-type "guint") +) + +(define-method get_description + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_description") + (return-type "const-gchar*") +) + +(define-function gst_debug_get_all_categories + (c-name "gst_debug_get_all_categories") + (return-type "GSList*") +) + +(define-function gst_debug_construct_term_color + (c-name "gst_debug_construct_term_color") + (return-type "gchar*") + (parameters + '("guint" "colorinfo") + ) +) + +(define-function _gst_debug_register_funcptr + (c-name "_gst_debug_register_funcptr") + (return-type "void*") + (parameters + '("void*" "ptr") + '("gchar*" "ptrname") + ) +) + +(define-function _gst_debug_nameof_funcptr + (c-name "_gst_debug_nameof_funcptr") + (return-type "const-gchar*") + (parameters + '("void*" "ptr") + ) +) + +(define-function gst_debug_print_stack_trace + (c-name "gst_debug_print_stack_trace") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstinterface.h + +(define-function gst_implements_interface_get_type + (c-name "gst_implements_interface_get_type") + (return-type "GType") +) + +(define-method implements_interface + (of-object "GstElement") + (c-name "gst_element_implements_interface") + (return-type "gboolean") + (parameters + '("GType" "iface_type") + ) +) + +(define-function gst_implements_interface_cast + (c-name "gst_implements_interface_cast") + (return-type "gpointer") + (parameters + '("gpointer" "from") + '("GType" "type") + ) +) + +(define-function gst_implements_interface_check + (c-name "gst_implements_interface_check") + (return-type "gboolean") + (parameters + '("gpointer" "from") + '("GType" "type") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstlog.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmacros.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmarshal.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmemchunk.h + +(define-function gst_mem_chunk_new + (c-name "gst_mem_chunk_new") + (is-constructor-of "GstMemChunk") + (return-type "GstMemChunk*") + (parameters + '("gchar*" "name") + '("gint" "atom_size") + '("gulong" "area_size") + '("gint" "type") + ) +) + +(define-method destroy + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_destroy") + (return-type "none") +) + +(define-method alloc + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_alloc") + (return-type "gpointer") +) + +(define-method alloc0 + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_alloc0") + (return-type "gpointer") +) + +(define-method free + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_free") + (return-type "none") + (parameters + '("gpointer" "mem") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstobject.h + +(define-function gst_object_get_type + (c-name "gst_object_get_type") + (return-type "GType") +) + +(define-method set_name + (of-object "GstObject") + (c-name "gst_object_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_name + (of-object "GstObject") + (c-name "gst_object_get_name") + (return-type "const-gchar*") +) + +(define-method set_parent + (of-object "GstObject") + (c-name "gst_object_set_parent") + (return-type "none") + (parameters + '("GstObject*" "parent") + ) +) + +(define-method get_parent + (of-object "GstObject") + (c-name "gst_object_get_parent") + (return-type "GstObject*") +) + +(define-method unparent + (of-object "GstObject") + (c-name "gst_object_unparent") + (return-type "none") +) + +(define-function gst_object_default_deep_notify + (c-name "gst_object_default_deep_notify") + (return-type "none") + (parameters + '("GObject*" "object") + '("GstObject*" "orig") + '("GParamSpec*" "pspec") + '("gchar**" "excluded_props") + ) +) + +(define-function gst_object_check_uniqueness + (c-name "gst_object_check_uniqueness") + (return-type "gboolean") + (parameters + '("GList*" "list") + '("const-gchar*" "name") + ) +) + +(define-method save_thyself + (of-object "GstObject") + (c-name "gst_object_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-method restore_thyself + (of-object "GstObject") + (c-name "gst_object_restore_thyself") + (return-type "none") + (parameters + '("xmlNodePtr" "self") + ) +) + +(define-method ref + (of-object "GstObject") + (c-name "gst_object_ref") + (return-type "GstObject*") +) + +(define-method unref + (of-object "GstObject") + (c-name "gst_object_unref") + (return-type "none") +) + +(define-method sink + (of-object "GstObject") + (c-name "gst_object_sink") + (return-type "none") +) + +(define-function gst_object_replace + (c-name "gst_object_replace") + (return-type "none") + (parameters + '("GstObject**" "oldobj") + '("GstObject*" "newobj") + ) +) + +(define-method get_path_string + (of-object "GstObject") + (c-name "gst_object_get_path_string") + (return-type "gchar*") +) + +(define-function gst_class_signal_connect + (c-name "gst_class_signal_connect") + (return-type "guint") + (parameters + '("GstObjectClass*" "klass") + '("const-gchar*" "name") + '("gpointer" "func") + '("gpointer" "func_data") + ) +) + +(define-function gst_class_signal_emit_by_name + (c-name "gst_class_signal_emit_by_name") + (return-type "none") + (parameters + '("GstObject*" "object") + '("const-gchar*" "name") + '("xmlNodePtr" "self") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpad.h + +(define-function gst_pad_get_type + (c-name "gst_pad_get_type") + (return-type "GType") +) + +(define-function gst_real_pad_get_type + (c-name "gst_real_pad_get_type") + (return-type "GType") +) + +(define-function gst_ghost_pad_get_type + (c-name "gst_ghost_pad_get_type") + (return-type "GType") +) + +(define-function gst_pad_new + (c-name "gst_pad_new") + (is-constructor-of "GstPad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + '("GstPadDirection" "direction") + ) +) + +(define-function gst_pad_new_from_template + (c-name "gst_pad_new_from_template") + (return-type "GstPad*") + (parameters + '("GstPadTemplate*" "templ") + '("const-gchar*" "name") + ) +) + +(define-function gst_pad_custom_new + (c-name "gst_pad_custom_new") + (is-constructor-of "GstPadCustom") + (return-type "GstPad*") + (parameters + '("GType" "type") + '("const-gchar*" "name") + '("GstPadDirection" "direction") + ) +) + +(define-function gst_pad_custom_new_from_template + (c-name "gst_pad_custom_new_from_template") + (return-type "GstPad*") + (parameters + '("GType" "type") + '("GstPadTemplate*" "templ") + '("const-gchar*" "name") + ) +) + +(define-method set_name + (of-object "GstPad") + (c-name "gst_pad_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_name + (of-object "GstPad") + (c-name "gst_pad_get_name") + (return-type "const-gchar*") +) + +(define-method get_direction + (of-object "GstPad") + (c-name "gst_pad_get_direction") + (return-type "GstPadDirection") +) + +(define-method set_active + (of-object "GstPad") + (c-name "gst_pad_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method is_active + (of-object "GstPad") + (c-name "gst_pad_is_active") + (return-type "gboolean") +) + +(define-method set_element_private + (of-object "GstPad") + (c-name "gst_pad_set_element_private") + (return-type "none") + (parameters + '("gpointer" "priv") + ) +) + +(define-method get_element_private + (of-object "GstPad") + (c-name "gst_pad_get_element_private") + (return-type "gpointer") +) + +(define-method set_parent + (of-object "GstPad") + (c-name "gst_pad_set_parent") + (return-type "none") + (parameters + '("GstElement*" "parent") + ) +) + +(define-method get_parent + (of-object "GstPad") + (c-name "gst_pad_get_parent") + (return-type "GstElement*") +) + +(define-method get_real_parent + (of-object "GstPad") + (c-name "gst_pad_get_real_parent") + (return-type "GstElement*") +) + +(define-method get_scheduler + (of-object "GstPad") + (c-name "gst_pad_get_scheduler") + (return-type "GstScheduler*") +) + +(define-method add_ghost_pad + (of-object "GstPad") + (c-name "gst_pad_add_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "ghostpad") + ) +) + +(define-method remove_ghost_pad + (of-object "GstPad") + (c-name "gst_pad_remove_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "ghostpad") + ) +) + +(define-method get_ghost_pad_list + (of-object "GstPad") + (c-name "gst_pad_get_ghost_pad_list") + (return-type "GList*") +) + +(define-method get_pad_template + (of-object "GstPad") + (c-name "gst_pad_get_pad_template") + (return-type "GstPadTemplate*") +) + +(define-method set_bufferalloc_function + (of-object "GstPad") + (c-name "gst_pad_set_bufferalloc_function") + (return-type "none") + (parameters + '("GstPadBufferAllocFunction" "bufferalloc") + ) +) + +(define-method alloc_buffer + (of-object "GstPad") + (c-name "gst_pad_alloc_buffer") + (return-type "GstBuffer*") + (parameters + '("guint64" "offset") + '("gint" "size") + ) +) + +(define-method set_chain_function + (of-object "GstPad") + (c-name "gst_pad_set_chain_function") + (return-type "none") + (parameters + '("GstPadChainFunction" "chain") + ) +) + +(define-method set_get_function + (of-object "GstPad") + (c-name "gst_pad_set_get_function") + (return-type "none") + (parameters + '("GstPadGetFunction" "get") + ) +) + +(define-method set_event_function + (of-object "GstPad") + (c-name "gst_pad_set_event_function") + (return-type "none") + (parameters + '("GstPadEventFunction" "event") + ) +) + +(define-method set_event_mask_function + (of-object "GstPad") + (c-name "gst_pad_set_event_mask_function") + (return-type "none") + (parameters + '("GstPadEventMaskFunction" "mask_func") + ) +) + +(define-method get_event_masks + (of-object "GstPad") + (c-name "gst_pad_get_event_masks") + (return-type "const-GstEventMask*") +) + +(define-method get_event_masks_default + (of-object "GstPad") + (c-name "gst_pad_get_event_masks_default") + (return-type "const-GstEventMask*") +) + +(define-method set_link_function + (of-object "GstPad") + (c-name "gst_pad_set_link_function") + (return-type "none") + (parameters + '("GstPadLinkFunction" "link") + ) +) + +(define-method can_link + (of-object "GstPad") + (c-name "gst_pad_can_link") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method can_link_filtered + (of-object "GstPad") + (c-name "gst_pad_can_link_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method set_unlink_function + (of-object "GstPad") + (c-name "gst_pad_set_unlink_function") + (return-type "none") + (parameters + '("GstPadUnlinkFunction" "unlink") + ) +) + +(define-method link + (of-object "GstPad") + (c-name "gst_pad_link") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method link_filtered + (of-object "GstPad") + (c-name "gst_pad_link_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method unlink + (of-object "GstPad") + (c-name "gst_pad_unlink") + (return-type "none") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method is_linked + (of-object "GstPad") + (c-name "gst_pad_is_linked") + (return-type "gboolean") +) + +(define-method get_peer + (of-object "GstPad") + (c-name "gst_pad_get_peer") + (return-type "GstPad*") +) + +(define-method get_negotiated_caps + (of-object "GstPad") + (c-name "gst_pad_get_negotiated_caps") + (return-type "const-GstCaps*") +) + +(define-method is_negotiated + (of-object "GstPad") + (c-name "gst_pad_is_negotiated") + (return-type "gboolean") +) + +(define-method get_caps + (of-object "GstPad") + (c-name "gst_pad_get_caps") + (return-type "GstCaps*") +) + +(define-method get_pad_template_caps + (of-object "GstPad") + (c-name "gst_pad_get_pad_template_caps") + (return-type "const-GstCaps*") +) + +(define-method try_set_caps + (of-object "GstPad") + (c-name "gst_pad_try_set_caps") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method try_set_caps_nonfixed + (of-object "GstPad") + (c-name "gst_pad_try_set_caps_nonfixed") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method check_compatibility + (of-object "GstPad") + (c-name "gst_pad_check_compatibility") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method set_getcaps_function + (of-object "GstPad") + (c-name "gst_pad_set_getcaps_function") + (return-type "none") + (parameters + '("GstPadGetCapsFunction" "getcaps") + ) +) + +(define-method set_fixate_function + (of-object "GstPad") + (c-name "gst_pad_set_fixate_function") + (return-type "none") + (parameters + '("GstPadFixateFunction" "fixate") + ) +) + +(define-method proxy_getcaps + (of-object "GstPad") + (c-name "gst_pad_proxy_getcaps") + (return-type "GstCaps*") +) + +(define-method proxy_pad_link + (of-object "GstPad") + (c-name "gst_pad_proxy_pad_link") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method proxy_fixate + (of-object "GstPad") + (c-name "gst_pad_proxy_fixate") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method proxy_link + (of-object "GstPad") + (c-name "gst_pad_proxy_link") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method set_explicit_caps + (of-object "GstPad") + (c-name "gst_pad_set_explicit_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method use_explicit_caps + (of-object "GstPad") + (c-name "gst_pad_use_explicit_caps") + (return-type "none") +) + +(define-method relink_filtered + (of-object "GstPad") + (c-name "gst_pad_relink_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method perform_negotiate + (of-object "GstPad") + (c-name "gst_pad_perform_negotiate") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method renegotiate + (of-object "GstPad") + (c-name "gst_pad_renegotiate") + (return-type "GstPadLinkReturn") +) + +(define-method unnegotiate + (of-object "GstPad") + (c-name "gst_pad_unnegotiate") + (return-type "none") +) + +(define-method try_relink_filtered + (of-object "GstPad") + (c-name "gst_pad_try_relink_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method get_allowed_caps + (of-object "GstPad") + (c-name "gst_pad_get_allowed_caps") + (return-type "GstCaps*") +) + +(define-method caps_change_notify + (of-object "GstPad") + (c-name "gst_pad_caps_change_notify") + (return-type "none") +) + +(define-method recover_caps_error + (of-object "GstPad") + (c-name "gst_pad_recover_caps_error") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "allowed") + ) +) + +(define-method push + (of-object "GstPad") + (c-name "gst_pad_push") + (return-type "none") + (parameters + '("GstData*" "data") + ) +) + +(define-method pull + (of-object "GstPad") + (c-name "gst_pad_pull") + (return-type "GstData*") +) + +(define-method send_event + (of-object "GstPad") + (c-name "gst_pad_send_event") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-method event_default + (of-object "GstPad") + (c-name "gst_pad_event_default") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-function gst_pad_selectv + (c-name "gst_pad_selectv") + (return-type "GstPad*") + (parameters + '("GList*" "padlist") + ) +) + +(define-method select + (of-object "GstPad") + (c-name "gst_pad_select") + (return-type "GstPad*") + (parameters + ) + (varargs #t) +) + +(define-method select_valist + (of-object "GstPad") + (c-name "gst_pad_select_valist") + (return-type "GstPad*") + (parameters + '("va_list" "varargs") + ) +) + +(define-method set_formats_function + (of-object "GstPad") + (c-name "gst_pad_set_formats_function") + (return-type "none") + (parameters + '("GstPadFormatsFunction" "formats") + ) +) + +(define-method get_formats + (of-object "GstPad") + (c-name "gst_pad_get_formats") + (return-type "const-GstFormat*") +) + +(define-method get_formats_default + (of-object "GstPad") + (c-name "gst_pad_get_formats_default") + (return-type "const-GstFormat*") +) + +(define-method set_convert_function + (of-object "GstPad") + (c-name "gst_pad_set_convert_function") + (return-type "none") + (parameters + '("GstPadConvertFunction" "convert") + ) +) + +(define-method convert + (of-object "GstPad") + (c-name "gst_pad_convert") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method convert_default + (of-object "GstPad") + (c-name "gst_pad_convert_default") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method set_query_function + (of-object "GstPad") + (c-name "gst_pad_set_query_function") + (return-type "none") + (parameters + '("GstPadQueryFunction" "query") + ) +) + +(define-method set_query_type_function + (of-object "GstPad") + (c-name "gst_pad_set_query_type_function") + (return-type "none") + (parameters + '("GstPadQueryTypeFunction" "type_func") + ) +) + +(define-method get_query_types + (of-object "GstPad") + (c-name "gst_pad_get_query_types") + (return-type "const-GstQueryType*") +) + +(define-method get_query_types_default + (of-object "GstPad") + (c-name "gst_pad_get_query_types_default") + (return-type "const-GstQueryType*") +) + +(define-method query + (of-object "GstPad") + (c-name "gst_pad_query") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method query_default + (of-object "GstPad") + (c-name "gst_pad_query_default") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method set_internal_link_function + (of-object "GstPad") + (c-name "gst_pad_set_internal_link_function") + (return-type "none") + (parameters + '("GstPadIntLinkFunction" "intlink") + ) +) + +(define-method get_internal_links + (of-object "GstPad") + (c-name "gst_pad_get_internal_links") + (return-type "GList*") +) + +(define-method get_internal_links_default + (of-object "GstPad") + (c-name "gst_pad_get_internal_links_default") + (return-type "GList*") +) + +(define-method dispatcher + (of-object "GstPad") + (c-name "gst_pad_dispatcher") + (return-type "gboolean") + (parameters + '("GstPadDispatcherFunction" "dispatch") + '("gpointer" "data") + ) +) + +(define-function gst_pad_load_and_link + (c-name "gst_pad_load_and_link") + (return-type "none") + (parameters + '("xmlNodePtr" "self") + '("GstObject*" "parent") + ) +) + +(define-function gst_ghost_pad_new + (c-name "gst_ghost_pad_new") + (is-constructor-of "GstGhostPad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + '("GstPad*" "pad") + ) +) + +(define-function gst_pad_template_get_type + (c-name "gst_pad_template_get_type") + (return-type "GType") +) + +(define-function gst_pad_template_new + (c-name "gst_pad_template_new") + (is-constructor-of "GstPadTemplate") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name_template") + '("GstPadDirection" "direction") + '("GstPadPresence" "presence") + '("GstCaps*" "caps") + ) +) + +(define-method get + (of-object "GstStaticPadTemplate") + (c-name "gst_static_pad_template_get") + (return-type "GstPadTemplate*") +) + +(define-method get_caps + (of-object "GstPadTemplate") + (c-name "gst_pad_template_get_caps") + (return-type "const-GstCaps*") +) + +(define-method get_caps_by_name + (of-object "GstPadTemplate") + (c-name "gst_pad_template_get_caps_by_name") + (return-type "const-GstCaps*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_ghost_pad_save_thyself + (c-name "gst_ghost_pad_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("GstPad*" "pad") + '("xmlNodePtr" "parent") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstparse.h + +(define-function gst_parse_error_quark + (c-name "gst_parse_error_quark") + (return-type "GQuark") +) + +(define-function gst_parse_launch + (c-name "gst_parse_launch") + (return-type "GstElement*") + (parameters + '("const-gchar*" "pipeline_description") + '("GError**" "error") + ) +) + +(define-function gst_parse_launchv + (c-name "gst_parse_launchv") + (return-type "GstElement*") + (parameters + '("const-gchar**" "argv") + '("GError**" "error") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpipeline.h + +(define-function gst_pipeline_get_type + (c-name "gst_pipeline_get_type") + (return-type "GType") +) + +(define-function gst_pipeline_new + (c-name "gst_pipeline_new") + (is-constructor-of "GstPipeline") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpluginfeature.h + +(define-function gst_plugin_feature_get_type + (c-name "gst_plugin_feature_get_type") + (return-type "GType") +) + +(define-method ensure_loaded + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_ensure_loaded") + (return-type "gboolean") +) + +(define-method unload_thyself + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_unload_thyself") + (return-type "none") +) + +(define-method type_name_filter + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_type_name_filter") + (return-type "gboolean") + (parameters + '("GstTypeNameData*" "data") + ) +) + +(define-method set_rank + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_set_rank") + (return-type "none") + (parameters + '("guint" "rank") + ) +) + +(define-method set_name + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_rank + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_get_rank") + (return-type "guint") +) + +(define-method get_name + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_get_name") + (return-type "const-gchar*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstplugin.h + +(define-function gst_plugin_error_quark + (c-name "gst_plugin_error_quark") + (return-type "GQuark") +) + +(define-function gst_plugin_get_type + (c-name "gst_plugin_get_type") + (return-type "GType") +) + +(define-function _gst_plugin_initialize + (c-name "_gst_plugin_initialize") + (return-type "none") +) + +(define-function _gst_plugin_register_static + (c-name "_gst_plugin_register_static") + (return-type "none") + (parameters + '("GstPluginDesc*" "desc") + ) +) + +(define-method get_name + (of-object "GstPlugin") + (c-name "gst_plugin_get_name") + (return-type "const-gchar*") +) + +(define-method get_description + (of-object "GstPlugin") + (c-name "gst_plugin_get_description") + (return-type "const-gchar*") +) + +(define-method get_filename + (of-object "GstPlugin") + (c-name "gst_plugin_get_filename") + (return-type "const-gchar*") +) + +(define-method get_license + (of-object "GstPlugin") + (c-name "gst_plugin_get_license") + (return-type "const-gchar*") +) + +(define-method get_package + (of-object "GstPlugin") + (c-name "gst_plugin_get_package") + (return-type "const-gchar*") +) + +(define-method get_origin + (of-object "GstPlugin") + (c-name "gst_plugin_get_origin") + (return-type "const-gchar*") +) + +(define-method get_module + (of-object "GstPlugin") + (c-name "gst_plugin_get_module") + (return-type "GModule*") +) + +(define-method is_loaded + (of-object "GstPlugin") + (c-name "gst_plugin_is_loaded") + (return-type "gboolean") +) + +(define-method feature_filter + (of-object "GstPlugin") + (c-name "gst_plugin_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_plugin_list_feature_filter + (c-name "gst_plugin_list_feature_filter") + (return-type "GList*") + (parameters + '("GList*" "list") + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method name_filter + (of-object "GstPlugin") + (c-name "gst_plugin_name_filter") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_feature_list + (of-object "GstPlugin") + (c-name "gst_plugin_get_feature_list") + (return-type "GList*") +) + +(define-method find_feature + (of-object "GstPlugin") + (c-name "gst_plugin_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-function gst_plugin_load_file + (c-name "gst_plugin_load_file") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "filename") + '("GError**" "error") + ) +) + +(define-method unload_plugin + (of-object "GstPlugin") + (c-name "gst_plugin_unload_plugin") + (return-type "gboolean") +) + +(define-method add_feature + (of-object "GstPlugin") + (c-name "gst_plugin_add_feature") + (return-type "none") + (parameters + '("GstPluginFeature*" "feature") + ) +) + +(define-function gst_plugin_load + (c-name "gst_plugin_load") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_library_load + (c-name "gst_library_load") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstprobe.h + +(define-function gst_probe_new + (c-name "gst_probe_new") + (is-constructor-of "GstProbe") + (return-type "GstProbe*") + (parameters + '("gboolean" "single_shot") + '("GstProbeCallback" "callback") + '("gpointer" "user_data") + ) +) + +(define-method destroy + (of-object "GstProbe") + (c-name "gst_probe_destroy") + (return-type "none") +) + +(define-method perform + (of-object "GstProbe") + (c-name "gst_probe_perform") + (return-type "gboolean") + (parameters + '("GstData**" "data") + ) +) + +(define-function gst_probe_dispatcher_new + (c-name "gst_probe_dispatcher_new") + (is-constructor-of "GstProbeDispatcher") + (return-type "GstProbeDispatcher*") +) + +(define-method destroy + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_destroy") + (return-type "none") +) + +(define-method init + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_init") + (return-type "none") +) + +(define-method set_active + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method add_probe + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_add_probe") + (return-type "none") + (parameters + '("GstProbe*" "probe") + ) +) + +(define-method remove_probe + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_remove_probe") + (return-type "none") + (parameters + '("GstProbe*" "probe") + ) +) + +(define-method dispatch + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_dispatch") + (return-type "gboolean") + (parameters + '("GstData**" "data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstquery.h + +(define-function _gst_query_type_initialize + (c-name "_gst_query_type_initialize") + (return-type "none") +) + +(define-function gst_query_type_register + (c-name "gst_query_type_register") + (return-type "GstQueryType") + (parameters + '("const-gchar*" "nick") + '("const-gchar*" "description") + ) +) + +(define-function gst_query_type_get_by_nick + (c-name "gst_query_type_get_by_nick") + (return-type "GstQueryType") + (parameters + '("const-gchar*" "nick") + ) +) + +(define-method s_contains + (of-object "GstQueryType") + (c-name "gst_query_types_contains") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + ) +) + +(define-method get_details + (of-object "GstQueryType") + (c-name "gst_query_type_get_details") + (return-type "const-GstQueryTypeDefinition*") +) + +(define-function gst_query_type_get_definitions + (c-name "gst_query_type_get_definitions") + (return-type "const-GList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstqueue.h + +(define-function gst_queue_get_type + (c-name "gst_queue_get_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstregistry.h + +(define-function gst_registry_get_type + (c-name "gst_registry_get_type") + (return-type "GType") +) + +(define-method load + (of-object "GstRegistry") + (c-name "gst_registry_load") + (return-type "gboolean") +) + +(define-method is_loaded + (of-object "GstRegistry") + (c-name "gst_registry_is_loaded") + (return-type "gboolean") +) + +(define-method save + (of-object "GstRegistry") + (c-name "gst_registry_save") + (return-type "gboolean") +) + +(define-method rebuild + (of-object "GstRegistry") + (c-name "gst_registry_rebuild") + (return-type "gboolean") +) + +(define-method unload + (of-object "GstRegistry") + (c-name "gst_registry_unload") + (return-type "gboolean") +) + +(define-method add_path + (of-object "GstRegistry") + (c-name "gst_registry_add_path") + (return-type "none") + (parameters + '("const-gchar*" "path") + ) +) + +(define-method get_path_list + (of-object "GstRegistry") + (c-name "gst_registry_get_path_list") + (return-type "GList*") +) + +(define-method clear_paths + (of-object "GstRegistry") + (c-name "gst_registry_clear_paths") + (return-type "none") +) + +(define-method add_plugin + (of-object "GstRegistry") + (c-name "gst_registry_add_plugin") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method remove_plugin + (of-object "GstRegistry") + (c-name "gst_registry_remove_plugin") + (return-type "none") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method plugin_filter + (of-object "GstRegistry") + (c-name "gst_registry_plugin_filter") + (return-type "GList*") + (parameters + '("GstPluginFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method feature_filter + (of-object "GstRegistry") + (c-name "gst_registry_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method find_plugin + (of-object "GstRegistry") + (c-name "gst_registry_find_plugin") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method find_feature + (of-object "GstRegistry") + (c-name "gst_registry_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-method load_plugin + (of-object "GstRegistry") + (c-name "gst_registry_load_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method unload_plugin + (of-object "GstRegistry") + (c-name "gst_registry_unload_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method update_plugin + (of-object "GstRegistry") + (c-name "gst_registry_update_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstregistrypool.h + +(define-function gst_registry_pool_list + (c-name "gst_registry_pool_list") + (return-type "GList*") +) + +(define-method pool_add + (of-object "GstRegistry") + (c-name "gst_registry_pool_add") + (return-type "none") + (parameters + '("guint" "priority") + ) +) + +(define-method pool_remove + (of-object "GstRegistry") + (c-name "gst_registry_pool_remove") + (return-type "none") +) + +(define-function gst_registry_pool_add_plugin + (c-name "gst_registry_pool_add_plugin") + (return-type "none") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-function gst_registry_pool_load_all + (c-name "gst_registry_pool_load_all") + (return-type "none") +) + +(define-function gst_registry_pool_plugin_filter + (c-name "gst_registry_pool_plugin_filter") + (return-type "GList*") + (parameters + '("GstPluginFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_registry_pool_feature_filter + (c-name "gst_registry_pool_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_registry_pool_plugin_list + (c-name "gst_registry_pool_plugin_list") + (return-type "GList*") +) + +(define-function gst_registry_pool_feature_list + (c-name "gst_registry_pool_feature_list") + (return-type "GList*") + (parameters + '("GType" "type") + ) +) + +(define-function gst_registry_pool_find_plugin + (c-name "gst_registry_pool_find_plugin") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_registry_pool_find_feature + (c-name "gst_registry_pool_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-function gst_registry_pool_get_prefered + (c-name "gst_registry_pool_get_prefered") + (return-type "GstRegistry*") + (parameters + '("GstRegistryFlags" "flags") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstscheduler.h + +(define-function gst_scheduler_get_type + (c-name "gst_scheduler_get_type") + (return-type "GType") +) + +(define-method setup + (of-object "GstScheduler") + (c-name "gst_scheduler_setup") + (return-type "none") +) + +(define-method reset + (of-object "GstScheduler") + (c-name "gst_scheduler_reset") + (return-type "none") +) + +(define-method add_element + (of-object "GstScheduler") + (c-name "gst_scheduler_add_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method remove_element + (of-object "GstScheduler") + (c-name "gst_scheduler_remove_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method add_scheduler + (of-object "GstScheduler") + (c-name "gst_scheduler_add_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched2") + ) +) + +(define-method remove_scheduler + (of-object "GstScheduler") + (c-name "gst_scheduler_remove_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched2") + ) +) + +(define-method state_transition + (of-object "GstScheduler") + (c-name "gst_scheduler_state_transition") + (return-type "GstElementStateReturn") + (parameters + '("GstElement*" "element") + '("gint" "transition") + ) +) + +(define-method scheduling_change + (of-object "GstScheduler") + (c-name "gst_scheduler_scheduling_change") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method lock_element + (of-object "GstScheduler") + (c-name "gst_scheduler_lock_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method unlock_element + (of-object "GstScheduler") + (c-name "gst_scheduler_unlock_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method yield + (of-object "GstScheduler") + (c-name "gst_scheduler_yield") + (return-type "gboolean") + (parameters + '("GstElement*" "element") + ) +) + +(define-method interrupt + (of-object "GstScheduler") + (c-name "gst_scheduler_interrupt") + (return-type "gboolean") + (parameters + '("GstElement*" "element") + ) +) + +(define-method error + (of-object "GstScheduler") + (c-name "gst_scheduler_error") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method pad_link + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_link") + (return-type "none") + (parameters + '("GstPad*" "srcpad") + '("GstPad*" "sinkpad") + ) +) + +(define-method pad_unlink + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_unlink") + (return-type "none") + (parameters + '("GstPad*" "srcpad") + '("GstPad*" "sinkpad") + ) +) + +(define-method pad_select + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_select") + (return-type "GstPad*") + (parameters + '("GList*" "padlist") + ) +) + +(define-method clock_wait + (of-object "GstScheduler") + (c-name "gst_scheduler_clock_wait") + (return-type "GstClockReturn") + (parameters + '("GstElement*" "element") + '("GstClockID" "id") + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method iterate + (of-object "GstScheduler") + (c-name "gst_scheduler_iterate") + (return-type "gboolean") +) + +(define-method use_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_use_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method set_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_set_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method get_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_get_clock") + (return-type "GstClock*") +) + +(define-method auto_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_auto_clock") + (return-type "none") +) + +(define-method show + (of-object "GstScheduler") + (c-name "gst_scheduler_show") + (return-type "none") +) + +(define-function gst_scheduler_factory_get_type + (c-name "gst_scheduler_factory_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_factory_new + (c-name "gst_scheduler_factory_new") + (is-constructor-of "GstSchedulerFactory") + (return-type "GstSchedulerFactory*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "longdesc") + '("GType" "type") + ) +) + +(define-method destroy + (of-object "GstSchedulerFactory") + (c-name "gst_scheduler_factory_destroy") + (return-type "none") +) + +(define-function gst_scheduler_factory_find + (c-name "gst_scheduler_factory_find") + (return-type "GstSchedulerFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method create + (of-object "GstSchedulerFactory") + (c-name "gst_scheduler_factory_create") + (return-type "GstScheduler*") + (parameters + '("GstElement*" "parent") + ) +) + +(define-function gst_scheduler_factory_make + (c-name "gst_scheduler_factory_make") + (return-type "GstScheduler*") + (parameters + '("const-gchar*" "name") + '("GstElement*" "parent") + ) +) + +(define-function gst_scheduler_factory_set_default_name + (c-name "gst_scheduler_factory_set_default_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_scheduler_factory_get_default_name + (c-name "gst_scheduler_factory_get_default_name") + (return-type "const-gchar*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gststructure.h + +(define-function gst_structure_get_type + (c-name "gst_structure_get_type") + (return-type "GType") +) + +(define-function _gst_structure_initialize + (c-name "_gst_structure_initialize") + (return-type "none") +) + +(define-function gst_structure_empty_new + (c-name "gst_structure_empty_new") + (is-constructor-of "GstStructureEmpty") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_structure_id_empty_new + (c-name "gst_structure_id_empty_new") + (is-constructor-of "GstStructureIdEmpty") + (return-type "GstStructure*") + (parameters + '("GQuark" "quark") + ) +) + +(define-function gst_structure_new + (c-name "gst_structure_new") + (is-constructor-of "GstStructure") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "firstfield") + ) + (varargs #t) +) + +(define-function gst_structure_new_valist + (c-name "gst_structure_new_valist") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "firstfield") + '("va_list" "varargs") + ) +) + +(define-method copy + (of-object "GstStructure") + (c-name "gst_structure_copy") + (return-type "GstStructure*") +) + +(define-method free + (of-object "GstStructure") + (c-name "gst_structure_free") + (return-type "none") +) + +(define-method get_name + (of-object "GstStructure") + (c-name "gst_structure_get_name") + (return-type "const-gchar*") +) + +(define-method set_name + (of-object "GstStructure") + (c-name "gst_structure_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method id_set_value + (of-object "GstStructure") + (c-name "gst_structure_id_set_value") + (return-type "none") + (parameters + '("GQuark" "field") + '("const-GValue*" "value") + ) +) + +(define-method set_value + (of-object "GstStructure") + (c-name "gst_structure_set_value") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("const-GValue*" "value") + ) +) + +(define-method set + (of-object "GstStructure") + (c-name "gst_structure_set") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) + (varargs #t) +) + +(define-method set_valist + (of-object "GstStructure") + (c-name "gst_structure_set_valist") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("va_list" "varargs") + ) +) + +(define-method id_get_value + (of-object "GstStructure") + (c-name "gst_structure_id_get_value") + (return-type "const-GValue*") + (parameters + '("GQuark" "field") + ) +) + +(define-method get_value + (of-object "GstStructure") + (c-name "gst_structure_get_value") + (return-type "const-GValue*") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method remove_field + (of-object "GstStructure") + (c-name "gst_structure_remove_field") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method remove_fields + (of-object "GstStructure") + (c-name "gst_structure_remove_fields") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) + (varargs #t) +) + +(define-method remove_fields_valist + (of-object "GstStructure") + (c-name "gst_structure_remove_fields_valist") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("va_list" "varargs") + ) +) + +(define-method remove_all_fields + (of-object "GstStructure") + (c-name "gst_structure_remove_all_fields") + (return-type "none") +) + +(define-method get_field_type + (of-object "GstStructure") + (c-name "gst_structure_get_field_type") + (return-type "GType") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method foreach + (of-object "GstStructure") + (c-name "gst_structure_foreach") + (return-type "gboolean") + (parameters + '("GstStructureForeachFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method n_fields + (of-object "GstStructure") + (c-name "gst_structure_n_fields") + (return-type "gint") +) + +(define-method has_field + (of-object "GstStructure") + (c-name "gst_structure_has_field") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method has_field_typed + (of-object "GstStructure") + (c-name "gst_structure_has_field_typed") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("GType" "type") + ) +) + +(define-method get_boolean + (of-object "GstStructure") + (c-name "gst_structure_get_boolean") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gboolean*" "value") + ) +) + +(define-method get_int + (of-object "GstStructure") + (c-name "gst_structure_get_int") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gint*" "value") + ) +) + +(define-method get_fourcc + (of-object "GstStructure") + (c-name "gst_structure_get_fourcc") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("guint32*" "value") + ) +) + +(define-method get_double + (of-object "GstStructure") + (c-name "gst_structure_get_double") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gdouble*" "value") + ) +) + +(define-method get_string + (of-object "GstStructure") + (c-name "gst_structure_get_string") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method to_string + (of-object "GstStructure") + (c-name "gst_structure_to_string") + (return-type "gchar*") +) + +(define-function gst_structure_from_string + (c-name "gst_structure_from_string") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "string") + '("gchar**" "end") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstsystemclock.h + +(define-function gst_system_clock_get_type + (c-name "gst_system_clock_get_type") + (return-type "GType") +) + +(define-function gst_system_clock_obtain + (c-name "gst_system_clock_obtain") + (return-type "GstClock*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttag.h + +(define-function _gst_tag_initialize + (c-name "_gst_tag_initialize") + (return-type "none") +) + +(define-function gst_tag_list_get_type + (c-name "gst_tag_list_get_type") + (return-type "GType") +) + +(define-function gst_tag_register + (c-name "gst_tag_register") + (return-type "none") + (parameters + '("gchar*" "name") + '("GstTagFlag" "flag") + '("GType" "type") + '("gchar*" "nick") + '("gchar*" "blurb") + '("GstTagMergeFunc" "func") + ) +) + +(define-function gst_tag_merge_use_first + (c-name "gst_tag_merge_use_first") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function gst_tag_merge_strings_with_comma + (c-name "gst_tag_merge_strings_with_comma") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function gst_tag_exists + (c-name "gst_tag_exists") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_type + (c-name "gst_tag_get_type") + (return-type "GType") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_nick + (c-name "gst_tag_get_nick") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_description + (c-name "gst_tag_get_description") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_is_fixed + (c-name "gst_tag_is_fixed") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_list_new + (c-name "gst_tag_list_new") + (is-constructor-of "GstTagList") + (return-type "GstTagList*") +) + +(define-function gst_is_tag_list + (c-name "gst_is_tag_list") + (return-type "gboolean") + (parameters + '("gconstpointer" "p") + ) +) + +(define-method copy + (of-object "GstTagList") + (c-name "gst_tag_list_copy") + (return-type "GstTagList*") +) + +(define-method insert + (of-object "GstTagList") + (c-name "gst_tag_list_insert") + (return-type "none") + (parameters + '("const-GstTagList*" "from") + '("GstTagMergeMode" "mode") + ) +) + +(define-method merge + (of-object "GstTagList") + (c-name "gst_tag_list_merge") + (return-type "GstTagList*") + (parameters + '("const-GstTagList*" "list2") + '("GstTagMergeMode" "mode") + ) +) + +(define-method free + (of-object "GstTagList") + (c-name "gst_tag_list_free") + (return-type "none") +) + +(define-method get_tag_size + (of-object "GstTagList") + (c-name "gst_tag_list_get_tag_size") + (return-type "guint") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-method add + (of-object "GstTagList") + (c-name "gst_tag_list_add") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_values + (of-object "GstTagList") + (c-name "gst_tag_list_add_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_valist + (of-object "GstTagList") + (c-name "gst_tag_list_add_valist") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method add_valist_values + (of-object "GstTagList") + (c-name "gst_tag_list_add_valist_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method remove_tag + (of-object "GstTagList") + (c-name "gst_tag_list_remove_tag") + (return-type "none") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-method foreach + (of-object "GstTagList") + (c-name "gst_tag_list_foreach") + (return-type "none") + (parameters + '("GstTagForeachFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method get_value_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_value_index") + (return-type "const-GValue*") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + ) +) + +(define-function gst_tag_list_copy_value + (c-name "gst_tag_list_copy_value") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GstTagList*" "list") + '("const-gchar*" "tag") + ) +) + +(define-method get_char + (of-object "GstTagList") + (c-name "gst_tag_list_get_char") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gchar*" "value") + ) +) + +(define-method get_char_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_char_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gchar*" "value") + ) +) + +(define-method get_uchar + (of-object "GstTagList") + (c-name "gst_tag_list_get_uchar") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guchar*" "value") + ) +) + +(define-method get_uchar_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uchar_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guchar*" "value") + ) +) + +(define-method get_boolean + (of-object "GstTagList") + (c-name "gst_tag_list_get_boolean") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gboolean*" "value") + ) +) + +(define-method get_boolean_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_boolean_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gboolean*" "value") + ) +) + +(define-method get_int + (of-object "GstTagList") + (c-name "gst_tag_list_get_int") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gint*" "value") + ) +) + +(define-method get_int_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_int_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gint*" "value") + ) +) + +(define-method get_uint + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint*" "value") + ) +) + +(define-method get_uint_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guint*" "value") + ) +) + +(define-method get_long + (of-object "GstTagList") + (c-name "gst_tag_list_get_long") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("glong*" "value") + ) +) + +(define-method get_long_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_long_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("glong*" "value") + ) +) + +(define-method get_ulong + (of-object "GstTagList") + (c-name "gst_tag_list_get_ulong") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gulong*" "value") + ) +) + +(define-method get_ulong_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_ulong_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gulong*" "value") + ) +) + +(define-method get_int64 + (of-object "GstTagList") + (c-name "gst_tag_list_get_int64") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gint64*" "value") + ) +) + +(define-method get_int64_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_int64_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gint64*" "value") + ) +) + +(define-method get_uint64 + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint64") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint64*" "value") + ) +) + +(define-method get_uint64_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint64_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guint64*" "value") + ) +) + +(define-method get_float + (of-object "GstTagList") + (c-name "gst_tag_list_get_float") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gfloat*" "value") + ) +) + +(define-method get_float_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_float_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gfloat*" "value") + ) +) + +(define-method get_double + (of-object "GstTagList") + (c-name "gst_tag_list_get_double") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gdouble*" "value") + ) +) + +(define-method get_double_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_double_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gdouble*" "value") + ) +) + +(define-method get_string + (of-object "GstTagList") + (c-name "gst_tag_list_get_string") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gchar**" "value") + ) +) + +(define-method get_string_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_string_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gchar**" "value") + ) +) + +(define-method get_pointer + (of-object "GstTagList") + (c-name "gst_tag_list_get_pointer") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gpointer*" "value") + ) +) + +(define-method get_pointer_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_pointer_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gpointer*" "value") + ) +) + +(define-function gst_event_new_tag + (c-name "gst_event_new_tag") + (return-type "GstEvent*") + (parameters + '("GstTagList*" "list") + ) +) + +(define-method tag_get_list + (of-object "GstEvent") + (c-name "gst_event_tag_get_list") + (return-type "GstTagList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttaginterface.h + +(define-function gst_tag_setter_get_type + (c-name "gst_tag_setter_get_type") + (return-type "GType") +) + +(define-method merge + (of-object "GstTagSetter") + (c-name "gst_tag_setter_merge") + (return-type "none") + (parameters + '("const-GstTagList*" "list") + '("GstTagMergeMode" "mode") + ) +) + +(define-method add + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_values + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_valist + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_valist") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method add_valist_values + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_valist_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method get_list + (of-object "GstTagSetter") + (c-name "gst_tag_setter_get_list") + (return-type "const-GstTagList*") +) + +(define-method set_merge_mode + (of-object "GstTagSetter") + (c-name "gst_tag_setter_set_merge_mode") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + ) +) + +(define-method get_merge_mode + (of-object "GstTagSetter") + (c-name "gst_tag_setter_get_merge_mode") + (return-type "GstTagMergeMode") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstthread.h + +(define-function gst_thread_get_type + (c-name "gst_thread_get_type") + (return-type "GType") +) + +(define-function gst_thread_new + (c-name "gst_thread_new") + (is-constructor-of "GstThread") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method set_priority + (of-object "GstThread") + (c-name "gst_thread_set_priority") + (return-type "none") + (parameters + '("GThreadPriority" "priority") + ) +) + +(define-function gst_thread_get_current + (c-name "gst_thread_get_current") + (return-type "GstThread*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttrace.h + +(define-function gst_trace_new + (c-name "gst_trace_new") + (is-constructor-of "GstTrace") + (return-type "GstTrace*") + (parameters + '("gchar*" "filename") + '("gint" "size") + ) +) + +(define-method destroy + (of-object "GstTrace") + (c-name "gst_trace_destroy") + (return-type "none") +) + +(define-method flush + (of-object "GstTrace") + (c-name "gst_trace_flush") + (return-type "none") +) + +(define-method text_flush + (of-object "GstTrace") + (c-name "gst_trace_text_flush") + (return-type "none") +) + +(define-method set_default + (of-object "GstTrace") + (c-name "gst_trace_set_default") + (return-type "none") +) + +(define-method _add_entry + (of-object "GstTrace") + (c-name "_gst_trace_add_entry") + (return-type "none") + (parameters + '("guint32" "seq") + '("guint32" "data") + '("gchar*" "msg") + ) +) + +(define-function gst_trace_read_tsc + (c-name "gst_trace_read_tsc") + (return-type "none") + (parameters + '("gint64*" "dst") + ) +) + +(define-function gst_alloc_trace_available + (c-name "gst_alloc_trace_available") + (return-type "gboolean") +) + +(define-function gst_alloc_trace_list + (c-name "gst_alloc_trace_list") + (return-type "const-GList*") +) + +(define-function _gst_alloc_trace_register + (c-name "_gst_alloc_trace_register") + (return-type "GstAllocTrace*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_alloc_trace_live_all + (c-name "gst_alloc_trace_live_all") + (return-type "int") +) + +(define-function gst_alloc_trace_print_all + (c-name "gst_alloc_trace_print_all") + (return-type "none") +) + +(define-function gst_alloc_trace_set_flags_all + (c-name "gst_alloc_trace_set_flags_all") + (return-type "none") + (parameters + '("GstAllocTraceFlags" "flags") + ) +) + +(define-function gst_alloc_trace_get + (c-name "gst_alloc_trace_get") + (return-type "GstAllocTrace*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method print + (of-object "GstAllocTrace") + (c-name "gst_alloc_trace_print") + (return-type "none") +) + +(define-method set_flags + (of-object "GstAllocTrace") + (c-name "gst_alloc_trace_set_flags") + (return-type "none") + (parameters + '("GstAllocTraceFlags" "flags") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttrashstack.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttypefind.h + +(define-method peek + (of-object "GstTypeFind") + (c-name "gst_type_find_peek") + (return-type "guint8*") + (parameters + '("gint64" "offset") + '("guint" "size") + ) +) + +(define-method suggest + (of-object "GstTypeFind") + (c-name "gst_type_find_suggest") + (return-type "none") + (parameters + '("guint" "probability") + '("const-GstCaps*" "caps") + ) +) + +(define-method get_length + (of-object "GstTypeFind") + (c-name "gst_type_find_get_length") + (return-type "guint64") +) + +(define-function gst_type_find_register + (c-name "gst_type_find_register") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + '("const-gchar*" "name") + '("guint" "rank") + '("GstTypeFindFunction" "func") + '("gchar**" "extensions") + '("const-GstCaps*" "possible_caps") + '("gpointer" "data") + ) +) + +(define-function gst_type_find_factory_get_type + (c-name "gst_type_find_factory_get_type") + (return-type "GType") +) + +(define-function gst_type_find_factory_get_list + (c-name "gst_type_find_factory_get_list") + (return-type "GList*") +) + +(define-method get_extensions + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_get_extensions") + (return-type "gchar**") +) + +(define-method get_caps + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_get_caps") + (return-type "const-GstCaps*") +) + +(define-method call_function + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_call_function") + (return-type "none") + (parameters + '("GstTypeFind*" "find") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttypes.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsturi.h + +(define-function gst_uri_protocol_is_valid + (c-name "gst_uri_protocol_is_valid") + (return-type "gboolean") + (parameters + '("const-gchar*" "protocol") + ) +) + +(define-function gst_uri_is_valid + (c-name "gst_uri_is_valid") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_get_protocol + (c-name "gst_uri_get_protocol") + (return-type "gchar*") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_get_location + (c-name "gst_uri_get_location") + (return-type "gchar*") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_construct + (c-name "gst_uri_construct") + (return-type "gchar*") + (parameters + '("const-gchar*" "protocol") + '("const-gchar*" "location") + ) +) + +(define-function gst_element_make_from_uri + (c-name "gst_element_make_from_uri") + (return-type "GstElement*") + (parameters + '("const-GstURIType" "type") + '("const-gchar*" "uri") + '("const-gchar*" "elementname") + ) +) + +(define-function gst_uri_handler_get_type + (c-name "gst_uri_handler_get_type") + (return-type "GType") +) + +(define-method get_uri_type + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_uri_type") + (return-type "guint") +) + +(define-method get_protocols + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_protocols") + (return-type "gchar**") +) + +(define-method get_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_uri") + (return-type "const-gchar*") +) + +(define-method set_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_set_uri") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-method new_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_new_uri") + (return-type "none") + (parameters + '("const-gchar*" "uri") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsturitype.h + +(define-function gst_uri_get_uri_type + (c-name "gst_uri_get_uri_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstutils.h + +(define-function gst_util_set_value_from_string + (c-name "gst_util_set_value_from_string") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-gchar*" "value_str") + ) +) + +(define-function gst_util_set_object_arg + (c-name "gst_util_set_object_arg") + (return-type "none") + (parameters + '("GObject*" "object") + '("const-gchar*" "name") + '("const-gchar*" "value") + ) +) + +(define-function gst_util_dump_mem + (c-name "gst_util_dump_mem") + (return-type "none") + (parameters + '("guchar*" "mem") + '("guint" "size") + ) +) + +(define-function gst_print_pad_caps + (c-name "gst_print_pad_caps") + (return-type "none") + (parameters + '("GString*" "buf") + '("gint" "indent") + '("GstPad*" "pad") + ) +) + +(define-function gst_print_element_args + (c-name "gst_print_element_args") + (return-type "none") + (parameters + '("GString*" "buf") + '("gint" "indent") + '("GstElement*" "element") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstvalue.h + +(define-function gst_value_list_prepend_value + (c-name "gst_value_list_prepend_value") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GValue*" "prepend_value") + ) +) + +(define-function gst_value_list_append_value + (c-name "gst_value_list_append_value") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GValue*" "append_value") + ) +) + +(define-function gst_value_list_get_size + (c-name "gst_value_list_get_size") + (return-type "guint") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_list_get_value + (c-name "gst_value_list_get_value") + (return-type "const-GValue*") + (parameters + '("const-GValue*" "value") + '("guint" "index") + ) +) + +(define-function gst_value_list_concat + (c-name "gst_value_list_concat") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_set_fourcc + (c-name "gst_value_set_fourcc") + (return-type "none") + (parameters + '("GValue*" "value") + '("guint32" "fourcc") + ) +) + +(define-function gst_value_get_fourcc + (c-name "gst_value_get_fourcc") + (return-type "guint32") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_int_range + (c-name "gst_value_set_int_range") + (return-type "none") + (parameters + '("GValue*" "value") + '("int" "start") + '("int" "end") + ) +) + +(define-function gst_value_get_int_range_min + (c-name "gst_value_get_int_range_min") + (return-type "int") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_int_range_max + (c-name "gst_value_get_int_range_max") + (return-type "int") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_double_range + (c-name "gst_value_set_double_range") + (return-type "none") + (parameters + '("GValue*" "value") + '("double" "start") + '("double" "end") + ) +) + +(define-function gst_value_get_double_range_min + (c-name "gst_value_get_double_range_min") + (return-type "double") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_double_range_max + (c-name "gst_value_get_double_range_max") + (return-type "double") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_caps + (c-name "gst_value_get_caps") + (return-type "const-GstCaps*") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_caps + (c-name "gst_value_set_caps") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GstCaps*" "caps") + ) +) + +(define-function gst_value_can_compare + (c-name "gst_value_can_compare") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_compare + (c-name "gst_value_compare") + (return-type "int") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_can_union + (c-name "gst_value_can_union") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_union + (c-name "gst_value_union") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_register_union_func + (c-name "gst_value_register_union_func") + (return-type "none") + (parameters + '("GType" "type1") + '("GType" "type2") + '("GstValueUnionFunc" "func") + ) +) + +(define-function gst_value_can_intersect + (c-name "gst_value_can_intersect") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_intersect + (c-name "gst_value_intersect") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_register_intersect_func + (c-name "gst_value_register_intersect_func") + (return-type "none") + (parameters + '("GType" "type1") + '("GType" "type2") + '("GstValueIntersectFunc" "func") + ) +) + +(define-function gst_value_register + (c-name "gst_value_register") + (return-type "none") + (parameters + '("const-GstValueTable*" "table") + ) +) + +(define-function gst_value_init_and_copy + (c-name "gst_value_init_and_copy") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function _gst_value_initialize + (c-name "_gst_value_initialize") + (return-type "none") +) + +(define-function gst_value_serialize + (c-name "gst_value_serialize") + (return-type "gchar*") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_deserialize + (c-name "gst_value_deserialize") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-gchar*" "src") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstversion.h + +(define-function gst_version + (c-name "gst_version") + (return-type "none") + (parameters + '("guint*" "major") + '("guint*" "minor") + '("guint*" "micro") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstxml.h + +(define-function gst_xml_get_type + (c-name "gst_xml_get_type") + (return-type "GType") +) + +(define-function gst_xml_write + (c-name "gst_xml_write") + (return-type "xmlDocPtr") + (parameters + '("GstElement*" "element") + ) +) + +(define-function gst_xml_write_file + (c-name "gst_xml_write_file") + (return-type "gint") + (parameters + '("GstElement*" "element") + '("FILE*" "out") + ) +) + +(define-function gst_xml_new + (c-name "gst_xml_new") + (is-constructor-of "GstXml") + (return-type "GstXML*") +) + +(define-method parse_doc + (of-object "GstXML") + (c-name "gst_xml_parse_doc") + (return-type "gboolean") + (parameters + '("xmlDocPtr" "doc") + '("const-guchar*" "root") + ) +) + +(define-method parse_file + (of-object "GstXML") + (c-name "gst_xml_parse_file") + (return-type "gboolean") + (parameters + '("const-guchar*" "fname") + '("const-guchar*" "root") + ) +) + +(define-method parse_memory + (of-object "GstXML") + (c-name "gst_xml_parse_memory") + (return-type "gboolean") + (parameters + '("guchar*" "buffer") + '("guint" "size") + '("const-gchar*" "root") + ) +) + +(define-method get_element + (of-object "GstXML") + (c-name "gst_xml_get_element") + (return-type "GstElement*") + (parameters + '("const-guchar*" "name") + ) +) + +(define-method get_topelements + (of-object "GstXML") + (c-name "gst_xml_get_topelements") + (return-type "GList*") +) + +(define-function gst_xml_make_element + (c-name "gst_xml_make_element") + (return-type "GstElement*") + (parameters + '("xmlNodePtr" "cur") + '("GstObject*" "parent") + ) +) + + +;; -*- scheme -*- +;; +;; Boxed types +;; + +(define-boxed Buffer + (in-module "Gst") + (c-name "GstBuffer") + (gtype-id "GST_TYPE_BUFFER") +) + +(define-boxed Caps + (in-module "Gst") + (c-name "GstCaps") + (gtype-id "GST_TYPE_CAPS") +) + +(define-boxed Event + (in-module "Gst") + (c-name "GstEvent") + (gtype-id "GST_TYPE_EVENT") +) + +;; +;; Accelerate common GstBin iterate loop +;; + +(define-function iterate_bin_all + (c-name "iterate_bin_all") + (return-type "none") + (parameters + '("GstBin*" "bin") + ) +) + +(define-function add_iterate_bin + (c-name "add_iterate_bin") + (return-type "guint") + (parameters + '("GstBin*" "bin") + ) +) + +(define-function remove_iterate_bin + (c-name "remove_iterate_bin") + (return-type "none") + (parameters + '("guint" "id") + ) +) + +;; +;; HACK +;; + +(define-method get_data + (of-object "GstBuffer") + (c-name "gst_buffer_get_data") + (return-type "char*") +) + +(define-method set_data + (of-object "GstBuffer") + (c-name "gst_buffer_set_data") + (return-type "none") + (parameters + '("char*" "data") + ) +) + + +;; +;; 0.7 Boxed types +;; + +(define-boxed Structure + (in-module "Gst") + (c-name "GstStructure") + (gtype-id "GST_TYPE_STRUCTURE") +) + +(define-boxed TagList + (in-module "Gst") + (c-name "GstTagList") + (gtype-id "GST_TYPE_TAG_LIST") +) diff --git a/gst/gstreamer.defs b/gst/gstreamer.defs new file mode 100644 index 0000000000..0dafc62c87 --- /dev/null +++ b/gst/gstreamer.defs @@ -0,0 +1,6968 @@ +;; -*- scheme -*- +; object definitions ... +(define-object Object + (in-module "Gst") + (parent "GObject") + (c-name "GstObject") + (gtype-id "GST_TYPE_OBJECT") +) + +(define-object Index + (in-module "Gst") + (parent "GstObject") + (c-name "GstIndex") + (gtype-id "GST_TYPE_INDEX") +) + +(define-object Element + (in-module "Gst") + (parent "GstObject") + (c-name "GstElement") + (gtype-id "GST_TYPE_ELEMENT") +) + +(define-object Bin + (in-module "Gst") + (parent "GstElement") + (c-name "GstBin") + (gtype-id "GST_TYPE_BIN") +) + +(define-object Clock + (in-module "Gst") + (parent "GstObject") + (c-name "GstClock") + (gtype-id "GST_TYPE_CLOCK") +) + +(define-object Pad + (in-module "Gst") + (parent "GstObject") + (c-name "GstPad") + (gtype-id "GST_TYPE_PAD") +) + +(define-object GhostPad + (in-module "Gst") + (parent "GstPad") + (c-name "GstGhostPad") + (gtype-id "GST_TYPE_GHOST_PAD") +) + +(define-object PadTemplate + (in-module "Gst") + (parent "GstObject") + (c-name "GstPadTemplate") + (gtype-id "GST_TYPE_PAD_TEMPLATE") +) + +(define-object Pipeline + (in-module "Gst") + (parent "GstBin") + (c-name "GstPipeline") + (gtype-id "GST_TYPE_PIPELINE") +) + +(define-object PluginFeature + (in-module "Gst") + (parent "GObject") + (c-name "GstPluginFeature") + (gtype-id "GST_TYPE_PLUGIN_FEATURE") +) + +(define-object IndexFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstIndexFactory") + (gtype-id "GST_TYPE_INDEX_FACTORY") +) + +(define-object ElementFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstElementFactory") + (gtype-id "GST_TYPE_ELEMENT_FACTORY") +) + +(define-object Queue + (in-module "Gst") + (parent "GstElement") + (c-name "GstQueue") + (gtype-id "GST_TYPE_QUEUE") +) + +(define-object RealPad + (in-module "Gst") + (parent "GstPad") + (c-name "GstRealPad") + (gtype-id "GST_TYPE_REAL_PAD") +) + +(define-object Registry + (in-module "Gst") + (parent "GObject") + (c-name "GstRegistry") + (gtype-id "GST_TYPE_REGISTRY") +) + +(define-object Scheduler + (in-module "Gst") + (parent "GstObject") + (c-name "GstScheduler") + (gtype-id "GST_TYPE_SCHEDULER") +) + +(define-object SchedulerFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstSchedulerFactory") + (gtype-id "GST_TYPE_SCHEDULER_FACTORY") +) + +(define-object SystemClock + (in-module "Gst") + (parent "GstClock") + (c-name "GstSystemClock") + (gtype-id "GST_TYPE_SYSTEM_CLOCK") +) + +(define-object Thread + (in-module "Gst") + (parent "GstBin") + (c-name "GstThread") + (gtype-id "GST_TYPE_THREAD") +) + +(define-object TypeFindFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstTypeFindFactory") + (gtype-id "GST_TYPE_TYPE_FIND_FACTORY") +) + +(define-object XML + (in-module "Gst") + (parent "GstObject") + (c-name "GstXML") + (gtype-id "GST_TYPE_XML") +) + +;; Enumerations and flags ... + +(define-enum BinFlags + (in-module "Gst") + (c-name "GstBinFlags") + (gtype-id "GST_TYPE_BIN_FLAGS") + (values + '("flag-manager" "GST_BIN_FLAG_MANAGER") + '("self-schedulable" "GST_BIN_SELF_SCHEDULABLE") + '("flag-prefer-cothreads" "GST_BIN_FLAG_PREFER_COTHREADS") + '("flag-fixed-clock" "GST_BIN_FLAG_FIXED_CLOCK") + '("flag-last" "GST_BIN_FLAG_LAST") + ) +) + +(define-enum BufferFlag + (in-module "Gst") + (c-name "GstBufferFlag") + (gtype-id "GST_TYPE_BUFFER_FLAG") + (values + '("readonly" "GST_BUFFER_READONLY") + '("subbuffer" "GST_BUFFER_SUBBUFFER") + '("original" "GST_BUFFER_ORIGINAL") + '("dontfree" "GST_BUFFER_DONTFREE") + '("key-unit" "GST_BUFFER_KEY_UNIT") + '("dontkeep" "GST_BUFFER_DONTKEEP") + '("flag-last" "GST_BUFFER_FLAG_LAST") + ) +) + +(define-enum ClockEntryStatus + (in-module "Gst") + (c-name "GstClockEntryStatus") + (gtype-id "GST_TYPE_CLOCK_ENTRY_STATUS") + (values + '("ok" "GST_CLOCK_ENTRY_OK") + '("early" "GST_CLOCK_ENTRY_EARLY") + '("restart" "GST_CLOCK_ENTRY_RESTART") + ) +) + +(define-enum ClockEntryType + (in-module "Gst") + (c-name "GstClockEntryType") + (gtype-id "GST_TYPE_CLOCK_ENTRY_TYPE") + (values + '("single" "GST_CLOCK_ENTRY_SINGLE") + '("periodic" "GST_CLOCK_ENTRY_PERIODIC") + ) +) + +(define-enum ClockReturn + (in-module "Gst") + (c-name "GstClockReturn") + (gtype-id "GST_TYPE_CLOCK_RETURN") + (values + '("stopped" "GST_CLOCK_STOPPED") + '("timeout" "GST_CLOCK_TIMEOUT") + '("early" "GST_CLOCK_EARLY") + '("error" "GST_CLOCK_ERROR") + '("unsupported" "GST_CLOCK_UNSUPPORTED") + ) +) + +(define-flags ClockFlags + (in-module "Gst") + (c-name "GstClockFlags") + (gtype-id "GST_TYPE_CLOCK_FLAGS") + (values + '("do-single-sync" "GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC") + '("do-single-async" "GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC") + '("do-periodic-sync" "GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC") + '("do-periodic-async" "GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC") + '("set-resolution" "GST_CLOCK_FLAG_CAN_SET_RESOLUTION") + '("set-speed" "GST_CLOCK_FLAG_CAN_SET_SPEED") + ) +) + +(define-flags CPUFlags + (in-module "Gst") + (c-name "GstCPUFlags") + (gtype-id "GST_TYPE_CPU_FLAGS") + (values + '("mmx" "GST_CPU_FLAG_MMX") + '("sse" "GST_CPU_FLAG_SSE") + '("mmxext" "GST_CPU_FLAG_MMXEXT") + '("3dnow" "GST_CPU_FLAG_3DNOW") + ) +) + +(define-enum DataFlags + (in-module "Gst") + (c-name "GstDataFlags") + (gtype-id "GST_TYPE_DATA_FLAGS") + (values + '("readonly" "GST_DATA_READONLY") + '("flag-last" "GST_DATA_FLAG_LAST") + ) +) + +(define-enum ElementFlags + (in-module "Gst") + (c-name "GstElementFlags") + (gtype-id "GST_TYPE_ELEMENT_FLAGS") + (values + '("complex" "GST_ELEMENT_COMPLEX") + '("decoupled" "GST_ELEMENT_DECOUPLED") + '("thread-suggested" "GST_ELEMENT_THREAD_SUGGESTED") + '("infinite-loop" "GST_ELEMENT_INFINITE_LOOP") + '("new-loopfunc" "GST_ELEMENT_NEW_LOOPFUNC") + '("event-aware" "GST_ELEMENT_EVENT_AWARE") + '("use-threadsafe-properties" "GST_ELEMENT_USE_THREADSAFE_PROPERTIES") + '("scheduler-private1" "GST_ELEMENT_SCHEDULER_PRIVATE1") + '("scheduler-private2" "GST_ELEMENT_SCHEDULER_PRIVATE2") + '("locked-state" "GST_ELEMENT_LOCKED_STATE") + '("in-error" "GST_ELEMENT_IN_ERROR") + '("flag-last" "GST_ELEMENT_FLAG_LAST") + ) +) + +(define-enum CoreError + (in-module "Gst") + (c-name "GstCoreError") + (gtype-id "GST_TYPE_CORE_ERROR") + (values + '("failed" "GST_CORE_ERROR_FAILED") + '("too-lazy" "GST_CORE_ERROR_TOO_LAZY") + '("not-implemented" "GST_CORE_ERROR_NOT_IMPLEMENTED") + '("state-change" "GST_CORE_ERROR_STATE_CHANGE") + '("pad" "GST_CORE_ERROR_PAD") + '("thread" "GST_CORE_ERROR_THREAD") + '("scheduler" "GST_CORE_ERROR_SCHEDULER") + '("negotiation" "GST_CORE_ERROR_NEGOTIATION") + '("event" "GST_CORE_ERROR_EVENT") + '("seek" "GST_CORE_ERROR_SEEK") + '("caps" "GST_CORE_ERROR_CAPS") + '("tag" "GST_CORE_ERROR_TAG") + '("num-errors" "GST_CORE_ERROR_NUM_ERRORS") + ) +) + +(define-enum LibraryError + (in-module "Gst") + (c-name "GstLibraryError") + (gtype-id "GST_TYPE_LIBRARY_ERROR") + (values + '("failed" "GST_LIBRARY_ERROR_FAILED") + '("too-lazy" "GST_LIBRARY_ERROR_TOO_LAZY") + '("init" "GST_LIBRARY_ERROR_INIT") + '("shutdown" "GST_LIBRARY_ERROR_SHUTDOWN") + '("settings" "GST_LIBRARY_ERROR_SETTINGS") + '("encode" "GST_LIBRARY_ERROR_ENCODE") + '("num-errors" "GST_LIBRARY_ERROR_NUM_ERRORS") + ) +) + +(define-enum ResourceError + (in-module "Gst") + (c-name "GstResourceError") + (gtype-id "GST_TYPE_RESOURCE_ERROR") + (values + '("failed" "GST_RESOURCE_ERROR_FAILED") + '("too-lazy" "GST_RESOURCE_ERROR_TOO_LAZY") + '("not-found" "GST_RESOURCE_ERROR_NOT_FOUND") + '("busy" "GST_RESOURCE_ERROR_BUSY") + '("open-read" "GST_RESOURCE_ERROR_OPEN_READ") + '("open-write" "GST_RESOURCE_ERROR_OPEN_WRITE") + '("open-read-write" "GST_RESOURCE_ERROR_OPEN_READ_WRITE") + '("close" "GST_RESOURCE_ERROR_CLOSE") + '("read" "GST_RESOURCE_ERROR_READ") + '("write" "GST_RESOURCE_ERROR_WRITE") + '("seek" "GST_RESOURCE_ERROR_SEEK") + '("sync" "GST_RESOURCE_ERROR_SYNC") + '("settings" "GST_RESOURCE_ERROR_SETTINGS") + '("num-errors" "GST_RESOURCE_ERROR_NUM_ERRORS") + ) +) + +(define-enum StreamError + (in-module "Gst") + (c-name "GstStreamError") + (gtype-id "GST_TYPE_STREAM_ERROR") + (values + '("failed" "GST_STREAM_ERROR_FAILED") + '("too-lazy" "GST_STREAM_ERROR_TOO_LAZY") + '("not-implemented" "GST_STREAM_ERROR_NOT_IMPLEMENTED") + '("type-not-found" "GST_STREAM_ERROR_TYPE_NOT_FOUND") + '("wrong-type" "GST_STREAM_ERROR_WRONG_TYPE") + '("codec-not-found" "GST_STREAM_ERROR_CODEC_NOT_FOUND") + '("decode" "GST_STREAM_ERROR_DECODE") + '("encode" "GST_STREAM_ERROR_ENCODE") + '("demux" "GST_STREAM_ERROR_DEMUX") + '("mux" "GST_STREAM_ERROR_MUX") + '("format" "GST_STREAM_ERROR_FORMAT") + '("num-errors" "GST_STREAM_ERROR_NUM_ERRORS") + ) +) + +(define-enum EventType + (in-module "Gst") + (c-name "GstEventType") + (gtype-id "GST_TYPE_EVENT_TYPE") + (values + '("unknown" "GST_EVENT_UNKNOWN") + '("eos" "GST_EVENT_EOS") + '("flush" "GST_EVENT_FLUSH") + '("empty" "GST_EVENT_EMPTY") + '("discontinuous" "GST_EVENT_DISCONTINUOUS") + '("qos" "GST_EVENT_QOS") + '("seek" "GST_EVENT_SEEK") + '("seek-segment" "GST_EVENT_SEEK_SEGMENT") + '("segment-done" "GST_EVENT_SEGMENT_DONE") + '("size" "GST_EVENT_SIZE") + '("rate" "GST_EVENT_RATE") + '("filler" "GST_EVENT_FILLER") + '("ts-offset" "GST_EVENT_TS_OFFSET") + '("interrupt" "GST_EVENT_INTERRUPT") + '("navigation" "GST_EVENT_NAVIGATION") + '("tag" "GST_EVENT_TAG") + ) +) + +(define-flags EventFlag + (in-module "Gst") + (c-name "GstEventFlag") + (gtype-id "GST_TYPE_EVENT_FLAG") + (values + '("event-flag-none" "GST_EVENT_FLAG_NONE") + '("rate-flag-negative" "GST_RATE_FLAG_NEGATIVE") + ) +) + +(define-flags SeekType + (in-module "Gst") + (c-name "GstSeekType") + (gtype-id "GST_TYPE_SEEK_TYPE") + (values + '("method-cur" "GST_SEEK_METHOD_CUR") + '("method-set" "GST_SEEK_METHOD_SET") + '("method-end" "GST_SEEK_METHOD_END") + '("flag-flush" "GST_SEEK_FLAG_FLUSH") + '("flag-accurate" "GST_SEEK_FLAG_ACCURATE") + '("flag-key-unit" "GST_SEEK_FLAG_KEY_UNIT") + '("flag-segment-loop" "GST_SEEK_FLAG_SEGMENT_LOOP") + ) +) + +(define-enum SeekAccuracy + (in-module "Gst") + (c-name "GstSeekAccuracy") + (gtype-id "GST_TYPE_SEEK_ACCURACY") + (values + '("certain" "GST_SEEK_CERTAIN") + '("fuzzy" "GST_SEEK_FUZZY") + ) +) + +(define-enum Format + (in-module "Gst") + (c-name "GstFormat") + (gtype-id "GST_TYPE_FORMAT") + (values + '("undefined" "GST_FORMAT_UNDEFINED") + '("default" "GST_FORMAT_DEFAULT") + '("bytes" "GST_FORMAT_BYTES") + '("time" "GST_FORMAT_TIME") + '("buffers" "GST_FORMAT_BUFFERS") + '("percent" "GST_FORMAT_PERCENT") + ) +) + +(define-enum IndexCertainty + (in-module "Gst") + (c-name "GstIndexCertainty") + (gtype-id "GST_TYPE_INDEX_CERTAINTY") + (values + '("unknown" "GST_INDEX_UNKNOWN") + '("certain" "GST_INDEX_CERTAIN") + '("fuzzy" "GST_INDEX_FUZZY") + ) +) + +(define-enum IndexEntryType + (in-module "Gst") + (c-name "GstIndexEntryType") + (gtype-id "GST_TYPE_INDEX_ENTRY_TYPE") + (values + '("id" "GST_INDEX_ENTRY_ID") + '("association" "GST_INDEX_ENTRY_ASSOCIATION") + '("object" "GST_INDEX_ENTRY_OBJECT") + '("format" "GST_INDEX_ENTRY_FORMAT") + ) +) + +(define-enum IndexLookupMethod + (in-module "Gst") + (c-name "GstIndexLookupMethod") + (gtype-id "GST_TYPE_INDEX_LOOKUP_METHOD") + (values + '("exact" "GST_INDEX_LOOKUP_EXACT") + '("before" "GST_INDEX_LOOKUP_BEFORE") + '("after" "GST_INDEX_LOOKUP_AFTER") + ) +) + +(define-flags AssocFlags + (in-module "Gst") + (c-name "GstAssocFlags") + (gtype-id "GST_TYPE_ASSOC_FLAGS") + (values + '("none" "GST_ASSOCIATION_FLAG_NONE") + '("key-unit" "GST_ASSOCIATION_FLAG_KEY_UNIT") + '("last" "GST_ASSOCIATION_FLAG_LAST") + ) +) + +(define-enum IndexResolverMethod + (in-module "Gst") + (c-name "GstIndexResolverMethod") + (gtype-id "GST_TYPE_INDEX_RESOLVER_METHOD") + (values + '("custom" "GST_INDEX_RESOLVER_CUSTOM") + '("gtype" "GST_INDEX_RESOLVER_GTYPE") + '("path" "GST_INDEX_RESOLVER_PATH") + ) +) + +(define-enum IndexFlags + (in-module "Gst") + (c-name "GstIndexFlags") + (gtype-id "GST_TYPE_INDEX_FLAGS") + (values + '("writable" "GST_INDEX_WRITABLE") + '("readable" "GST_INDEX_READABLE") + '("flag-last" "GST_INDEX_FLAG_LAST") + ) +) + +(define-enum DebugLevel + (in-module "Gst") + (c-name "GstDebugLevel") + (gtype-id "GST_TYPE_DEBUG_LEVEL") + (values + '("none" "GST_LEVEL_NONE") + '("error" "GST_LEVEL_ERROR") + '("warning" "GST_LEVEL_WARNING") + '("info" "GST_LEVEL_INFO") + '("debug" "GST_LEVEL_DEBUG") + '("log" "GST_LEVEL_LOG") + '("count" "GST_LEVEL_COUNT") + ) +) + +(define-enum DebugColorFlags + (in-module "Gst") + (c-name "GstDebugColorFlags") + (gtype-id "GST_TYPE_DEBUG_COLOR_FLAGS") + (values + '("fg-black" "GST_DEBUG_FG_BLACK") + '("fg-red" "GST_DEBUG_FG_RED") + '("fg-green" "GST_DEBUG_FG_GREEN") + '("fg-yellow" "GST_DEBUG_FG_YELLOW") + '("fg-blue" "GST_DEBUG_FG_BLUE") + '("fg-magenta" "GST_DEBUG_FG_MAGENTA") + '("fg-cyan" "GST_DEBUG_FG_CYAN") + '("fg-white" "GST_DEBUG_FG_WHITE") + '("bg-black" "GST_DEBUG_BG_BLACK") + '("bg-red" "GST_DEBUG_BG_RED") + '("bg-green" "GST_DEBUG_BG_GREEN") + '("bg-yellow" "GST_DEBUG_BG_YELLOW") + '("bg-blue" "GST_DEBUG_BG_BLUE") + '("bg-magenta" "GST_DEBUG_BG_MAGENTA") + '("bg-cyan" "GST_DEBUG_BG_CYAN") + '("bg-white" "GST_DEBUG_BG_WHITE") + '("bold" "GST_DEBUG_BOLD") + '("underline" "GST_DEBUG_UNDERLINE") + ) +) + +(define-enum ObjectFlags + (in-module "Gst") + (c-name "GstObjectFlags") + (gtype-id "GST_TYPE_OBJECT_FLAGS") + (values + '("destroyed" "GST_DESTROYED") + '("floating" "GST_FLOATING") + '("object-flag-last" "GST_OBJECT_FLAG_LAST") + ) +) + +(define-enum PadLinkReturn + (in-module "Gst") + (c-name "GstPadLinkReturn") + (gtype-id "GST_TYPE_PAD_LINK_RETURN") + (values + '("refused" "GST_PAD_LINK_REFUSED") + '("delayed" "GST_PAD_LINK_DELAYED") + '("ok" "GST_PAD_LINK_OK") + '("done" "GST_PAD_LINK_DONE") + ) +) + +(define-enum PadDirection + (in-module "Gst") + (c-name "GstPadDirection") + (gtype-id "GST_TYPE_PAD_DIRECTION") + (values + '("unknown" "GST_PAD_UNKNOWN") + '("src" "GST_PAD_SRC") + '("sink" "GST_PAD_SINK") + ) +) + +(define-enum PadFlags + (in-module "Gst") + (c-name "GstPadFlags") + (gtype-id "GST_TYPE_PAD_FLAGS") + (values + '("disabled" "GST_PAD_DISABLED") + '("negotiating" "GST_PAD_NEGOTIATING") + '("flag-last" "GST_PAD_FLAG_LAST") + ) +) + +(define-enum PadPresence + (in-module "Gst") + (c-name "GstPadPresence") + (gtype-id "GST_TYPE_PAD_PRESENCE") + (values + '("always" "GST_PAD_ALWAYS") + '("sometimes" "GST_PAD_SOMETIMES") + '("request" "GST_PAD_REQUEST") + ) +) + +(define-enum PadTemplateFlags + (in-module "Gst") + (c-name "GstPadTemplateFlags") + (gtype-id "GST_TYPE_PAD_TEMPLATE_FLAGS") + (values + '("ixed" "GST_PAD_TEMPLATE_FIXED") + '("lag-last" "GST_PAD_TEMPLATE_FLAG_LAST") + ) +) + +(define-enum ParseError + (in-module "Gst") + (c-name "GstParseError") + (gtype-id "GST_TYPE_PARSE_ERROR") + (values + '("syntax" "GST_PARSE_ERROR_SYNTAX") + '("no-such-element" "GST_PARSE_ERROR_NO_SUCH_ELEMENT") + '("no-such-property" "GST_PARSE_ERROR_NO_SUCH_PROPERTY") + '("link" "GST_PARSE_ERROR_LINK") + '("could-not-set-property" "GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY") + '("empty-bin" "GST_PARSE_ERROR_EMPTY_BIN") + '("empty" "GST_PARSE_ERROR_EMPTY") + ) +) + +(define-enum PluginError + (in-module "Gst") + (c-name "GstPluginError") + (gtype-id "GST_TYPE_PLUGIN_ERROR") + (values + '("module" "GST_PLUGIN_ERROR_MODULE") + '("dependencies" "GST_PLUGIN_ERROR_DEPENDENCIES") + '("name-mismatch" "GST_PLUGIN_ERROR_NAME_MISMATCH") + ) +) + +(define-enum QueryType + (in-module "Gst") + (c-name "GstQueryType") + (gtype-id "GST_TYPE_QUERY_TYPE") + (values + '("none" "GST_QUERY_NONE") + '("total" "GST_QUERY_TOTAL") + '("position" "GST_QUERY_POSITION") + '("latency" "GST_QUERY_LATENCY") + '("jitter" "GST_QUERY_JITTER") + '("start" "GST_QUERY_START") + '("segment-end" "GST_QUERY_SEGMENT_END") + '("rate" "GST_QUERY_RATE") + ) +) + +(define-flags RegistryReturn + (in-module "Gst") + (c-name "GstRegistryReturn") + (gtype-id "GST_TYPE_REGISTRY_RETURN") + (values + '("ok" "GST_REGISTRY_OK") + '("load-error" "GST_REGISTRY_LOAD_ERROR") + '("save-error" "GST_REGISTRY_SAVE_ERROR") + '("plugin-load-error" "GST_REGISTRY_PLUGIN_LOAD_ERROR") + '("plugin-signature-error" "GST_REGISTRY_PLUGIN_SIGNATURE_ERROR") + ) +) + +(define-flags RegistryFlags + (in-module "Gst") + (c-name "GstRegistryFlags") + (gtype-id "GST_TYPE_REGISTRY_FLAGS") + (values + '("readable" "GST_REGISTRY_READABLE") + '("writable" "GST_REGISTRY_WRITABLE") + '("exists" "GST_REGISTRY_EXISTS") + '("remote" "GST_REGISTRY_REMOTE") + '("delayed-loading" "GST_REGISTRY_DELAYED_LOADING") + ) +) + +(define-enum SchedulerFlags + (in-module "Gst") + (c-name "GstSchedulerFlags") + (gtype-id "GST_TYPE_SCHEDULER_FLAGS") + (values + '("fixed-clock" "GST_SCHEDULER_FLAG_FIXED_CLOCK") + '("last" "GST_SCHEDULER_FLAG_LAST") + ) +) + +(define-enum SchedulerState + (in-module "Gst") + (c-name "GstSchedulerState") + (gtype-id "GST_TYPE_SCHEDULER_STATE") + (values + '("none" "GST_SCHEDULER_STATE_NONE") + '("running" "GST_SCHEDULER_STATE_RUNNING") + '("stopped" "GST_SCHEDULER_STATE_STOPPED") + '("error" "GST_SCHEDULER_STATE_ERROR") + ) +) + +(define-enum TagMergeMode + (in-module "Gst") + (c-name "GstTagMergeMode") + (gtype-id "GST_TYPE_TAG_MERGE_MODE") + (values + '("undefined" "GST_TAG_MERGE_UNDEFINED") + '("replace-all" "GST_TAG_MERGE_REPLACE_ALL") + '("replace" "GST_TAG_MERGE_REPLACE") + '("append" "GST_TAG_MERGE_APPEND") + '("prepend" "GST_TAG_MERGE_PREPEND") + '("keep" "GST_TAG_MERGE_KEEP") + '("keep-all" "GST_TAG_MERGE_KEEP_ALL") + '("count" "GST_TAG_MERGE_COUNT") + ) +) + +(define-enum TagFlag + (in-module "Gst") + (c-name "GstTagFlag") + (gtype-id "GST_TYPE_TAG_FLAG") + (values + '("undefined" "GST_TAG_FLAG_UNDEFINED") + '("meta" "GST_TAG_FLAG_META") + '("encoded" "GST_TAG_FLAG_ENCODED") + '("decoded" "GST_TAG_FLAG_DECODED") + '("count" "GST_TAG_FLAG_COUNT") + ) +) + +(define-enum ThreadState + (in-module "Gst") + (c-name "GstThreadState") + (gtype-id "GST_TYPE_THREAD_STATE") + (values + '("state-spinning" "GST_THREAD_STATE_SPINNING") + '("state-reaping" "GST_THREAD_STATE_REAPING") + '("mutex-locked" "GST_THREAD_MUTEX_LOCKED") + '("flag-last" "GST_THREAD_FLAG_LAST") + ) +) + +(define-flags AllocTraceFlags + (in-module "Gst") + (c-name "GstAllocTraceFlags") + (gtype-id "GST_TYPE_ALLOC_TRACE_FLAGS") + (values + '("live" "GST_ALLOC_TRACE_LIVE") + '("mem-live" "GST_ALLOC_TRACE_MEM_LIVE") + ) +) + +(define-enum TypeFindProbability + (in-module "Gst") + (c-name "GstTypeFindProbability") + (gtype-id "GST_TYPE_TYPE_FIND_PROBABILITY") + (values + '("minimum" "GST_TYPE_FIND_MINIMUM") + '("possible" "GST_TYPE_FIND_POSSIBLE") + '("likely" "GST_TYPE_FIND_LIKELY") + '("nearly-certain" "GST_TYPE_FIND_NEARLY_CERTAIN") + '("maximum" "GST_TYPE_FIND_MAXIMUM") + ) +) + +(define-flags ElementState + (in-module "Gst") + (c-name "GstElementState") + (gtype-id "GST_TYPE_ELEMENT_STATE") + (values + '("void-pending" "GST_STATE_VOID_PENDING") + '("null" "GST_STATE_NULL") + '("ready" "GST_STATE_READY") + '("paused" "GST_STATE_PAUSED") + '("playing" "GST_STATE_PLAYING") + ) +) + +(define-enum ElementStateReturn + (in-module "Gst") + (c-name "GstElementStateReturn") + (gtype-id "GST_TYPE_ELEMENT_STATE_RETURN") + (values + '("failure" "GST_STATE_FAILURE") + '("success" "GST_STATE_SUCCESS") + '("async" "GST_STATE_ASYNC") + ) +) + +(define-enum Result + (in-module "Gst") + (c-name "GstResult") + (gtype-id "GST_TYPE_RESULT") + (values + '("ok" "GST_RESULT_OK") + '("nok" "GST_RESULT_NOK") + '("not-impl" "GST_RESULT_NOT_IMPL") + ) +) + +(define-enum URIType + (in-module "Gst") + (c-name "GstURIType") + (gtype-id "GST_TYPE_URI_TYPE") + (values + '("unknown" "GST_URI_UNKNOWN") + '("sink" "GST_URI_SINK") + '("src" "GST_URI_SRC") + ) +) + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstatomic.h + +(define-method init + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_init") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method destroy + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_destroy") + (return-type "none") +) + +(define-method set + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_set") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method read + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_read") + (return-type "gint") +) + +(define-method add + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_add") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method inc + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_inc") + (return-type "none") +) + +(define-method dec_and_test + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_dec_and_test") + (return-type "gboolean") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstbin.h + +(define-function gst_bin_get_type + (c-name "gst_bin_get_type") + (return-type "GType") +) + +(define-function gst_bin_new + (c-name "gst_bin_new") + (is-constructor-of "GstBin") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method add + (of-object "GstBin") + (c-name "gst_bin_add") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method add_many + (of-object "GstBin") + (c-name "gst_bin_add_many") + (return-type "none") + (parameters + '("GstElement*" "element_1") + ) + (varargs #t) +) + +(define-method remove + (of-object "GstBin") + (c-name "gst_bin_remove") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method remove_many + (of-object "GstBin") + (c-name "gst_bin_remove_many") + (return-type "none") + (parameters + '("GstElement*" "element_1") + ) + (varargs #t) +) + +(define-method get_by_name + (of-object "GstBin") + (c-name "gst_bin_get_by_name") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_by_name_recurse_up + (of-object "GstBin") + (c-name "gst_bin_get_by_name_recurse_up") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_list + (of-object "GstBin") + (c-name "gst_bin_get_list") + (return-type "const-GList*") +) + +(define-method get_by_interface + (of-object "GstBin") + (c-name "gst_bin_get_by_interface") + (return-type "GstElement*") + (parameters + '("GType" "interface") + ) +) + +(define-method get_all_by_interface + (of-object "GstBin") + (c-name "gst_bin_get_all_by_interface") + (return-type "GList*") + (parameters + '("GType" "interface") + ) +) + +(define-method iterate + (of-object "GstBin") + (c-name "gst_bin_iterate") + (return-type "gboolean") +) + +(define-method use_clock + (of-object "GstBin") + (c-name "gst_bin_use_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method get_clock + (of-object "GstBin") + (c-name "gst_bin_get_clock") + (return-type "GstClock*") +) + +(define-method auto_clock + (of-object "GstBin") + (c-name "gst_bin_auto_clock") + (return-type "none") +) + +(define-method sync_children_state + (of-object "GstBin") + (c-name "gst_bin_sync_children_state") + (return-type "GstElementStateReturn") +) + +(define-method child_state_change + (of-object "GstBin") + (c-name "gst_bin_child_state_change") + (return-type "none") + (parameters + '("GstElementState" "oldstate") + '("GstElementState" "newstate") + '("GstElement*" "child") + ) +) + +(define-method set_pre_iterate_function + (of-object "GstBin") + (c-name "gst_bin_set_pre_iterate_function") + (return-type "none") + (parameters + '("GstBinPrePostIterateFunction" "func") + '("gpointer" "user_data") + ) +) + +(define-method set_post_iterate_function + (of-object "GstBin") + (c-name "gst_bin_set_post_iterate_function") + (return-type "none") + (parameters + '("GstBinPrePostIterateFunction" "func") + '("gpointer" "user_data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstbuffer.h + +(define-function gst_buffer_get_type + (c-name "gst_buffer_get_type") + (return-type "GType") +) + +(define-function gst_buffer_new + (c-name "gst_buffer_new") + (is-constructor-of "GstBuffer") + (return-type "GstBuffer*") +) + +(define-function gst_buffer_new_and_alloc + (c-name "gst_buffer_new_and_alloc") + (return-type "GstBuffer*") + (parameters + '("guint" "size") + ) +) + +(define-method stamp + (of-object "GstBuffer") + (c-name "gst_buffer_stamp") + (return-type "none") + (parameters + '("const-GstBuffer*" "src") + ) +) + +(define-method create_sub + (of-object "GstBuffer") + (c-name "gst_buffer_create_sub") + (return-type "GstBuffer*") + (parameters + '("guint" "offset") + '("guint" "size") + ) +) + +(define-method merge + (of-object "GstBuffer") + (c-name "gst_buffer_merge") + (return-type "GstBuffer*") + (parameters + '("GstBuffer*" "buf2") + ) +) + +(define-method is_span_fast + (of-object "GstBuffer") + (c-name "gst_buffer_is_span_fast") + (return-type "gboolean") + (parameters + '("GstBuffer*" "buf2") + ) +) + +(define-method span + (of-object "GstBuffer") + (c-name "gst_buffer_span") + (return-type "GstBuffer*") + (parameters + '("guint32" "offset") + '("GstBuffer*" "buf2") + '("guint32" "len") + ) +) + +(define-function _gst_buffer_initialize + (c-name "_gst_buffer_initialize") + (return-type "none") +) + +(define-method default_free + (of-object "GstBuffer") + (c-name "gst_buffer_default_free") + (return-type "none") +) + +(define-method default_copy + (of-object "GstBuffer") + (c-name "gst_buffer_default_copy") + (return-type "GstBuffer*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstcaps.h + +(define-function _gst_caps_initialize + (c-name "_gst_caps_initialize") + (return-type "none") +) + +(define-function gst_caps_get_type + (c-name "gst_caps_get_type") + (return-type "GType") +) + +(define-function gst_caps_new_empty + (c-name "gst_caps_new_empty") + (return-type "GstCaps*") +) + +(define-function gst_caps_new_any + (c-name "gst_caps_new_any") + (return-type "GstCaps*") +) + +(define-function gst_caps_new_simple + (c-name "gst_caps_new_simple") + (return-type "GstCaps*") + (parameters + '("const-char*" "media_type") + '("const-char*" "fieldname") + ) + (varargs #t) +) + +(define-function gst_caps_new_full + (c-name "gst_caps_new_full") + (return-type "GstCaps*") + (parameters + '("GstStructure*" "struct1") + ) + (varargs #t) +) + +(define-function gst_caps_new_full_valist + (c-name "gst_caps_new_full_valist") + (return-type "GstCaps*") + (parameters + '("GstStructure*" "structure") + '("va_list" "var_args") + ) +) + +(define-method copy + (of-object "GstCaps") + (c-name "gst_caps_copy") + (return-type "GstCaps*") +) + +(define-method free + (of-object "GstCaps") + (c-name "gst_caps_free") + (return-type "none") +) + +(define-method get + (of-object "GstStaticCaps") + (c-name "gst_static_caps_get") + (return-type "const-GstCaps*") +) + +(define-method append + (of-object "GstCaps") + (c-name "gst_caps_append") + (return-type "none") + (parameters + '("GstCaps*" "caps2") + ) +) + +(define-method append_structure + (of-object "GstCaps") + (c-name "gst_caps_append_structure") + (return-type "none") + (parameters + '("GstStructure*" "structure") + ) +) + +(define-method split_one + (of-object "GstCaps") + (c-name "gst_caps_split_one") + (return-type "GstCaps*") +) + +(define-method get_size + (of-object "GstCaps") + (c-name "gst_caps_get_size") + (return-type "int") +) + +(define-method get_structure + (of-object "GstCaps") + (c-name "gst_caps_get_structure") + (return-type "GstStructure*") + (parameters + '("int" "index") + ) +) + +(define-method copy_1 + (of-object "GstCaps") + (c-name "gst_caps_copy_1") + (return-type "GstCaps*") +) + +(define-method set_simple + (of-object "GstCaps") + (c-name "gst_caps_set_simple") + (return-type "none") + (parameters + '("char*" "field") + ) + (varargs #t) +) + +(define-method set_simple_valist + (of-object "GstCaps") + (c-name "gst_caps_set_simple_valist") + (return-type "none") + (parameters + '("char*" "field") + '("va_list" "varargs") + ) +) + +(define-method is_any + (of-object "GstCaps") + (c-name "gst_caps_is_any") + (return-type "gboolean") +) + +(define-method is_empty + (of-object "GstCaps") + (c-name "gst_caps_is_empty") + (return-type "gboolean") +) + +(define-method is_chained + (of-object "GstCaps") + (c-name "gst_caps_is_chained") + (return-type "gboolean") +) + +(define-method is_fixed + (of-object "GstCaps") + (c-name "gst_caps_is_fixed") + (return-type "gboolean") +) + +(define-method is_equal_fixed + (of-object "GstCaps") + (c-name "gst_caps_is_equal_fixed") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method is_always_compatible + (of-object "GstCaps") + (c-name "gst_caps_is_always_compatible") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method intersect + (of-object "GstCaps") + (c-name "gst_caps_intersect") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method union + (of-object "GstCaps") + (c-name "gst_caps_union") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method normalize + (of-object "GstCaps") + (c-name "gst_caps_normalize") + (return-type "GstCaps*") +) + +(define-method simplify + (of-object "GstCaps") + (c-name "gst_caps_simplify") + (return-type "GstCaps*") +) + +(define-method save_thyself + (of-object "GstCaps") + (c-name "gst_caps_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-function gst_caps_load_thyself + (c-name "gst_caps_load_thyself") + (return-type "GstCaps*") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-function gst_caps_replace + (c-name "gst_caps_replace") + (return-type "none") + (parameters + '("GstCaps**" "caps") + '("GstCaps*" "newcaps") + ) +) + +(define-method to_string + (of-object "GstCaps") + (c-name "gst_caps_to_string") + (return-type "gchar*") +) + +(define-function gst_caps_from_string + (c-name "gst_caps_from_string") + (return-type "GstCaps*") + (parameters + '("const-gchar*" "string") + ) +) + +(define-function gst_caps_structure_fixate_field_nearest_int + (c-name "gst_caps_structure_fixate_field_nearest_int") + (return-type "gboolean") + (parameters + '("GstStructure*" "structure") + '("const-char*" "field_name") + '("int" "target") + ) +) + +(define-function gst_caps_structure_fixate_field_nearest_double + (c-name "gst_caps_structure_fixate_field_nearest_double") + (return-type "gboolean") + (parameters + '("GstStructure*" "structure") + '("const-char*" "field_name") + '("double" "target") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstclock.h + +(define-function gst_clock_get_type + (c-name "gst_clock_get_type") + (return-type "GType") +) + +(define-method set_speed + (of-object "GstClock") + (c-name "gst_clock_set_speed") + (return-type "gdouble") + (parameters + '("gdouble" "speed") + ) +) + +(define-method get_speed + (of-object "GstClock") + (c-name "gst_clock_get_speed") + (return-type "gdouble") +) + +(define-method set_resolution + (of-object "GstClock") + (c-name "gst_clock_set_resolution") + (return-type "guint64") + (parameters + '("guint64" "resolution") + ) +) + +(define-method get_resolution + (of-object "GstClock") + (c-name "gst_clock_get_resolution") + (return-type "guint64") +) + +(define-method set_active + (of-object "GstClock") + (c-name "gst_clock_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method is_active + (of-object "GstClock") + (c-name "gst_clock_is_active") + (return-type "gboolean") +) + +(define-method reset + (of-object "GstClock") + (c-name "gst_clock_reset") + (return-type "none") +) + +(define-method handle_discont + (of-object "GstClock") + (c-name "gst_clock_handle_discont") + (return-type "gboolean") + (parameters + '("guint64" "time") + ) +) + +(define-method get_time + (of-object "GstClock") + (c-name "gst_clock_get_time") + (return-type "GstClockTime") +) + +(define-method get_event_time + (of-object "GstClock") + (c-name "gst_clock_get_event_time") + (return-type "GstClockTime") +) + +(define-method get_next_id + (of-object "GstClock") + (c-name "gst_clock_get_next_id") + (return-type "GstClockID") +) + +(define-method new_single_shot_id + (of-object "GstClock") + (c-name "gst_clock_new_single_shot_id") + (return-type "GstClockID") + (parameters + '("GstClockTime" "time") + ) +) + +(define-method new_periodic_id + (of-object "GstClock") + (c-name "gst_clock_new_periodic_id") + (return-type "GstClockID") + (parameters + '("GstClockTime" "start_time") + '("GstClockTime" "interval") + ) +) + +(define-method get_time + (of-object "GstClockID") + (c-name "gst_clock_id_get_time") + (return-type "GstClockTime") +) + +(define-method wait + (of-object "GstClockID") + (c-name "gst_clock_id_wait") + (return-type "GstClockReturn") + (parameters + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method wait_async + (of-object "GstClockID") + (c-name "gst_clock_id_wait_async") + (return-type "GstClockReturn") + (parameters + '("GstClockCallback" "func") + '("gpointer" "user_data") + ) +) + +(define-method unschedule + (of-object "GstClockID") + (c-name "gst_clock_id_unschedule") + (return-type "none") +) + +(define-method unlock + (of-object "GstClockID") + (c-name "gst_clock_id_unlock") + (return-type "none") +) + +(define-method free + (of-object "GstClockID") + (c-name "gst_clock_id_free") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstconfig.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstcpu.h + +(define-function _gst_cpu_initialize + (c-name "_gst_cpu_initialize") + (return-type "none") + (parameters + '("gboolean" "useopt") + ) +) + +(define-function gst_cpu_get_flags + (c-name "gst_cpu_get_flags") + (return-type "GstCPUFlags") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstdata.h + +(define-method init + (of-object "GstData") + (c-name "gst_data_init") + (return-type "none") + (parameters + '("GType" "type") + '("guint16" "flags") + '("GstDataFreeFunction" "free") + '("GstDataCopyFunction" "copy") + ) +) + +(define-method dispose + (of-object "GstData") + (c-name "gst_data_dispose") + (return-type "none") +) + +(define-method copy_into + (of-object "GstData") + (c-name "gst_data_copy_into") + (return-type "none") + (parameters + '("GstData*" "target") + ) +) + +(define-method copy + (of-object "GstData") + (c-name "gst_data_copy") + (return-type "GstData*") +) + +(define-method is_writable + (of-object "GstData") + (c-name "gst_data_is_writable") + (return-type "gboolean") +) + +(define-method copy_on_write + (of-object "GstData") + (c-name "gst_data_copy_on_write") + (return-type "GstData*") +) + +(define-method free + (of-object "GstData") + (c-name "gst_data_free") + (return-type "none") +) + +(define-method ref + (of-object "GstData") + (c-name "gst_data_ref") + (return-type "GstData*") +) + +(define-method ref_by_count + (of-object "GstData") + (c-name "gst_data_ref_by_count") + (return-type "GstData*") + (parameters + '("gint" "count") + ) +) + +(define-method unref + (of-object "GstData") + (c-name "gst_data_unref") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstelement.h + +(define-method add_pad_template + (of-object "GstElementClass") + (c-name "gst_element_class_add_pad_template") + (return-type "none") + (parameters + '("GstPadTemplate*" "templ") + ) +) + +(define-method install_std_props + (of-object "GstElementClass") + (c-name "gst_element_class_install_std_props") + (return-type "none") + (parameters + '("const-gchar*" "first_name") + ) + (varargs #t) +) + +(define-method set_details + (of-object "GstElementClass") + (c-name "gst_element_class_set_details") + (return-type "none") + (parameters + '("const-GstElementDetails*" "details") + ) +) + +(define-function gst_element_default_error + (c-name "gst_element_default_error") + (return-type "none") + (parameters + '("GObject*" "object") + '("GstObject*" "orig") + '("GError*" "error") + '("gchar*" "debug") + ) +) + +(define-function gst_element_get_type + (c-name "gst_element_get_type") + (return-type "GType") +) + +(define-method set_loop_function + (of-object "GstElement") + (c-name "gst_element_set_loop_function") + (return-type "none") + (parameters + '("GstElementLoopFunction" "loop") + ) +) + +(define-method set + (of-object "GstElement") + (c-name "gst_element_set") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + ) + (varargs #t) +) + +(define-method get + (of-object "GstElement") + (c-name "gst_element_get") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + ) + (varargs #t) +) + +(define-method set_valist + (of-object "GstElement") + (c-name "gst_element_set_valist") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + '("va_list" "var_args") + ) +) + +(define-method get_valist + (of-object "GstElement") + (c-name "gst_element_get_valist") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + '("va_list" "var_args") + ) +) + +(define-method set_property + (of-object "GstElement") + (c-name "gst_element_set_property") + (return-type "none") + (parameters + '("const-gchar*" "property_name") + '("const-GValue*" "value") + ) +) + +(define-method get_property + (of-object "GstElement") + (c-name "gst_element_get_property") + (return-type "none") + (parameters + '("const-gchar*" "property_name") + '("GValue*" "value") + ) +) + +(define-method enable_threadsafe_properties + (of-object "GstElement") + (c-name "gst_element_enable_threadsafe_properties") + (return-type "none") +) + +(define-method disable_threadsafe_properties + (of-object "GstElement") + (c-name "gst_element_disable_threadsafe_properties") + (return-type "none") +) + +(define-method set_pending_properties + (of-object "GstElement") + (c-name "gst_element_set_pending_properties") + (return-type "none") +) + +(define-method requires_clock + (of-object "GstElement") + (c-name "gst_element_requires_clock") + (return-type "gboolean") +) + +(define-method provides_clock + (of-object "GstElement") + (c-name "gst_element_provides_clock") + (return-type "gboolean") +) + +(define-method get_clock + (of-object "GstElement") + (c-name "gst_element_get_clock") + (return-type "GstClock*") +) + +(define-method set_clock + (of-object "GstElement") + (c-name "gst_element_set_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method clock_wait + (of-object "GstElement") + (c-name "gst_element_clock_wait") + (return-type "GstClockReturn") + (parameters + '("GstClockID" "id") + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method get_time + (of-object "GstElement") + (c-name "gst_element_get_time") + (return-type "GstClockTime") +) + +(define-method wait + (of-object "GstElement") + (c-name "gst_element_wait") + (return-type "gboolean") + (parameters + '("GstClockTime" "timestamp") + ) +) + +(define-method set_time + (of-object "GstElement") + (c-name "gst_element_set_time") + (return-type "none") + (parameters + '("GstClockTime" "time") + ) +) + +(define-method adjust_time + (of-object "GstElement") + (c-name "gst_element_adjust_time") + (return-type "none") + (parameters + '("GstClockTimeDiff" "diff") + ) +) + +(define-method is_indexable + (of-object "GstElement") + (c-name "gst_element_is_indexable") + (return-type "gboolean") +) + +(define-method set_index + (of-object "GstElement") + (c-name "gst_element_set_index") + (return-type "none") + (parameters + '("GstIndex*" "index") + ) +) + +(define-method get_index + (of-object "GstElement") + (c-name "gst_element_get_index") + (return-type "GstIndex*") +) + +(define-method release_locks + (of-object "GstElement") + (c-name "gst_element_release_locks") + (return-type "gboolean") +) + +(define-method yield + (of-object "GstElement") + (c-name "gst_element_yield") + (return-type "none") +) + +(define-method interrupt + (of-object "GstElement") + (c-name "gst_element_interrupt") + (return-type "gboolean") +) + +(define-method set_scheduler + (of-object "GstElement") + (c-name "gst_element_set_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched") + ) +) + +(define-method get_scheduler + (of-object "GstElement") + (c-name "gst_element_get_scheduler") + (return-type "GstScheduler*") +) + +(define-method add_pad + (of-object "GstElement") + (c-name "gst_element_add_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method remove_pad + (of-object "GstElement") + (c-name "gst_element_remove_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method add_ghost_pad + (of-object "GstElement") + (c-name "gst_element_add_ghost_pad") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + '("const-gchar*" "name") + ) +) + +(define-method remove_ghost_pad + (of-object "GstElement") + (c-name "gst_element_remove_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_pad + (of-object "GstElement") + (c-name "gst_element_get_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_static_pad + (of-object "GstElement") + (c-name "gst_element_get_static_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_request_pad + (of-object "GstElement") + (c-name "gst_element_get_request_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method release_request_pad + (of-object "GstElement") + (c-name "gst_element_release_request_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_pad_list + (of-object "GstElement") + (c-name "gst_element_get_pad_list") + (return-type "const-GList*") +) + +(define-method get_compatible_pad + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_compatible_pad_filtered + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad_filtered") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method get_pad_template + (of-object "GstElementClass") + (c-name "gst_element_class_get_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_pad_template_list + (of-object "GstElementClass") + (c-name "gst_element_class_get_pad_template_list") + (return-type "GList*") +) + +(define-method get_pad_template + (of-object "GstElement") + (c-name "gst_element_get_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_pad_template_list + (of-object "GstElement") + (c-name "gst_element_get_pad_template_list") + (return-type "GList*") +) + +(define-method get_compatible_pad_template + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("GstPadTemplate*" "compattempl") + ) +) + +(define-method link + (of-object "GstElement") + (c-name "gst_element_link") + (return-type "gboolean") + (parameters + '("GstElement*" "dest") + ) +) + +(define-method link_filtered + (of-object "GstElement") + (c-name "gst_element_link_filtered") + (return-type "gboolean") + (parameters + '("GstElement*" "dest") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-function element_link_many + (c-name "gst_element_link_many") + (return-type "gboolean") + (parameters + '("GstElement*" "element_1") + '("GstElement*" "element_2") + ) + (varargs #t) +) + +(define-method unlink + (of-object "GstElement") + (c-name "gst_element_unlink") + (return-type "none") + (parameters + '("GstElement*" "dest") + ) +) + +(define-method unlink_many + (of-object "GstElement") + (c-name "gst_element_unlink_many") + (return-type "none") + (parameters + '("GstElement*" "element_2") + ) + (varargs #t) +) + +(define-method link_pads + (of-object "GstElement") + (c-name "gst_element_link_pads") + (return-type "gboolean") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + ) +) + +(define-method link_pads_filtered + (of-object "GstElement") + (c-name "gst_element_link_pads_filtered") + (return-type "gboolean") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method unlink_pads + (of-object "GstElement") + (c-name "gst_element_unlink_pads") + (return-type "none") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + ) +) + +(define-method get_event_masks + (of-object "GstElement") + (c-name "gst_element_get_event_masks") + (return-type "const-GstEventMask*") +) + +(define-method send_event + (of-object "GstElement") + (c-name "gst_element_send_event") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-method seek + (of-object "GstElement") + (c-name "gst_element_seek") + (return-type "gboolean") + (parameters + '("GstSeekType" "seek_type") + '("guint64" "offset") + ) +) + +(define-method get_query_types + (of-object "GstElement") + (c-name "gst_element_get_query_types") + (return-type "const-GstQueryType*") +) + +(define-method query + (of-object "GstElement") + (c-name "gst_element_query") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method get_formats + (of-object "GstElement") + (c-name "gst_element_get_formats") + (return-type "const-GstFormat*") +) + +(define-method convert + (of-object "GstElement") + (c-name "gst_element_convert") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method found_tags + (of-object "GstElement") + (c-name "gst_element_found_tags") + (return-type "none") + (parameters + '("const-GstTagList*" "tag_list") + ) +) + +(define-method found_tags_for_pad + (of-object "GstElement") + (c-name "gst_element_found_tags_for_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + '("GstClockTime" "timestamp") + '("GstTagList*" "list") + ) +) + +(define-method set_eos + (of-object "GstElement") + (c-name "gst_element_set_eos") + (return-type "none") +) + +(define-function _gst_element_error_printf + (c-name "_gst_element_error_printf") + (return-type "gchar*") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-method error_full + (of-object "GstElement") + (c-name "gst_element_error_full") + (return-type "none") + (parameters + '("GQuark" "domain") + '("gint" "code") + '("gchar*" "message") + '("gchar*" "debug") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + ) +) + +(define-method is_locked_state + (of-object "GstElement") + (c-name "gst_element_is_locked_state") + (return-type "gboolean") +) + +(define-method set_locked_state + (of-object "GstElement") + (c-name "gst_element_set_locked_state") + (return-type "none") + (parameters + '("gboolean" "locked_state") + ) +) + +(define-method sync_state_with_parent + (of-object "GstElement") + (c-name "gst_element_sync_state_with_parent") + (return-type "gboolean") +) + +(define-method get_state + (of-object "GstElement") + (c-name "gst_element_get_state") + (return-type "GstElementState") +) + +(define-method set_state + (of-object "GstElement") + (c-name "gst_element_set_state") + (return-type "GstElementStateReturn") + (parameters + '("GstElementState" "state") + ) +) + +(define-method wait_state_change + (of-object "GstElement") + (c-name "gst_element_wait_state_change") + (return-type "none") +) + +(define-method get_name + (of-object "GstElementState") + (c-name "gst_element_state_get_name") + (return-type "const-gchar*") +) + +(define-method get_factory + (of-object "GstElement") + (c-name "gst_element_get_factory") + (return-type "GstElementFactory*") +) + +(define-method get_managing_bin + (of-object "GstElement") + (c-name "gst_element_get_managing_bin") + (return-type "GstBin*") +) + +(define-function gst_element_factory_get_type + (c-name "gst_element_factory_get_type") + (return-type "GType") +) + +(define-function gst_element_register + (c-name "gst_element_register") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + '("const-gchar*" "elementname") + '("guint" "rank") + '("GType" "type") + ) +) + +(define-function gst_element_factory_find + (c-name "gst_element_factory_find") + (return-type "GstElementFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_element_type + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_element_type") + (return-type "GType") +) + +(define-method get_longname + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_longname") + (return-type "const-gchar*") +) + +(define-method get_klass + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_klass") + (return-type "const-gchar*") +) + +(define-method get_description + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_description") + (return-type "const-gchar*") +) + +(define-method get_author + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_author") + (return-type "const-gchar*") +) + +(define-method get_num_pad_templates + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_num_pad_templates") + (return-type "guint") +) + +(define-method get_pad_templates + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_pad_templates") + (return-type "const-GList*") +) + +(define-method get_uri_type + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_uri_type") + (return-type "guint") +) + +(define-method get_uri_protocols + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_uri_protocols") + (return-type "gchar**") +) + +(define-method create + (of-object "GstElementFactory") + (c-name "gst_element_factory_create") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_element_factory_make + (is-constructor-of "GstElement") + (c-name "gst_element_factory_make") + (return-type "GstElement*") + (parameters + '("const-gchar*" "factoryname") + '("const-gchar*" "name") + ) +) + +(define-method can_src_caps + (of-object "GstElementFactory") + (c-name "gst_element_factory_can_src_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method can_sink_caps + (of-object "GstElementFactory") + (c-name "gst_element_factory_can_sink_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method __add_pad_template + (of-object "GstElementFactory") + (c-name "__gst_element_factory_add_pad_template") + (return-type "none") + (parameters + '("GstPadTemplate*" "templ") + ) +) + +(define-method __add_interface + (of-object "GstElementFactory") + (c-name "__gst_element_factory_add_interface") + (return-type "none") + (parameters + '("const-gchar*" "interfacename") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstenumtypes.h + +(define-function gst_object_flags_get_type + (c-name "gst_object_flags_get_type") + (return-type "GType") +) + +(define-function gst_bin_flags_get_type + (c-name "gst_bin_flags_get_type") + (return-type "GType") +) + +(define-function gst_buffer_flag_get_type + (c-name "gst_buffer_flag_get_type") + (return-type "GType") +) + +(define-function gst_clock_entry_status_get_type + (c-name "gst_clock_entry_status_get_type") + (return-type "GType") +) + +(define-function gst_clock_entry_type_get_type + (c-name "gst_clock_entry_type_get_type") + (return-type "GType") +) + +(define-function gst_clock_return_get_type + (c-name "gst_clock_return_get_type") + (return-type "GType") +) + +(define-function gst_clock_flags_get_type + (c-name "gst_clock_flags_get_type") + (return-type "GType") +) + +(define-function gst_cpu_flags_get_type + (c-name "gst_cpu_flags_get_type") + (return-type "GType") +) + +(define-function gst_data_flags_get_type + (c-name "gst_data_flags_get_type") + (return-type "GType") +) + +(define-function gst_element_flags_get_type + (c-name "gst_element_flags_get_type") + (return-type "GType") +) + +(define-function gst_core_error_get_type + (c-name "gst_core_error_get_type") + (return-type "GType") +) + +(define-function gst_library_error_get_type + (c-name "gst_library_error_get_type") + (return-type "GType") +) + +(define-function gst_resource_error_get_type + (c-name "gst_resource_error_get_type") + (return-type "GType") +) + +(define-function gst_stream_error_get_type + (c-name "gst_stream_error_get_type") + (return-type "GType") +) + +(define-function gst_event_type_get_type + (c-name "gst_event_type_get_type") + (return-type "GType") +) + +(define-function gst_event_flag_get_type + (c-name "gst_event_flag_get_type") + (return-type "GType") +) + +(define-function gst_seek_type_get_type + (c-name "gst_seek_type_get_type") + (return-type "GType") +) + +(define-function gst_seek_accuracy_get_type + (c-name "gst_seek_accuracy_get_type") + (return-type "GType") +) + +(define-function gst_format_get_type + (c-name "gst_format_get_type") + (return-type "GType") +) + +(define-function gst_index_certainty_get_type + (c-name "gst_index_certainty_get_type") + (return-type "GType") +) + +(define-function gst_index_entry_type_get_type + (c-name "gst_index_entry_type_get_type") + (return-type "GType") +) + +(define-function gst_index_lookup_method_get_type + (c-name "gst_index_lookup_method_get_type") + (return-type "GType") +) + +(define-function gst_assoc_flags_get_type + (c-name "gst_assoc_flags_get_type") + (return-type "GType") +) + +(define-function gst_index_resolver_method_get_type + (c-name "gst_index_resolver_method_get_type") + (return-type "GType") +) + +(define-function gst_index_flags_get_type + (c-name "gst_index_flags_get_type") + (return-type "GType") +) + +(define-function gst_debug_level_get_type + (c-name "gst_debug_level_get_type") + (return-type "GType") +) + +(define-function gst_debug_color_flags_get_type + (c-name "gst_debug_color_flags_get_type") + (return-type "GType") +) + +(define-function gst_pad_link_return_get_type + (c-name "gst_pad_link_return_get_type") + (return-type "GType") +) + +(define-function gst_pad_direction_get_type + (c-name "gst_pad_direction_get_type") + (return-type "GType") +) + +(define-function gst_pad_flags_get_type + (c-name "gst_pad_flags_get_type") + (return-type "GType") +) + +(define-function gst_pad_presence_get_type + (c-name "gst_pad_presence_get_type") + (return-type "GType") +) + +(define-function gst_pad_template_flags_get_type + (c-name "gst_pad_template_flags_get_type") + (return-type "GType") +) + +(define-function gst_plugin_error_get_type + (c-name "gst_plugin_error_get_type") + (return-type "GType") +) + +(define-function gst_query_type_get_type + (c-name "gst_query_type_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_flags_get_type + (c-name "gst_scheduler_flags_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_state_get_type + (c-name "gst_scheduler_state_get_type") + (return-type "GType") +) + +(define-function gst_tag_merge_mode_get_type + (c-name "gst_tag_merge_mode_get_type") + (return-type "GType") +) + +(define-function gst_tag_flag_get_type + (c-name "gst_tag_flag_get_type") + (return-type "GType") +) + +(define-function gst_thread_state_get_type + (c-name "gst_thread_state_get_type") + (return-type "GType") +) + +(define-function gst_alloc_trace_flags_get_type + (c-name "gst_alloc_trace_flags_get_type") + (return-type "GType") +) + +(define-function gst_type_find_probability_get_type + (c-name "gst_type_find_probability_get_type") + (return-type "GType") +) + +(define-function gst_element_state_get_type + (c-name "gst_element_state_get_type") + (return-type "GType") +) + +(define-function gst_element_state_return_get_type + (c-name "gst_element_state_return_get_type") + (return-type "GType") +) + +(define-function gst_result_get_type + (c-name "gst_result_get_type") + (return-type "GType") +) + +(define-function gst_uri_type_get_type + (c-name "gst_uri_type_get_type") + (return-type "GType") +) + +(define-function gst_registry_return_get_type + (c-name "gst_registry_return_get_type") + (return-type "GType") +) + +(define-function gst_registry_flags_get_type + (c-name "gst_registry_flags_get_type") + (return-type "GType") +) + +(define-function gst_parse_error_get_type + (c-name "gst_parse_error_get_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsterror.h + +(define-function gst_core_error_quark + (c-name "gst_core_error_quark") + (return-type "GQuark") +) + +(define-function gst_library_error_quark + (c-name "gst_library_error_quark") + (return-type "GQuark") +) + +(define-function gst_resource_error_quark + (c-name "gst_resource_error_quark") + (return-type "GQuark") +) + +(define-function gst_stream_error_quark + (c-name "gst_stream_error_quark") + (return-type "GQuark") +) + +(define-function gst_error_get_message + (c-name "gst_error_get_message") + (return-type "gchar*") + (parameters + '("GQuark" "domain") + '("gint" "code") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstevent.h + +(define-function _gst_event_initialize + (c-name "_gst_event_initialize") + (return-type "none") +) + +(define-function gst_event_get_type + (c-name "gst_event_get_type") + (return-type "GType") +) + +(define-function gst_event_new + (c-name "gst_event_new") + (is-constructor-of "GstEvent") + (return-type "GstEvent*") + (parameters + '("GstEventType" "type") + ) +) + +(define-method s_contains + (of-object "GstEventMask") + (c-name "gst_event_masks_contains") + (return-type "gboolean") + (parameters + '("GstEventMask*" "mask") + ) +) + +(define-function gst_event_new_seek + (c-name "gst_event_new_seek") + (return-type "GstEvent*") + (parameters + '("GstSeekType" "type") + '("gint64" "offset") + ) +) + +(define-function gst_event_new_segment_seek + (c-name "gst_event_new_segment_seek") + (return-type "GstEvent*") + (parameters + '("GstSeekType" "type") + '("gint64" "start") + '("gint64" "stop") + ) +) + +(define-function gst_event_new_size + (c-name "gst_event_new_size") + (return-type "GstEvent*") + (parameters + '("GstFormat" "format") + '("gint64" "value") + ) +) + +(define-function gst_event_new_discontinuous + (c-name "gst_event_new_discontinuous") + (return-type "GstEvent*") + (parameters + '("gboolean" "new_media") + '("GstFormat" "format1") + ) + (varargs #t) +) + +(define-function gst_event_new_discontinuous_valist + (c-name "gst_event_new_discontinuous_valist") + (return-type "GstEvent*") + (parameters + '("gboolean" "new_media") + '("GstFormat" "format1") + '("va_list" "var_args") + ) +) + +(define-method discont_get_value + (of-object "GstEvent") + (c-name "gst_event_discont_get_value") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + '("gint64*" "value") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstfilter.h + +(define-function gst_filter_run + (c-name "gst_filter_run") + (return-type "GList*") + (parameters + '("const-GList*" "list") + '("GstFilterFunc" "func") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstformat.h + +(define-function _gst_format_initialize + (c-name "_gst_format_initialize") + (return-type "none") +) + +(define-function gst_format_register + (c-name "gst_format_register") + (return-type "GstFormat") + (parameters + '("const-gchar*" "nick") + '("const-gchar*" "description") + ) +) + +(define-function gst_format_get_by_nick + (c-name "gst_format_get_by_nick") + (return-type "GstFormat") + (parameters + '("const-gchar*" "nick") + ) +) + +(define-method s_contains + (of-object "GstFormat") + (c-name "gst_formats_contains") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + ) +) + +(define-method get_details + (of-object "GstFormat") + (c-name "gst_format_get_details") + (return-type "const-GstFormatDefinition*") +) + +(define-function gst_format_get_definitions + (c-name "gst_format_get_definitions") + (return-type "const-GList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gst.h + +(define-function gst_init + (c-name "gst_init") + (return-type "none") + (parameters + '("int*" "argc") + '("char**[]" "argv") + ) +) + +(define-function gst_init_check + (c-name "gst_init_check") + (return-type "gboolean") + (parameters + '("int*" "argc") + '("char**[]" "argv") + ) +) + +(define-function gst_init_with_popt_table + (c-name "gst_init_with_popt_table") + (return-type "none") + (parameters + '("int*" "argc") + '("char**[]" "argv") + '("const-GstPoptOption*" "popt_options") + ) +) + +(define-function gst_init_check_with_popt_table + (c-name "gst_init_check_with_popt_table") + (return-type "gboolean") + (parameters + '("int*" "argc") + '("char**[]" "argv") + '("const-GstPoptOption*" "popt_options") + ) +) + +(define-function gst_init_get_popt_table + (c-name "gst_init_get_popt_table") + (return-type "const-GstPoptOption*") +) + +(define-function gst_use_threads + (c-name "gst_use_threads") + (return-type "none") + (parameters + '("gboolean" "use_threads") + ) +) + +(define-function gst_has_threads + (c-name "gst_has_threads") + (return-type "gboolean") +) + +(define-function gst_main + (c-name "gst_main") + (return-type "none") +) + +(define-function gst_main_quit + (c-name "gst_main_quit") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstindex.h + +(define-function gst_index_get_type + (c-name "gst_index_get_type") + (return-type "GType") +) + +(define-function gst_index_new + (c-name "gst_index_new") + (is-constructor-of "GstIndex") + (return-type "GstIndex*") +) + +(define-method commit + (of-object "GstIndex") + (c-name "gst_index_commit") + (return-type "none") + (parameters + '("gint" "id") + ) +) + +(define-method get_group + (of-object "GstIndex") + (c-name "gst_index_get_group") + (return-type "gint") +) + +(define-method new_group + (of-object "GstIndex") + (c-name "gst_index_new_group") + (return-type "gint") +) + +(define-method set_group + (of-object "GstIndex") + (c-name "gst_index_set_group") + (return-type "gboolean") + (parameters + '("gint" "groupnum") + ) +) + +(define-method set_certainty + (of-object "GstIndex") + (c-name "gst_index_set_certainty") + (return-type "none") + (parameters + '("GstIndexCertainty" "certainty") + ) +) + +(define-method get_certainty + (of-object "GstIndex") + (c-name "gst_index_get_certainty") + (return-type "GstIndexCertainty") +) + +(define-method set_filter + (of-object "GstIndex") + (c-name "gst_index_set_filter") + (return-type "none") + (parameters + '("GstIndexFilter" "filter") + '("gpointer" "user_data") + ) +) + +(define-method set_resolver + (of-object "GstIndex") + (c-name "gst_index_set_resolver") + (return-type "none") + (parameters + '("GstIndexResolver" "resolver") + '("gpointer" "user_data") + ) +) + +(define-method get_writer_id + (of-object "GstIndex") + (c-name "gst_index_get_writer_id") + (return-type "gboolean") + (parameters + '("GstObject*" "writer") + '("gint*" "id") + ) +) + +(define-method add_format + (of-object "GstIndex") + (c-name "gst_index_add_format") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstFormat" "format") + ) +) + +(define-method add_association + (of-object "GstIndex") + (c-name "gst_index_add_association") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + ) + (varargs #t) +) + +(define-method add_object + (of-object "GstIndex") + (c-name "gst_index_add_object") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("gchar*" "key") + '("GType" "type") + '("gpointer" "object") + ) +) + +(define-method add_id + (of-object "GstIndex") + (c-name "gst_index_add_id") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("gchar*" "description") + ) +) + +(define-method get_assoc_entry + (of-object "GstIndex") + (c-name "gst_index_get_assoc_entry") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstIndexLookupMethod" "method") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + ) +) + +(define-method get_assoc_entry_full + (of-object "GstIndex") + (c-name "gst_index_get_assoc_entry_full") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstIndexLookupMethod" "method") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + '("GCompareDataFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-function gst_index_entry_get_type + (c-name "gst_index_entry_get_type") + (return-type "GType") +) + +(define-method copy + (of-object "GstIndexEntry") + (c-name "gst_index_entry_copy") + (return-type "GstIndexEntry*") +) + +(define-method free + (of-object "GstIndexEntry") + (c-name "gst_index_entry_free") + (return-type "none") +) + +(define-method assoc_map + (of-object "GstIndexEntry") + (c-name "gst_index_entry_assoc_map") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + '("gint64*" "value") + ) +) + +(define-function gst_index_factory_get_type + (c-name "gst_index_factory_get_type") + (return-type "GType") +) + +(define-function gst_index_factory_new + (c-name "gst_index_factory_new") + (is-constructor-of "GstIndexFactory") + (return-type "GstIndexFactory*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "longdesc") + '("GType" "type") + ) +) + +(define-method destroy + (of-object "GstIndexFactory") + (c-name "gst_index_factory_destroy") + (return-type "none") +) + +(define-function gst_index_factory_find + (c-name "gst_index_factory_find") + (return-type "GstIndexFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method create + (of-object "GstIndexFactory") + (c-name "gst_index_factory_create") + (return-type "GstIndex*") +) + +(define-function gst_index_factory_make + (c-name "gst_index_factory_make") + (return-type "GstIndex*") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstinfo.h + +(define-function _gst_debug_init + (c-name "_gst_debug_init") + (return-type "none") +) + +(define-function gst_debug_log + (c-name "gst_debug_log") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function gst_debug_log_valist + (c-name "gst_debug_log_valist") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("const-gchar*" "format") + '("va_list" "args") + ) +) + +(define-method get + (of-object "GstDebugMessage") + (c-name "gst_debug_message_get") + (return-type "const-gchar*") +) + +(define-function gst_debug_log_default + (c-name "gst_debug_log_default") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("GstDebugMessage*" "message") + '("gpointer" "unused") + ) +) + +(define-method get_name + (of-object "GstDebugLevel") + (c-name "gst_debug_level_get_name") + (return-type "const-gchar*") +) + +(define-function gst_debug_add_log_function + (c-name "gst_debug_add_log_function") + (return-type "none") + (parameters + '("GstLogFunction" "func") + '("gpointer" "data") + ) +) + +(define-function gst_debug_remove_log_function + (c-name "gst_debug_remove_log_function") + (return-type "guint") + (parameters + '("GstLogFunction" "func") + ) +) + +(define-function gst_debug_remove_log_function_by_data + (c-name "gst_debug_remove_log_function_by_data") + (return-type "guint") + (parameters + '("gpointer" "data") + ) +) + +(define-function gst_debug_set_active + (c-name "gst_debug_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-function gst_debug_is_active + (c-name "gst_debug_is_active") + (return-type "gboolean") +) + +(define-function gst_debug_set_colored + (c-name "gst_debug_set_colored") + (return-type "none") + (parameters + '("gboolean" "colored") + ) +) + +(define-function gst_debug_is_colored + (c-name "gst_debug_is_colored") + (return-type "gboolean") +) + +(define-function gst_debug_set_default_threshold + (c-name "gst_debug_set_default_threshold") + (return-type "none") + (parameters + '("GstDebugLevel" "level") + ) +) + +(define-function gst_debug_get_default_threshold + (c-name "gst_debug_get_default_threshold") + (return-type "GstDebugLevel") +) + +(define-function gst_debug_set_threshold_for_name + (c-name "gst_debug_set_threshold_for_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("GstDebugLevel" "level") + ) +) + +(define-function gst_debug_unset_threshold_for_name + (c-name "gst_debug_unset_threshold_for_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function _gst_debug_category_new + (c-name "_gst_debug_category_new") + (is-constructor-of "GstDebugCategory") + (return-type "GstDebugCategory*") + (parameters + '("gchar*" "name") + '("guint" "color") + '("gchar*" "description") + ) +) + +(define-method free + (of-object "GstDebugCategory") + (c-name "gst_debug_category_free") + (return-type "none") +) + +(define-method set_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_set_threshold") + (return-type "none") + (parameters + '("GstDebugLevel" "level") + ) +) + +(define-method reset_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_reset_threshold") + (return-type "none") +) + +(define-method get_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_threshold") + (return-type "GstDebugLevel") +) + +(define-method get_name + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_name") + (return-type "const-gchar*") +) + +(define-method get_color + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_color") + (return-type "guint") +) + +(define-method get_description + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_description") + (return-type "const-gchar*") +) + +(define-function gst_debug_get_all_categories + (c-name "gst_debug_get_all_categories") + (return-type "GSList*") +) + +(define-function gst_debug_construct_term_color + (c-name "gst_debug_construct_term_color") + (return-type "gchar*") + (parameters + '("guint" "colorinfo") + ) +) + +(define-function _gst_debug_register_funcptr + (c-name "_gst_debug_register_funcptr") + (return-type "void*") + (parameters + '("void*" "ptr") + '("gchar*" "ptrname") + ) +) + +(define-function _gst_debug_nameof_funcptr + (c-name "_gst_debug_nameof_funcptr") + (return-type "const-gchar*") + (parameters + '("void*" "ptr") + ) +) + +(define-function gst_debug_print_stack_trace + (c-name "gst_debug_print_stack_trace") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstinterface.h + +(define-function gst_implements_interface_get_type + (c-name "gst_implements_interface_get_type") + (return-type "GType") +) + +(define-method implements_interface + (of-object "GstElement") + (c-name "gst_element_implements_interface") + (return-type "gboolean") + (parameters + '("GType" "iface_type") + ) +) + +(define-function gst_implements_interface_cast + (c-name "gst_implements_interface_cast") + (return-type "gpointer") + (parameters + '("gpointer" "from") + '("GType" "type") + ) +) + +(define-function gst_implements_interface_check + (c-name "gst_implements_interface_check") + (return-type "gboolean") + (parameters + '("gpointer" "from") + '("GType" "type") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstlog.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmacros.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmarshal.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmemchunk.h + +(define-function gst_mem_chunk_new + (c-name "gst_mem_chunk_new") + (is-constructor-of "GstMemChunk") + (return-type "GstMemChunk*") + (parameters + '("gchar*" "name") + '("gint" "atom_size") + '("gulong" "area_size") + '("gint" "type") + ) +) + +(define-method destroy + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_destroy") + (return-type "none") +) + +(define-method alloc + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_alloc") + (return-type "gpointer") +) + +(define-method alloc0 + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_alloc0") + (return-type "gpointer") +) + +(define-method free + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_free") + (return-type "none") + (parameters + '("gpointer" "mem") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstobject.h + +(define-function gst_object_get_type + (c-name "gst_object_get_type") + (return-type "GType") +) + +(define-method set_name + (of-object "GstObject") + (c-name "gst_object_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_name + (of-object "GstObject") + (c-name "gst_object_get_name") + (return-type "const-gchar*") +) + +(define-method set_parent + (of-object "GstObject") + (c-name "gst_object_set_parent") + (return-type "none") + (parameters + '("GstObject*" "parent") + ) +) + +(define-method get_parent + (of-object "GstObject") + (c-name "gst_object_get_parent") + (return-type "GstObject*") +) + +(define-method unparent + (of-object "GstObject") + (c-name "gst_object_unparent") + (return-type "none") +) + +(define-function gst_object_default_deep_notify + (c-name "gst_object_default_deep_notify") + (return-type "none") + (parameters + '("GObject*" "object") + '("GstObject*" "orig") + '("GParamSpec*" "pspec") + '("gchar**" "excluded_props") + ) +) + +(define-function gst_object_check_uniqueness + (c-name "gst_object_check_uniqueness") + (return-type "gboolean") + (parameters + '("GList*" "list") + '("const-gchar*" "name") + ) +) + +(define-method save_thyself + (of-object "GstObject") + (c-name "gst_object_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-method restore_thyself + (of-object "GstObject") + (c-name "gst_object_restore_thyself") + (return-type "none") + (parameters + '("xmlNodePtr" "self") + ) +) + +(define-method ref + (of-object "GstObject") + (c-name "gst_object_ref") + (return-type "GstObject*") +) + +(define-method unref + (of-object "GstObject") + (c-name "gst_object_unref") + (return-type "none") +) + +(define-method sink + (of-object "GstObject") + (c-name "gst_object_sink") + (return-type "none") +) + +(define-function gst_object_replace + (c-name "gst_object_replace") + (return-type "none") + (parameters + '("GstObject**" "oldobj") + '("GstObject*" "newobj") + ) +) + +(define-method get_path_string + (of-object "GstObject") + (c-name "gst_object_get_path_string") + (return-type "gchar*") +) + +(define-function gst_class_signal_connect + (c-name "gst_class_signal_connect") + (return-type "guint") + (parameters + '("GstObjectClass*" "klass") + '("const-gchar*" "name") + '("gpointer" "func") + '("gpointer" "func_data") + ) +) + +(define-function gst_class_signal_emit_by_name + (c-name "gst_class_signal_emit_by_name") + (return-type "none") + (parameters + '("GstObject*" "object") + '("const-gchar*" "name") + '("xmlNodePtr" "self") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpad.h + +(define-function gst_pad_get_type + (c-name "gst_pad_get_type") + (return-type "GType") +) + +(define-function gst_real_pad_get_type + (c-name "gst_real_pad_get_type") + (return-type "GType") +) + +(define-function gst_ghost_pad_get_type + (c-name "gst_ghost_pad_get_type") + (return-type "GType") +) + +(define-function gst_pad_new + (c-name "gst_pad_new") + (is-constructor-of "GstPad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + '("GstPadDirection" "direction") + ) +) + +(define-function gst_pad_new_from_template + (c-name "gst_pad_new_from_template") + (return-type "GstPad*") + (parameters + '("GstPadTemplate*" "templ") + '("const-gchar*" "name") + ) +) + +(define-function gst_pad_custom_new + (c-name "gst_pad_custom_new") + (is-constructor-of "GstPadCustom") + (return-type "GstPad*") + (parameters + '("GType" "type") + '("const-gchar*" "name") + '("GstPadDirection" "direction") + ) +) + +(define-function gst_pad_custom_new_from_template + (c-name "gst_pad_custom_new_from_template") + (return-type "GstPad*") + (parameters + '("GType" "type") + '("GstPadTemplate*" "templ") + '("const-gchar*" "name") + ) +) + +(define-method set_name + (of-object "GstPad") + (c-name "gst_pad_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_name + (of-object "GstPad") + (c-name "gst_pad_get_name") + (return-type "const-gchar*") +) + +(define-method get_direction + (of-object "GstPad") + (c-name "gst_pad_get_direction") + (return-type "GstPadDirection") +) + +(define-method set_active + (of-object "GstPad") + (c-name "gst_pad_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method is_active + (of-object "GstPad") + (c-name "gst_pad_is_active") + (return-type "gboolean") +) + +(define-method set_element_private + (of-object "GstPad") + (c-name "gst_pad_set_element_private") + (return-type "none") + (parameters + '("gpointer" "priv") + ) +) + +(define-method get_element_private + (of-object "GstPad") + (c-name "gst_pad_get_element_private") + (return-type "gpointer") +) + +(define-method set_parent + (of-object "GstPad") + (c-name "gst_pad_set_parent") + (return-type "none") + (parameters + '("GstElement*" "parent") + ) +) + +(define-method get_parent + (of-object "GstPad") + (c-name "gst_pad_get_parent") + (return-type "GstElement*") +) + +(define-method get_real_parent + (of-object "GstPad") + (c-name "gst_pad_get_real_parent") + (return-type "GstElement*") +) + +(define-method get_scheduler + (of-object "GstPad") + (c-name "gst_pad_get_scheduler") + (return-type "GstScheduler*") +) + +(define-method add_ghost_pad + (of-object "GstPad") + (c-name "gst_pad_add_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "ghostpad") + ) +) + +(define-method remove_ghost_pad + (of-object "GstPad") + (c-name "gst_pad_remove_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "ghostpad") + ) +) + +(define-method get_ghost_pad_list + (of-object "GstPad") + (c-name "gst_pad_get_ghost_pad_list") + (return-type "GList*") +) + +(define-method get_pad_template + (of-object "GstPad") + (c-name "gst_pad_get_pad_template") + (return-type "GstPadTemplate*") +) + +(define-method set_bufferalloc_function + (of-object "GstPad") + (c-name "gst_pad_set_bufferalloc_function") + (return-type "none") + (parameters + '("GstPadBufferAllocFunction" "bufferalloc") + ) +) + +(define-method alloc_buffer + (of-object "GstPad") + (c-name "gst_pad_alloc_buffer") + (return-type "GstBuffer*") + (parameters + '("guint64" "offset") + '("gint" "size") + ) +) + +(define-method set_chain_function + (of-object "GstPad") + (c-name "gst_pad_set_chain_function") + (return-type "none") + (parameters + '("GstPadChainFunction" "chain") + ) +) + +(define-method set_get_function + (of-object "GstPad") + (c-name "gst_pad_set_get_function") + (return-type "none") + (parameters + '("GstPadGetFunction" "get") + ) +) + +(define-method set_event_function + (of-object "GstPad") + (c-name "gst_pad_set_event_function") + (return-type "none") + (parameters + '("GstPadEventFunction" "event") + ) +) + +(define-method set_event_mask_function + (of-object "GstPad") + (c-name "gst_pad_set_event_mask_function") + (return-type "none") + (parameters + '("GstPadEventMaskFunction" "mask_func") + ) +) + +(define-method get_event_masks + (of-object "GstPad") + (c-name "gst_pad_get_event_masks") + (return-type "const-GstEventMask*") +) + +(define-method get_event_masks_default + (of-object "GstPad") + (c-name "gst_pad_get_event_masks_default") + (return-type "const-GstEventMask*") +) + +(define-method set_link_function + (of-object "GstPad") + (c-name "gst_pad_set_link_function") + (return-type "none") + (parameters + '("GstPadLinkFunction" "link") + ) +) + +(define-method can_link + (of-object "GstPad") + (c-name "gst_pad_can_link") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method can_link_filtered + (of-object "GstPad") + (c-name "gst_pad_can_link_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method set_unlink_function + (of-object "GstPad") + (c-name "gst_pad_set_unlink_function") + (return-type "none") + (parameters + '("GstPadUnlinkFunction" "unlink") + ) +) + +(define-method link + (of-object "GstPad") + (c-name "gst_pad_link") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method link_filtered + (of-object "GstPad") + (c-name "gst_pad_link_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method unlink + (of-object "GstPad") + (c-name "gst_pad_unlink") + (return-type "none") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method is_linked + (of-object "GstPad") + (c-name "gst_pad_is_linked") + (return-type "gboolean") +) + +(define-method get_peer + (of-object "GstPad") + (c-name "gst_pad_get_peer") + (return-type "GstPad*") +) + +(define-method get_negotiated_caps + (of-object "GstPad") + (c-name "gst_pad_get_negotiated_caps") + (return-type "const-GstCaps*") +) + +(define-method is_negotiated + (of-object "GstPad") + (c-name "gst_pad_is_negotiated") + (return-type "gboolean") +) + +(define-method get_caps + (of-object "GstPad") + (c-name "gst_pad_get_caps") + (return-type "GstCaps*") +) + +(define-method get_pad_template_caps + (of-object "GstPad") + (c-name "gst_pad_get_pad_template_caps") + (return-type "const-GstCaps*") +) + +(define-method try_set_caps + (of-object "GstPad") + (c-name "gst_pad_try_set_caps") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method try_set_caps_nonfixed + (of-object "GstPad") + (c-name "gst_pad_try_set_caps_nonfixed") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method check_compatibility + (of-object "GstPad") + (c-name "gst_pad_check_compatibility") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method set_getcaps_function + (of-object "GstPad") + (c-name "gst_pad_set_getcaps_function") + (return-type "none") + (parameters + '("GstPadGetCapsFunction" "getcaps") + ) +) + +(define-method set_fixate_function + (of-object "GstPad") + (c-name "gst_pad_set_fixate_function") + (return-type "none") + (parameters + '("GstPadFixateFunction" "fixate") + ) +) + +(define-method proxy_getcaps + (of-object "GstPad") + (c-name "gst_pad_proxy_getcaps") + (return-type "GstCaps*") +) + +(define-method proxy_pad_link + (of-object "GstPad") + (c-name "gst_pad_proxy_pad_link") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method proxy_fixate + (of-object "GstPad") + (c-name "gst_pad_proxy_fixate") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method proxy_link + (of-object "GstPad") + (c-name "gst_pad_proxy_link") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method set_explicit_caps + (of-object "GstPad") + (c-name "gst_pad_set_explicit_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method use_explicit_caps + (of-object "GstPad") + (c-name "gst_pad_use_explicit_caps") + (return-type "none") +) + +(define-method relink_filtered + (of-object "GstPad") + (c-name "gst_pad_relink_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method perform_negotiate + (of-object "GstPad") + (c-name "gst_pad_perform_negotiate") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method renegotiate + (of-object "GstPad") + (c-name "gst_pad_renegotiate") + (return-type "GstPadLinkReturn") +) + +(define-method unnegotiate + (of-object "GstPad") + (c-name "gst_pad_unnegotiate") + (return-type "none") +) + +(define-method try_relink_filtered + (of-object "GstPad") + (c-name "gst_pad_try_relink_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method get_allowed_caps + (of-object "GstPad") + (c-name "gst_pad_get_allowed_caps") + (return-type "GstCaps*") +) + +(define-method caps_change_notify + (of-object "GstPad") + (c-name "gst_pad_caps_change_notify") + (return-type "none") +) + +(define-method recover_caps_error + (of-object "GstPad") + (c-name "gst_pad_recover_caps_error") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "allowed") + ) +) + +(define-method push + (of-object "GstPad") + (c-name "gst_pad_push") + (return-type "none") + (parameters + '("GstData*" "data") + ) +) + +(define-method pull + (of-object "GstPad") + (c-name "gst_pad_pull") + (return-type "GstData*") +) + +(define-method send_event + (of-object "GstPad") + (c-name "gst_pad_send_event") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-method event_default + (of-object "GstPad") + (c-name "gst_pad_event_default") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-function gst_pad_selectv + (c-name "gst_pad_selectv") + (return-type "GstPad*") + (parameters + '("GList*" "padlist") + ) +) + +(define-method select + (of-object "GstPad") + (c-name "gst_pad_select") + (return-type "GstPad*") + (parameters + ) + (varargs #t) +) + +(define-method select_valist + (of-object "GstPad") + (c-name "gst_pad_select_valist") + (return-type "GstPad*") + (parameters + '("va_list" "varargs") + ) +) + +(define-method set_formats_function + (of-object "GstPad") + (c-name "gst_pad_set_formats_function") + (return-type "none") + (parameters + '("GstPadFormatsFunction" "formats") + ) +) + +(define-method get_formats + (of-object "GstPad") + (c-name "gst_pad_get_formats") + (return-type "const-GstFormat*") +) + +(define-method get_formats_default + (of-object "GstPad") + (c-name "gst_pad_get_formats_default") + (return-type "const-GstFormat*") +) + +(define-method set_convert_function + (of-object "GstPad") + (c-name "gst_pad_set_convert_function") + (return-type "none") + (parameters + '("GstPadConvertFunction" "convert") + ) +) + +(define-method convert + (of-object "GstPad") + (c-name "gst_pad_convert") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method convert_default + (of-object "GstPad") + (c-name "gst_pad_convert_default") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method set_query_function + (of-object "GstPad") + (c-name "gst_pad_set_query_function") + (return-type "none") + (parameters + '("GstPadQueryFunction" "query") + ) +) + +(define-method set_query_type_function + (of-object "GstPad") + (c-name "gst_pad_set_query_type_function") + (return-type "none") + (parameters + '("GstPadQueryTypeFunction" "type_func") + ) +) + +(define-method get_query_types + (of-object "GstPad") + (c-name "gst_pad_get_query_types") + (return-type "const-GstQueryType*") +) + +(define-method get_query_types_default + (of-object "GstPad") + (c-name "gst_pad_get_query_types_default") + (return-type "const-GstQueryType*") +) + +(define-method query + (of-object "GstPad") + (c-name "gst_pad_query") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method query_default + (of-object "GstPad") + (c-name "gst_pad_query_default") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method set_internal_link_function + (of-object "GstPad") + (c-name "gst_pad_set_internal_link_function") + (return-type "none") + (parameters + '("GstPadIntLinkFunction" "intlink") + ) +) + +(define-method get_internal_links + (of-object "GstPad") + (c-name "gst_pad_get_internal_links") + (return-type "GList*") +) + +(define-method get_internal_links_default + (of-object "GstPad") + (c-name "gst_pad_get_internal_links_default") + (return-type "GList*") +) + +(define-method dispatcher + (of-object "GstPad") + (c-name "gst_pad_dispatcher") + (return-type "gboolean") + (parameters + '("GstPadDispatcherFunction" "dispatch") + '("gpointer" "data") + ) +) + +(define-function gst_pad_load_and_link + (c-name "gst_pad_load_and_link") + (return-type "none") + (parameters + '("xmlNodePtr" "self") + '("GstObject*" "parent") + ) +) + +(define-function gst_ghost_pad_new + (c-name "gst_ghost_pad_new") + (is-constructor-of "GstGhostPad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + '("GstPad*" "pad") + ) +) + +(define-function gst_pad_template_get_type + (c-name "gst_pad_template_get_type") + (return-type "GType") +) + +(define-function gst_pad_template_new + (c-name "gst_pad_template_new") + (is-constructor-of "GstPadTemplate") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name_template") + '("GstPadDirection" "direction") + '("GstPadPresence" "presence") + '("GstCaps*" "caps") + ) +) + +(define-method get + (of-object "GstStaticPadTemplate") + (c-name "gst_static_pad_template_get") + (return-type "GstPadTemplate*") +) + +(define-method get_caps + (of-object "GstPadTemplate") + (c-name "gst_pad_template_get_caps") + (return-type "const-GstCaps*") +) + +(define-method get_caps_by_name + (of-object "GstPadTemplate") + (c-name "gst_pad_template_get_caps_by_name") + (return-type "const-GstCaps*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_ghost_pad_save_thyself + (c-name "gst_ghost_pad_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("GstPad*" "pad") + '("xmlNodePtr" "parent") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstparse.h + +(define-function gst_parse_error_quark + (c-name "gst_parse_error_quark") + (return-type "GQuark") +) + +(define-function gst_parse_launch + (c-name "gst_parse_launch") + (return-type "GstElement*") + (parameters + '("const-gchar*" "pipeline_description") + '("GError**" "error") + ) +) + +(define-function gst_parse_launchv + (c-name "gst_parse_launchv") + (return-type "GstElement*") + (parameters + '("const-gchar**" "argv") + '("GError**" "error") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpipeline.h + +(define-function gst_pipeline_get_type + (c-name "gst_pipeline_get_type") + (return-type "GType") +) + +(define-function gst_pipeline_new + (c-name "gst_pipeline_new") + (is-constructor-of "GstPipeline") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpluginfeature.h + +(define-function gst_plugin_feature_get_type + (c-name "gst_plugin_feature_get_type") + (return-type "GType") +) + +(define-method ensure_loaded + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_ensure_loaded") + (return-type "gboolean") +) + +(define-method unload_thyself + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_unload_thyself") + (return-type "none") +) + +(define-method type_name_filter + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_type_name_filter") + (return-type "gboolean") + (parameters + '("GstTypeNameData*" "data") + ) +) + +(define-method set_rank + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_set_rank") + (return-type "none") + (parameters + '("guint" "rank") + ) +) + +(define-method set_name + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_rank + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_get_rank") + (return-type "guint") +) + +(define-method get_name + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_get_name") + (return-type "const-gchar*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstplugin.h + +(define-function gst_plugin_error_quark + (c-name "gst_plugin_error_quark") + (return-type "GQuark") +) + +(define-function gst_plugin_get_type + (c-name "gst_plugin_get_type") + (return-type "GType") +) + +(define-function _gst_plugin_initialize + (c-name "_gst_plugin_initialize") + (return-type "none") +) + +(define-function _gst_plugin_register_static + (c-name "_gst_plugin_register_static") + (return-type "none") + (parameters + '("GstPluginDesc*" "desc") + ) +) + +(define-method get_name + (of-object "GstPlugin") + (c-name "gst_plugin_get_name") + (return-type "const-gchar*") +) + +(define-method get_description + (of-object "GstPlugin") + (c-name "gst_plugin_get_description") + (return-type "const-gchar*") +) + +(define-method get_filename + (of-object "GstPlugin") + (c-name "gst_plugin_get_filename") + (return-type "const-gchar*") +) + +(define-method get_license + (of-object "GstPlugin") + (c-name "gst_plugin_get_license") + (return-type "const-gchar*") +) + +(define-method get_package + (of-object "GstPlugin") + (c-name "gst_plugin_get_package") + (return-type "const-gchar*") +) + +(define-method get_origin + (of-object "GstPlugin") + (c-name "gst_plugin_get_origin") + (return-type "const-gchar*") +) + +(define-method get_module + (of-object "GstPlugin") + (c-name "gst_plugin_get_module") + (return-type "GModule*") +) + +(define-method is_loaded + (of-object "GstPlugin") + (c-name "gst_plugin_is_loaded") + (return-type "gboolean") +) + +(define-method feature_filter + (of-object "GstPlugin") + (c-name "gst_plugin_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_plugin_list_feature_filter + (c-name "gst_plugin_list_feature_filter") + (return-type "GList*") + (parameters + '("GList*" "list") + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method name_filter + (of-object "GstPlugin") + (c-name "gst_plugin_name_filter") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_feature_list + (of-object "GstPlugin") + (c-name "gst_plugin_get_feature_list") + (return-type "GList*") +) + +(define-method find_feature + (of-object "GstPlugin") + (c-name "gst_plugin_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-function gst_plugin_load_file + (c-name "gst_plugin_load_file") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "filename") + '("GError**" "error") + ) +) + +(define-method unload_plugin + (of-object "GstPlugin") + (c-name "gst_plugin_unload_plugin") + (return-type "gboolean") +) + +(define-method add_feature + (of-object "GstPlugin") + (c-name "gst_plugin_add_feature") + (return-type "none") + (parameters + '("GstPluginFeature*" "feature") + ) +) + +(define-function gst_plugin_load + (c-name "gst_plugin_load") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_library_load + (c-name "gst_library_load") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstprobe.h + +(define-function gst_probe_new + (c-name "gst_probe_new") + (is-constructor-of "GstProbe") + (return-type "GstProbe*") + (parameters + '("gboolean" "single_shot") + '("GstProbeCallback" "callback") + '("gpointer" "user_data") + ) +) + +(define-method destroy + (of-object "GstProbe") + (c-name "gst_probe_destroy") + (return-type "none") +) + +(define-method perform + (of-object "GstProbe") + (c-name "gst_probe_perform") + (return-type "gboolean") + (parameters + '("GstData**" "data") + ) +) + +(define-function gst_probe_dispatcher_new + (c-name "gst_probe_dispatcher_new") + (is-constructor-of "GstProbeDispatcher") + (return-type "GstProbeDispatcher*") +) + +(define-method destroy + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_destroy") + (return-type "none") +) + +(define-method init + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_init") + (return-type "none") +) + +(define-method set_active + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method add_probe + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_add_probe") + (return-type "none") + (parameters + '("GstProbe*" "probe") + ) +) + +(define-method remove_probe + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_remove_probe") + (return-type "none") + (parameters + '("GstProbe*" "probe") + ) +) + +(define-method dispatch + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_dispatch") + (return-type "gboolean") + (parameters + '("GstData**" "data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstquery.h + +(define-function _gst_query_type_initialize + (c-name "_gst_query_type_initialize") + (return-type "none") +) + +(define-function gst_query_type_register + (c-name "gst_query_type_register") + (return-type "GstQueryType") + (parameters + '("const-gchar*" "nick") + '("const-gchar*" "description") + ) +) + +(define-function gst_query_type_get_by_nick + (c-name "gst_query_type_get_by_nick") + (return-type "GstQueryType") + (parameters + '("const-gchar*" "nick") + ) +) + +(define-method s_contains + (of-object "GstQueryType") + (c-name "gst_query_types_contains") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + ) +) + +(define-method get_details + (of-object "GstQueryType") + (c-name "gst_query_type_get_details") + (return-type "const-GstQueryTypeDefinition*") +) + +(define-function gst_query_type_get_definitions + (c-name "gst_query_type_get_definitions") + (return-type "const-GList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstqueue.h + +(define-function gst_queue_get_type + (c-name "gst_queue_get_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstregistry.h + +(define-function gst_registry_get_type + (c-name "gst_registry_get_type") + (return-type "GType") +) + +(define-method load + (of-object "GstRegistry") + (c-name "gst_registry_load") + (return-type "gboolean") +) + +(define-method is_loaded + (of-object "GstRegistry") + (c-name "gst_registry_is_loaded") + (return-type "gboolean") +) + +(define-method save + (of-object "GstRegistry") + (c-name "gst_registry_save") + (return-type "gboolean") +) + +(define-method rebuild + (of-object "GstRegistry") + (c-name "gst_registry_rebuild") + (return-type "gboolean") +) + +(define-method unload + (of-object "GstRegistry") + (c-name "gst_registry_unload") + (return-type "gboolean") +) + +(define-method add_path + (of-object "GstRegistry") + (c-name "gst_registry_add_path") + (return-type "none") + (parameters + '("const-gchar*" "path") + ) +) + +(define-method get_path_list + (of-object "GstRegistry") + (c-name "gst_registry_get_path_list") + (return-type "GList*") +) + +(define-method clear_paths + (of-object "GstRegistry") + (c-name "gst_registry_clear_paths") + (return-type "none") +) + +(define-method add_plugin + (of-object "GstRegistry") + (c-name "gst_registry_add_plugin") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method remove_plugin + (of-object "GstRegistry") + (c-name "gst_registry_remove_plugin") + (return-type "none") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method plugin_filter + (of-object "GstRegistry") + (c-name "gst_registry_plugin_filter") + (return-type "GList*") + (parameters + '("GstPluginFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method feature_filter + (of-object "GstRegistry") + (c-name "gst_registry_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method find_plugin + (of-object "GstRegistry") + (c-name "gst_registry_find_plugin") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method find_feature + (of-object "GstRegistry") + (c-name "gst_registry_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-method load_plugin + (of-object "GstRegistry") + (c-name "gst_registry_load_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method unload_plugin + (of-object "GstRegistry") + (c-name "gst_registry_unload_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method update_plugin + (of-object "GstRegistry") + (c-name "gst_registry_update_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstregistrypool.h + +(define-function gst_registry_pool_list + (c-name "gst_registry_pool_list") + (return-type "GList*") +) + +(define-method pool_add + (of-object "GstRegistry") + (c-name "gst_registry_pool_add") + (return-type "none") + (parameters + '("guint" "priority") + ) +) + +(define-method pool_remove + (of-object "GstRegistry") + (c-name "gst_registry_pool_remove") + (return-type "none") +) + +(define-function gst_registry_pool_add_plugin + (c-name "gst_registry_pool_add_plugin") + (return-type "none") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-function gst_registry_pool_load_all + (c-name "gst_registry_pool_load_all") + (return-type "none") +) + +(define-function gst_registry_pool_plugin_filter + (c-name "gst_registry_pool_plugin_filter") + (return-type "GList*") + (parameters + '("GstPluginFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_registry_pool_feature_filter + (c-name "gst_registry_pool_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_registry_pool_plugin_list + (c-name "gst_registry_pool_plugin_list") + (return-type "GList*") +) + +(define-function gst_registry_pool_feature_list + (c-name "gst_registry_pool_feature_list") + (return-type "GList*") + (parameters + '("GType" "type") + ) +) + +(define-function gst_registry_pool_find_plugin + (c-name "gst_registry_pool_find_plugin") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_registry_pool_find_feature + (c-name "gst_registry_pool_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-function gst_registry_pool_get_prefered + (c-name "gst_registry_pool_get_prefered") + (return-type "GstRegistry*") + (parameters + '("GstRegistryFlags" "flags") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstscheduler.h + +(define-function gst_scheduler_get_type + (c-name "gst_scheduler_get_type") + (return-type "GType") +) + +(define-method setup + (of-object "GstScheduler") + (c-name "gst_scheduler_setup") + (return-type "none") +) + +(define-method reset + (of-object "GstScheduler") + (c-name "gst_scheduler_reset") + (return-type "none") +) + +(define-method add_element + (of-object "GstScheduler") + (c-name "gst_scheduler_add_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method remove_element + (of-object "GstScheduler") + (c-name "gst_scheduler_remove_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method add_scheduler + (of-object "GstScheduler") + (c-name "gst_scheduler_add_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched2") + ) +) + +(define-method remove_scheduler + (of-object "GstScheduler") + (c-name "gst_scheduler_remove_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched2") + ) +) + +(define-method state_transition + (of-object "GstScheduler") + (c-name "gst_scheduler_state_transition") + (return-type "GstElementStateReturn") + (parameters + '("GstElement*" "element") + '("gint" "transition") + ) +) + +(define-method scheduling_change + (of-object "GstScheduler") + (c-name "gst_scheduler_scheduling_change") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method lock_element + (of-object "GstScheduler") + (c-name "gst_scheduler_lock_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method unlock_element + (of-object "GstScheduler") + (c-name "gst_scheduler_unlock_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method yield + (of-object "GstScheduler") + (c-name "gst_scheduler_yield") + (return-type "gboolean") + (parameters + '("GstElement*" "element") + ) +) + +(define-method interrupt + (of-object "GstScheduler") + (c-name "gst_scheduler_interrupt") + (return-type "gboolean") + (parameters + '("GstElement*" "element") + ) +) + +(define-method error + (of-object "GstScheduler") + (c-name "gst_scheduler_error") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method pad_link + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_link") + (return-type "none") + (parameters + '("GstPad*" "srcpad") + '("GstPad*" "sinkpad") + ) +) + +(define-method pad_unlink + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_unlink") + (return-type "none") + (parameters + '("GstPad*" "srcpad") + '("GstPad*" "sinkpad") + ) +) + +(define-method pad_select + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_select") + (return-type "GstPad*") + (parameters + '("GList*" "padlist") + ) +) + +(define-method clock_wait + (of-object "GstScheduler") + (c-name "gst_scheduler_clock_wait") + (return-type "GstClockReturn") + (parameters + '("GstElement*" "element") + '("GstClockID" "id") + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method iterate + (of-object "GstScheduler") + (c-name "gst_scheduler_iterate") + (return-type "gboolean") +) + +(define-method use_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_use_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method set_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_set_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method get_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_get_clock") + (return-type "GstClock*") +) + +(define-method auto_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_auto_clock") + (return-type "none") +) + +(define-method show + (of-object "GstScheduler") + (c-name "gst_scheduler_show") + (return-type "none") +) + +(define-function gst_scheduler_factory_get_type + (c-name "gst_scheduler_factory_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_factory_new + (c-name "gst_scheduler_factory_new") + (is-constructor-of "GstSchedulerFactory") + (return-type "GstSchedulerFactory*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "longdesc") + '("GType" "type") + ) +) + +(define-method destroy + (of-object "GstSchedulerFactory") + (c-name "gst_scheduler_factory_destroy") + (return-type "none") +) + +(define-function gst_scheduler_factory_find + (c-name "gst_scheduler_factory_find") + (return-type "GstSchedulerFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method create + (of-object "GstSchedulerFactory") + (c-name "gst_scheduler_factory_create") + (return-type "GstScheduler*") + (parameters + '("GstElement*" "parent") + ) +) + +(define-function gst_scheduler_factory_make + (c-name "gst_scheduler_factory_make") + (return-type "GstScheduler*") + (parameters + '("const-gchar*" "name") + '("GstElement*" "parent") + ) +) + +(define-function gst_scheduler_factory_set_default_name + (c-name "gst_scheduler_factory_set_default_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_scheduler_factory_get_default_name + (c-name "gst_scheduler_factory_get_default_name") + (return-type "const-gchar*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gststructure.h + +(define-function gst_structure_get_type + (c-name "gst_structure_get_type") + (return-type "GType") +) + +(define-function _gst_structure_initialize + (c-name "_gst_structure_initialize") + (return-type "none") +) + +(define-function gst_structure_empty_new + (c-name "gst_structure_empty_new") + (is-constructor-of "GstStructureEmpty") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_structure_id_empty_new + (c-name "gst_structure_id_empty_new") + (is-constructor-of "GstStructureIdEmpty") + (return-type "GstStructure*") + (parameters + '("GQuark" "quark") + ) +) + +(define-function gst_structure_new + (c-name "gst_structure_new") + (is-constructor-of "GstStructure") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "firstfield") + ) + (varargs #t) +) + +(define-function gst_structure_new_valist + (c-name "gst_structure_new_valist") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "firstfield") + '("va_list" "varargs") + ) +) + +(define-method copy + (of-object "GstStructure") + (c-name "gst_structure_copy") + (return-type "GstStructure*") +) + +(define-method free + (of-object "GstStructure") + (c-name "gst_structure_free") + (return-type "none") +) + +(define-method get_name + (of-object "GstStructure") + (c-name "gst_structure_get_name") + (return-type "const-gchar*") +) + +(define-method set_name + (of-object "GstStructure") + (c-name "gst_structure_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method id_set_value + (of-object "GstStructure") + (c-name "gst_structure_id_set_value") + (return-type "none") + (parameters + '("GQuark" "field") + '("const-GValue*" "value") + ) +) + +(define-method set_value + (of-object "GstStructure") + (c-name "gst_structure_set_value") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("const-GValue*" "value") + ) +) + +(define-method set + (of-object "GstStructure") + (c-name "gst_structure_set") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) + (varargs #t) +) + +(define-method set_valist + (of-object "GstStructure") + (c-name "gst_structure_set_valist") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("va_list" "varargs") + ) +) + +(define-method id_get_value + (of-object "GstStructure") + (c-name "gst_structure_id_get_value") + (return-type "const-GValue*") + (parameters + '("GQuark" "field") + ) +) + +(define-method get_value + (of-object "GstStructure") + (c-name "gst_structure_get_value") + (return-type "const-GValue*") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method remove_field + (of-object "GstStructure") + (c-name "gst_structure_remove_field") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method remove_fields + (of-object "GstStructure") + (c-name "gst_structure_remove_fields") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) + (varargs #t) +) + +(define-method remove_fields_valist + (of-object "GstStructure") + (c-name "gst_structure_remove_fields_valist") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("va_list" "varargs") + ) +) + +(define-method remove_all_fields + (of-object "GstStructure") + (c-name "gst_structure_remove_all_fields") + (return-type "none") +) + +(define-method get_field_type + (of-object "GstStructure") + (c-name "gst_structure_get_field_type") + (return-type "GType") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method foreach + (of-object "GstStructure") + (c-name "gst_structure_foreach") + (return-type "gboolean") + (parameters + '("GstStructureForeachFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method n_fields + (of-object "GstStructure") + (c-name "gst_structure_n_fields") + (return-type "gint") +) + +(define-method has_field + (of-object "GstStructure") + (c-name "gst_structure_has_field") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method has_field_typed + (of-object "GstStructure") + (c-name "gst_structure_has_field_typed") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("GType" "type") + ) +) + +(define-method get_boolean + (of-object "GstStructure") + (c-name "gst_structure_get_boolean") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gboolean*" "value") + ) +) + +(define-method get_int + (of-object "GstStructure") + (c-name "gst_structure_get_int") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gint*" "value") + ) +) + +(define-method get_fourcc + (of-object "GstStructure") + (c-name "gst_structure_get_fourcc") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("guint32*" "value") + ) +) + +(define-method get_double + (of-object "GstStructure") + (c-name "gst_structure_get_double") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gdouble*" "value") + ) +) + +(define-method get_string + (of-object "GstStructure") + (c-name "gst_structure_get_string") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method to_string + (of-object "GstStructure") + (c-name "gst_structure_to_string") + (return-type "gchar*") +) + +(define-function gst_structure_from_string + (c-name "gst_structure_from_string") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "string") + '("gchar**" "end") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstsystemclock.h + +(define-function gst_system_clock_get_type + (c-name "gst_system_clock_get_type") + (return-type "GType") +) + +(define-function gst_system_clock_obtain + (c-name "gst_system_clock_obtain") + (return-type "GstClock*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttag.h + +(define-function _gst_tag_initialize + (c-name "_gst_tag_initialize") + (return-type "none") +) + +(define-function gst_tag_list_get_type + (c-name "gst_tag_list_get_type") + (return-type "GType") +) + +(define-function gst_tag_register + (c-name "gst_tag_register") + (return-type "none") + (parameters + '("gchar*" "name") + '("GstTagFlag" "flag") + '("GType" "type") + '("gchar*" "nick") + '("gchar*" "blurb") + '("GstTagMergeFunc" "func") + ) +) + +(define-function gst_tag_merge_use_first + (c-name "gst_tag_merge_use_first") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function gst_tag_merge_strings_with_comma + (c-name "gst_tag_merge_strings_with_comma") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function gst_tag_exists + (c-name "gst_tag_exists") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_type + (c-name "gst_tag_get_type") + (return-type "GType") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_nick + (c-name "gst_tag_get_nick") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_description + (c-name "gst_tag_get_description") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_is_fixed + (c-name "gst_tag_is_fixed") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_list_new + (c-name "gst_tag_list_new") + (is-constructor-of "GstTagList") + (return-type "GstTagList*") +) + +(define-function gst_is_tag_list + (c-name "gst_is_tag_list") + (return-type "gboolean") + (parameters + '("gconstpointer" "p") + ) +) + +(define-method copy + (of-object "GstTagList") + (c-name "gst_tag_list_copy") + (return-type "GstTagList*") +) + +(define-method insert + (of-object "GstTagList") + (c-name "gst_tag_list_insert") + (return-type "none") + (parameters + '("const-GstTagList*" "from") + '("GstTagMergeMode" "mode") + ) +) + +(define-method merge + (of-object "GstTagList") + (c-name "gst_tag_list_merge") + (return-type "GstTagList*") + (parameters + '("const-GstTagList*" "list2") + '("GstTagMergeMode" "mode") + ) +) + +(define-method free + (of-object "GstTagList") + (c-name "gst_tag_list_free") + (return-type "none") +) + +(define-method get_tag_size + (of-object "GstTagList") + (c-name "gst_tag_list_get_tag_size") + (return-type "guint") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-method add + (of-object "GstTagList") + (c-name "gst_tag_list_add") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_values + (of-object "GstTagList") + (c-name "gst_tag_list_add_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_valist + (of-object "GstTagList") + (c-name "gst_tag_list_add_valist") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method add_valist_values + (of-object "GstTagList") + (c-name "gst_tag_list_add_valist_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method remove_tag + (of-object "GstTagList") + (c-name "gst_tag_list_remove_tag") + (return-type "none") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-method foreach + (of-object "GstTagList") + (c-name "gst_tag_list_foreach") + (return-type "none") + (parameters + '("GstTagForeachFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method get_value_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_value_index") + (return-type "const-GValue*") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + ) +) + +(define-function gst_tag_list_copy_value + (c-name "gst_tag_list_copy_value") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GstTagList*" "list") + '("const-gchar*" "tag") + ) +) + +(define-method get_char + (of-object "GstTagList") + (c-name "gst_tag_list_get_char") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gchar*" "value") + ) +) + +(define-method get_char_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_char_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gchar*" "value") + ) +) + +(define-method get_uchar + (of-object "GstTagList") + (c-name "gst_tag_list_get_uchar") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guchar*" "value") + ) +) + +(define-method get_uchar_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uchar_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guchar*" "value") + ) +) + +(define-method get_boolean + (of-object "GstTagList") + (c-name "gst_tag_list_get_boolean") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gboolean*" "value") + ) +) + +(define-method get_boolean_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_boolean_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gboolean*" "value") + ) +) + +(define-method get_int + (of-object "GstTagList") + (c-name "gst_tag_list_get_int") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gint*" "value") + ) +) + +(define-method get_int_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_int_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gint*" "value") + ) +) + +(define-method get_uint + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint*" "value") + ) +) + +(define-method get_uint_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guint*" "value") + ) +) + +(define-method get_long + (of-object "GstTagList") + (c-name "gst_tag_list_get_long") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("glong*" "value") + ) +) + +(define-method get_long_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_long_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("glong*" "value") + ) +) + +(define-method get_ulong + (of-object "GstTagList") + (c-name "gst_tag_list_get_ulong") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gulong*" "value") + ) +) + +(define-method get_ulong_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_ulong_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gulong*" "value") + ) +) + +(define-method get_int64 + (of-object "GstTagList") + (c-name "gst_tag_list_get_int64") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gint64*" "value") + ) +) + +(define-method get_int64_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_int64_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gint64*" "value") + ) +) + +(define-method get_uint64 + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint64") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint64*" "value") + ) +) + +(define-method get_uint64_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint64_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guint64*" "value") + ) +) + +(define-method get_float + (of-object "GstTagList") + (c-name "gst_tag_list_get_float") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gfloat*" "value") + ) +) + +(define-method get_float_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_float_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gfloat*" "value") + ) +) + +(define-method get_double + (of-object "GstTagList") + (c-name "gst_tag_list_get_double") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gdouble*" "value") + ) +) + +(define-method get_double_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_double_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gdouble*" "value") + ) +) + +(define-method get_string + (of-object "GstTagList") + (c-name "gst_tag_list_get_string") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gchar**" "value") + ) +) + +(define-method get_string_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_string_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gchar**" "value") + ) +) + +(define-method get_pointer + (of-object "GstTagList") + (c-name "gst_tag_list_get_pointer") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gpointer*" "value") + ) +) + +(define-method get_pointer_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_pointer_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gpointer*" "value") + ) +) + +(define-function gst_event_new_tag + (c-name "gst_event_new_tag") + (return-type "GstEvent*") + (parameters + '("GstTagList*" "list") + ) +) + +(define-method tag_get_list + (of-object "GstEvent") + (c-name "gst_event_tag_get_list") + (return-type "GstTagList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttaginterface.h + +(define-function gst_tag_setter_get_type + (c-name "gst_tag_setter_get_type") + (return-type "GType") +) + +(define-method merge + (of-object "GstTagSetter") + (c-name "gst_tag_setter_merge") + (return-type "none") + (parameters + '("const-GstTagList*" "list") + '("GstTagMergeMode" "mode") + ) +) + +(define-method add + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_values + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_valist + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_valist") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method add_valist_values + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_valist_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method get_list + (of-object "GstTagSetter") + (c-name "gst_tag_setter_get_list") + (return-type "const-GstTagList*") +) + +(define-method set_merge_mode + (of-object "GstTagSetter") + (c-name "gst_tag_setter_set_merge_mode") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + ) +) + +(define-method get_merge_mode + (of-object "GstTagSetter") + (c-name "gst_tag_setter_get_merge_mode") + (return-type "GstTagMergeMode") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstthread.h + +(define-function gst_thread_get_type + (c-name "gst_thread_get_type") + (return-type "GType") +) + +(define-function gst_thread_new + (c-name "gst_thread_new") + (is-constructor-of "GstThread") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method set_priority + (of-object "GstThread") + (c-name "gst_thread_set_priority") + (return-type "none") + (parameters + '("GThreadPriority" "priority") + ) +) + +(define-function gst_thread_get_current + (c-name "gst_thread_get_current") + (return-type "GstThread*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttrace.h + +(define-function gst_trace_new + (c-name "gst_trace_new") + (is-constructor-of "GstTrace") + (return-type "GstTrace*") + (parameters + '("gchar*" "filename") + '("gint" "size") + ) +) + +(define-method destroy + (of-object "GstTrace") + (c-name "gst_trace_destroy") + (return-type "none") +) + +(define-method flush + (of-object "GstTrace") + (c-name "gst_trace_flush") + (return-type "none") +) + +(define-method text_flush + (of-object "GstTrace") + (c-name "gst_trace_text_flush") + (return-type "none") +) + +(define-method set_default + (of-object "GstTrace") + (c-name "gst_trace_set_default") + (return-type "none") +) + +(define-method _add_entry + (of-object "GstTrace") + (c-name "_gst_trace_add_entry") + (return-type "none") + (parameters + '("guint32" "seq") + '("guint32" "data") + '("gchar*" "msg") + ) +) + +(define-function gst_trace_read_tsc + (c-name "gst_trace_read_tsc") + (return-type "none") + (parameters + '("gint64*" "dst") + ) +) + +(define-function gst_alloc_trace_available + (c-name "gst_alloc_trace_available") + (return-type "gboolean") +) + +(define-function gst_alloc_trace_list + (c-name "gst_alloc_trace_list") + (return-type "const-GList*") +) + +(define-function _gst_alloc_trace_register + (c-name "_gst_alloc_trace_register") + (return-type "GstAllocTrace*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_alloc_trace_live_all + (c-name "gst_alloc_trace_live_all") + (return-type "int") +) + +(define-function gst_alloc_trace_print_all + (c-name "gst_alloc_trace_print_all") + (return-type "none") +) + +(define-function gst_alloc_trace_set_flags_all + (c-name "gst_alloc_trace_set_flags_all") + (return-type "none") + (parameters + '("GstAllocTraceFlags" "flags") + ) +) + +(define-function gst_alloc_trace_get + (c-name "gst_alloc_trace_get") + (return-type "GstAllocTrace*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method print + (of-object "GstAllocTrace") + (c-name "gst_alloc_trace_print") + (return-type "none") +) + +(define-method set_flags + (of-object "GstAllocTrace") + (c-name "gst_alloc_trace_set_flags") + (return-type "none") + (parameters + '("GstAllocTraceFlags" "flags") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttrashstack.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttypefind.h + +(define-method peek + (of-object "GstTypeFind") + (c-name "gst_type_find_peek") + (return-type "guint8*") + (parameters + '("gint64" "offset") + '("guint" "size") + ) +) + +(define-method suggest + (of-object "GstTypeFind") + (c-name "gst_type_find_suggest") + (return-type "none") + (parameters + '("guint" "probability") + '("const-GstCaps*" "caps") + ) +) + +(define-method get_length + (of-object "GstTypeFind") + (c-name "gst_type_find_get_length") + (return-type "guint64") +) + +(define-function gst_type_find_register + (c-name "gst_type_find_register") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + '("const-gchar*" "name") + '("guint" "rank") + '("GstTypeFindFunction" "func") + '("gchar**" "extensions") + '("const-GstCaps*" "possible_caps") + '("gpointer" "data") + ) +) + +(define-function gst_type_find_factory_get_type + (c-name "gst_type_find_factory_get_type") + (return-type "GType") +) + +(define-function gst_type_find_factory_get_list + (c-name "gst_type_find_factory_get_list") + (return-type "GList*") +) + +(define-method get_extensions + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_get_extensions") + (return-type "gchar**") +) + +(define-method get_caps + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_get_caps") + (return-type "const-GstCaps*") +) + +(define-method call_function + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_call_function") + (return-type "none") + (parameters + '("GstTypeFind*" "find") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttypes.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsturi.h + +(define-function gst_uri_protocol_is_valid + (c-name "gst_uri_protocol_is_valid") + (return-type "gboolean") + (parameters + '("const-gchar*" "protocol") + ) +) + +(define-function gst_uri_is_valid + (c-name "gst_uri_is_valid") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_get_protocol + (c-name "gst_uri_get_protocol") + (return-type "gchar*") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_get_location + (c-name "gst_uri_get_location") + (return-type "gchar*") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_construct + (c-name "gst_uri_construct") + (return-type "gchar*") + (parameters + '("const-gchar*" "protocol") + '("const-gchar*" "location") + ) +) + +(define-function gst_element_make_from_uri + (c-name "gst_element_make_from_uri") + (return-type "GstElement*") + (parameters + '("const-GstURIType" "type") + '("const-gchar*" "uri") + '("const-gchar*" "elementname") + ) +) + +(define-function gst_uri_handler_get_type + (c-name "gst_uri_handler_get_type") + (return-type "GType") +) + +(define-method get_uri_type + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_uri_type") + (return-type "guint") +) + +(define-method get_protocols + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_protocols") + (return-type "gchar**") +) + +(define-method get_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_uri") + (return-type "const-gchar*") +) + +(define-method set_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_set_uri") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-method new_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_new_uri") + (return-type "none") + (parameters + '("const-gchar*" "uri") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsturitype.h + +(define-function gst_uri_get_uri_type + (c-name "gst_uri_get_uri_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstutils.h + +(define-function gst_util_set_value_from_string + (c-name "gst_util_set_value_from_string") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-gchar*" "value_str") + ) +) + +(define-function gst_util_set_object_arg + (c-name "gst_util_set_object_arg") + (return-type "none") + (parameters + '("GObject*" "object") + '("const-gchar*" "name") + '("const-gchar*" "value") + ) +) + +(define-function gst_util_dump_mem + (c-name "gst_util_dump_mem") + (return-type "none") + (parameters + '("guchar*" "mem") + '("guint" "size") + ) +) + +(define-function gst_print_pad_caps + (c-name "gst_print_pad_caps") + (return-type "none") + (parameters + '("GString*" "buf") + '("gint" "indent") + '("GstPad*" "pad") + ) +) + +(define-function gst_print_element_args + (c-name "gst_print_element_args") + (return-type "none") + (parameters + '("GString*" "buf") + '("gint" "indent") + '("GstElement*" "element") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstvalue.h + +(define-function gst_value_list_prepend_value + (c-name "gst_value_list_prepend_value") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GValue*" "prepend_value") + ) +) + +(define-function gst_value_list_append_value + (c-name "gst_value_list_append_value") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GValue*" "append_value") + ) +) + +(define-function gst_value_list_get_size + (c-name "gst_value_list_get_size") + (return-type "guint") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_list_get_value + (c-name "gst_value_list_get_value") + (return-type "const-GValue*") + (parameters + '("const-GValue*" "value") + '("guint" "index") + ) +) + +(define-function gst_value_list_concat + (c-name "gst_value_list_concat") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_set_fourcc + (c-name "gst_value_set_fourcc") + (return-type "none") + (parameters + '("GValue*" "value") + '("guint32" "fourcc") + ) +) + +(define-function gst_value_get_fourcc + (c-name "gst_value_get_fourcc") + (return-type "guint32") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_int_range + (c-name "gst_value_set_int_range") + (return-type "none") + (parameters + '("GValue*" "value") + '("int" "start") + '("int" "end") + ) +) + +(define-function gst_value_get_int_range_min + (c-name "gst_value_get_int_range_min") + (return-type "int") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_int_range_max + (c-name "gst_value_get_int_range_max") + (return-type "int") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_double_range + (c-name "gst_value_set_double_range") + (return-type "none") + (parameters + '("GValue*" "value") + '("double" "start") + '("double" "end") + ) +) + +(define-function gst_value_get_double_range_min + (c-name "gst_value_get_double_range_min") + (return-type "double") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_double_range_max + (c-name "gst_value_get_double_range_max") + (return-type "double") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_caps + (c-name "gst_value_get_caps") + (return-type "const-GstCaps*") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_caps + (c-name "gst_value_set_caps") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GstCaps*" "caps") + ) +) + +(define-function gst_value_can_compare + (c-name "gst_value_can_compare") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_compare + (c-name "gst_value_compare") + (return-type "int") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_can_union + (c-name "gst_value_can_union") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_union + (c-name "gst_value_union") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_register_union_func + (c-name "gst_value_register_union_func") + (return-type "none") + (parameters + '("GType" "type1") + '("GType" "type2") + '("GstValueUnionFunc" "func") + ) +) + +(define-function gst_value_can_intersect + (c-name "gst_value_can_intersect") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_intersect + (c-name "gst_value_intersect") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_register_intersect_func + (c-name "gst_value_register_intersect_func") + (return-type "none") + (parameters + '("GType" "type1") + '("GType" "type2") + '("GstValueIntersectFunc" "func") + ) +) + +(define-function gst_value_register + (c-name "gst_value_register") + (return-type "none") + (parameters + '("const-GstValueTable*" "table") + ) +) + +(define-function gst_value_init_and_copy + (c-name "gst_value_init_and_copy") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function _gst_value_initialize + (c-name "_gst_value_initialize") + (return-type "none") +) + +(define-function gst_value_serialize + (c-name "gst_value_serialize") + (return-type "gchar*") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_deserialize + (c-name "gst_value_deserialize") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-gchar*" "src") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstversion.h + +(define-function gst_version + (c-name "gst_version") + (return-type "none") + (parameters + '("guint*" "major") + '("guint*" "minor") + '("guint*" "micro") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstxml.h + +(define-function gst_xml_get_type + (c-name "gst_xml_get_type") + (return-type "GType") +) + +(define-function gst_xml_write + (c-name "gst_xml_write") + (return-type "xmlDocPtr") + (parameters + '("GstElement*" "element") + ) +) + +(define-function gst_xml_write_file + (c-name "gst_xml_write_file") + (return-type "gint") + (parameters + '("GstElement*" "element") + '("FILE*" "out") + ) +) + +(define-function gst_xml_new + (c-name "gst_xml_new") + (is-constructor-of "GstXml") + (return-type "GstXML*") +) + +(define-method parse_doc + (of-object "GstXML") + (c-name "gst_xml_parse_doc") + (return-type "gboolean") + (parameters + '("xmlDocPtr" "doc") + '("const-guchar*" "root") + ) +) + +(define-method parse_file + (of-object "GstXML") + (c-name "gst_xml_parse_file") + (return-type "gboolean") + (parameters + '("const-guchar*" "fname") + '("const-guchar*" "root") + ) +) + +(define-method parse_memory + (of-object "GstXML") + (c-name "gst_xml_parse_memory") + (return-type "gboolean") + (parameters + '("guchar*" "buffer") + '("guint" "size") + '("const-gchar*" "root") + ) +) + +(define-method get_element + (of-object "GstXML") + (c-name "gst_xml_get_element") + (return-type "GstElement*") + (parameters + '("const-guchar*" "name") + ) +) + +(define-method get_topelements + (of-object "GstXML") + (c-name "gst_xml_get_topelements") + (return-type "GList*") +) + +(define-function gst_xml_make_element + (c-name "gst_xml_make_element") + (return-type "GstElement*") + (parameters + '("xmlNodePtr" "cur") + '("GstObject*" "parent") + ) +) + + +;; -*- scheme -*- +;; +;; Boxed types +;; + +(define-boxed Buffer + (in-module "Gst") + (c-name "GstBuffer") + (gtype-id "GST_TYPE_BUFFER") +) + +(define-boxed Caps + (in-module "Gst") + (c-name "GstCaps") + (gtype-id "GST_TYPE_CAPS") +) + +(define-boxed Event + (in-module "Gst") + (c-name "GstEvent") + (gtype-id "GST_TYPE_EVENT") +) + +;; +;; Accelerate common GstBin iterate loop +;; + +(define-function iterate_bin_all + (c-name "iterate_bin_all") + (return-type "none") + (parameters + '("GstBin*" "bin") + ) +) + +(define-function add_iterate_bin + (c-name "add_iterate_bin") + (return-type "guint") + (parameters + '("GstBin*" "bin") + ) +) + +(define-function remove_iterate_bin + (c-name "remove_iterate_bin") + (return-type "none") + (parameters + '("guint" "id") + ) +) + +;; +;; HACK +;; + +(define-method get_data + (of-object "GstBuffer") + (c-name "gst_buffer_get_data") + (return-type "char*") +) + +(define-method set_data + (of-object "GstBuffer") + (c-name "gst_buffer_set_data") + (return-type "none") + (parameters + '("char*" "data") + ) +) + + +;; +;; 0.7 Boxed types +;; + +(define-boxed Structure + (in-module "Gst") + (c-name "GstStructure") + (gtype-id "GST_TYPE_STRUCTURE") +) + +(define-boxed TagList + (in-module "Gst") + (c-name "GstTagList") + (gtype-id "GST_TYPE_TAG_LIST") +) diff --git a/gstreamer/Makefile.am b/gstreamer/Makefile.am index b2c83e8d81..e81eb16654 100644 --- a/gstreamer/Makefile.am +++ b/gstreamer/Makefile.am @@ -42,26 +42,17 @@ _gstmodule_la_SOURCES = \ _gstmodule_la_CFLAGS = $(GST_CFLAGS) -fno-strict-aliasing _gstmodule_la_LIBADD = $(GST_LIBS) _gstmodule_la_LDFLAGS = -module -avoid-version -export-symbols-regex init_gst -nodist__gstmodule_la_SOURCES = gstreamer.c +nodist__gstmodule_la_SOURCES = $(MODULE).c -CLEANFILES = $(MODULE).c h2def.defs $(MODULE).defs $(MODULE).override -EXTRA_DIST = $(GST_OVERRIDES) $(GST_DEFS) $(GST_CODE) arg-types.py +CLEANFILES = $(MODULE).c +EXTRA_DIST = $(MODULE).defs $(GST_OVERRIDES) $(GST_DEFS) $(GST_CODE) arg-types.py GST_EXCLUDE_INCLUDES=\ $(GST_INCLUDEDIR)/gst/gstatomic_impl.h \ $(GST_INCLUDEDIR)/gst/gstcompat.h GST_INCLUDES=$(filter-out $(GST_EXCLUDE_INCLUDES),$(wildcard $(GST_INCLUDEDIR)/gst/*.h)) -gstreamer.override: common.override $(GST_MAJORMINOR).override - cat $+ > $@ - -h2def.defs: $(GST_INCLUDES) - $(PYTHON) $(PYGTK_H2DEF) $(GST_INCLUDES) > $@ - -gstreamer.defs: h2def.defs common.defs $(GST_MAJORMINOR).defs - cat $+ > $@ - -gstreamer.c: $(MODULE).defs arg-types.py $(MODULE).override +gstreamer.c: $(srcdir)/$(MODULE).defs $(srcdir)/arg-types.py $(srcdir)/$(MODULE).override $(PYGTK_CODEGEN) \ --load-types $(srcdir)/arg-types.py \ --override $(srcdir)/$(MODULE).override \ diff --git a/gstreamer/common.defs b/gstreamer/common.defs index 11117cd603..8215a6a158 100644 --- a/gstreamer/common.defs +++ b/gstreamer/common.defs @@ -1,3 +1,4 @@ +;; -*- scheme -*- ;; ;; Boxed types ;; @@ -67,17 +68,4 @@ ) ) -;; -;; Element constructor override; uses a nonexistant make_element -;; which is defined in gstreamer.overrides -;; -(define-function gst_element_factory_make_element - (is-constructor-of "GstElement") - (c-name "gst_element_factory_make_element") - (return-type "GstElement*") - (parameters - '("const-gchar*" "elementname") - '("const-gchar*" "name") - ) -) diff --git a/gstreamer/common.override b/gstreamer/common.override index 8dfb39dd9b..be4491fe2a 100644 --- a/gstreamer/common.override +++ b/gstreamer/common.override @@ -369,3 +369,39 @@ _wrap_gst_version(void) return Py_BuildValue("(iii)", major, minor, micro); } +%% +override gst_bin_add_many args +static PyObject * +_wrap_gst_bin_add_many(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + PyGObject *element; + int i; + int len; + + len = PyList_Size(args); + if (len == 0) + { + PyErr_SetString(PyExc_TypeError, "GstBin.add requires at least one argument"); + return NULL; + } + + + for (i = 0; i < len; i++) + { + element = (PyGObject*)PyList_GetItem(args, i); + if (!pygobject_check(element, &PyGstElement_Type)) + { + PyErr_SetString(PyExc_TypeError, "argument must be a GstElement"); + return NULL; + } + } + + for (i = 0; i < len; i++) + { + element = (PyGObject*)PyList_GetItem(args, i); + gst_bin_add(GST_BIN(self->obj), GST_ELEMENT(element->obj)); + } + + Py_INCREF(Py_None); + return Py_None; +} diff --git a/gstreamer/gst.defs b/gstreamer/gst.defs new file mode 100644 index 0000000000..0dafc62c87 --- /dev/null +++ b/gstreamer/gst.defs @@ -0,0 +1,6968 @@ +;; -*- scheme -*- +; object definitions ... +(define-object Object + (in-module "Gst") + (parent "GObject") + (c-name "GstObject") + (gtype-id "GST_TYPE_OBJECT") +) + +(define-object Index + (in-module "Gst") + (parent "GstObject") + (c-name "GstIndex") + (gtype-id "GST_TYPE_INDEX") +) + +(define-object Element + (in-module "Gst") + (parent "GstObject") + (c-name "GstElement") + (gtype-id "GST_TYPE_ELEMENT") +) + +(define-object Bin + (in-module "Gst") + (parent "GstElement") + (c-name "GstBin") + (gtype-id "GST_TYPE_BIN") +) + +(define-object Clock + (in-module "Gst") + (parent "GstObject") + (c-name "GstClock") + (gtype-id "GST_TYPE_CLOCK") +) + +(define-object Pad + (in-module "Gst") + (parent "GstObject") + (c-name "GstPad") + (gtype-id "GST_TYPE_PAD") +) + +(define-object GhostPad + (in-module "Gst") + (parent "GstPad") + (c-name "GstGhostPad") + (gtype-id "GST_TYPE_GHOST_PAD") +) + +(define-object PadTemplate + (in-module "Gst") + (parent "GstObject") + (c-name "GstPadTemplate") + (gtype-id "GST_TYPE_PAD_TEMPLATE") +) + +(define-object Pipeline + (in-module "Gst") + (parent "GstBin") + (c-name "GstPipeline") + (gtype-id "GST_TYPE_PIPELINE") +) + +(define-object PluginFeature + (in-module "Gst") + (parent "GObject") + (c-name "GstPluginFeature") + (gtype-id "GST_TYPE_PLUGIN_FEATURE") +) + +(define-object IndexFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstIndexFactory") + (gtype-id "GST_TYPE_INDEX_FACTORY") +) + +(define-object ElementFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstElementFactory") + (gtype-id "GST_TYPE_ELEMENT_FACTORY") +) + +(define-object Queue + (in-module "Gst") + (parent "GstElement") + (c-name "GstQueue") + (gtype-id "GST_TYPE_QUEUE") +) + +(define-object RealPad + (in-module "Gst") + (parent "GstPad") + (c-name "GstRealPad") + (gtype-id "GST_TYPE_REAL_PAD") +) + +(define-object Registry + (in-module "Gst") + (parent "GObject") + (c-name "GstRegistry") + (gtype-id "GST_TYPE_REGISTRY") +) + +(define-object Scheduler + (in-module "Gst") + (parent "GstObject") + (c-name "GstScheduler") + (gtype-id "GST_TYPE_SCHEDULER") +) + +(define-object SchedulerFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstSchedulerFactory") + (gtype-id "GST_TYPE_SCHEDULER_FACTORY") +) + +(define-object SystemClock + (in-module "Gst") + (parent "GstClock") + (c-name "GstSystemClock") + (gtype-id "GST_TYPE_SYSTEM_CLOCK") +) + +(define-object Thread + (in-module "Gst") + (parent "GstBin") + (c-name "GstThread") + (gtype-id "GST_TYPE_THREAD") +) + +(define-object TypeFindFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstTypeFindFactory") + (gtype-id "GST_TYPE_TYPE_FIND_FACTORY") +) + +(define-object XML + (in-module "Gst") + (parent "GstObject") + (c-name "GstXML") + (gtype-id "GST_TYPE_XML") +) + +;; Enumerations and flags ... + +(define-enum BinFlags + (in-module "Gst") + (c-name "GstBinFlags") + (gtype-id "GST_TYPE_BIN_FLAGS") + (values + '("flag-manager" "GST_BIN_FLAG_MANAGER") + '("self-schedulable" "GST_BIN_SELF_SCHEDULABLE") + '("flag-prefer-cothreads" "GST_BIN_FLAG_PREFER_COTHREADS") + '("flag-fixed-clock" "GST_BIN_FLAG_FIXED_CLOCK") + '("flag-last" "GST_BIN_FLAG_LAST") + ) +) + +(define-enum BufferFlag + (in-module "Gst") + (c-name "GstBufferFlag") + (gtype-id "GST_TYPE_BUFFER_FLAG") + (values + '("readonly" "GST_BUFFER_READONLY") + '("subbuffer" "GST_BUFFER_SUBBUFFER") + '("original" "GST_BUFFER_ORIGINAL") + '("dontfree" "GST_BUFFER_DONTFREE") + '("key-unit" "GST_BUFFER_KEY_UNIT") + '("dontkeep" "GST_BUFFER_DONTKEEP") + '("flag-last" "GST_BUFFER_FLAG_LAST") + ) +) + +(define-enum ClockEntryStatus + (in-module "Gst") + (c-name "GstClockEntryStatus") + (gtype-id "GST_TYPE_CLOCK_ENTRY_STATUS") + (values + '("ok" "GST_CLOCK_ENTRY_OK") + '("early" "GST_CLOCK_ENTRY_EARLY") + '("restart" "GST_CLOCK_ENTRY_RESTART") + ) +) + +(define-enum ClockEntryType + (in-module "Gst") + (c-name "GstClockEntryType") + (gtype-id "GST_TYPE_CLOCK_ENTRY_TYPE") + (values + '("single" "GST_CLOCK_ENTRY_SINGLE") + '("periodic" "GST_CLOCK_ENTRY_PERIODIC") + ) +) + +(define-enum ClockReturn + (in-module "Gst") + (c-name "GstClockReturn") + (gtype-id "GST_TYPE_CLOCK_RETURN") + (values + '("stopped" "GST_CLOCK_STOPPED") + '("timeout" "GST_CLOCK_TIMEOUT") + '("early" "GST_CLOCK_EARLY") + '("error" "GST_CLOCK_ERROR") + '("unsupported" "GST_CLOCK_UNSUPPORTED") + ) +) + +(define-flags ClockFlags + (in-module "Gst") + (c-name "GstClockFlags") + (gtype-id "GST_TYPE_CLOCK_FLAGS") + (values + '("do-single-sync" "GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC") + '("do-single-async" "GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC") + '("do-periodic-sync" "GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC") + '("do-periodic-async" "GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC") + '("set-resolution" "GST_CLOCK_FLAG_CAN_SET_RESOLUTION") + '("set-speed" "GST_CLOCK_FLAG_CAN_SET_SPEED") + ) +) + +(define-flags CPUFlags + (in-module "Gst") + (c-name "GstCPUFlags") + (gtype-id "GST_TYPE_CPU_FLAGS") + (values + '("mmx" "GST_CPU_FLAG_MMX") + '("sse" "GST_CPU_FLAG_SSE") + '("mmxext" "GST_CPU_FLAG_MMXEXT") + '("3dnow" "GST_CPU_FLAG_3DNOW") + ) +) + +(define-enum DataFlags + (in-module "Gst") + (c-name "GstDataFlags") + (gtype-id "GST_TYPE_DATA_FLAGS") + (values + '("readonly" "GST_DATA_READONLY") + '("flag-last" "GST_DATA_FLAG_LAST") + ) +) + +(define-enum ElementFlags + (in-module "Gst") + (c-name "GstElementFlags") + (gtype-id "GST_TYPE_ELEMENT_FLAGS") + (values + '("complex" "GST_ELEMENT_COMPLEX") + '("decoupled" "GST_ELEMENT_DECOUPLED") + '("thread-suggested" "GST_ELEMENT_THREAD_SUGGESTED") + '("infinite-loop" "GST_ELEMENT_INFINITE_LOOP") + '("new-loopfunc" "GST_ELEMENT_NEW_LOOPFUNC") + '("event-aware" "GST_ELEMENT_EVENT_AWARE") + '("use-threadsafe-properties" "GST_ELEMENT_USE_THREADSAFE_PROPERTIES") + '("scheduler-private1" "GST_ELEMENT_SCHEDULER_PRIVATE1") + '("scheduler-private2" "GST_ELEMENT_SCHEDULER_PRIVATE2") + '("locked-state" "GST_ELEMENT_LOCKED_STATE") + '("in-error" "GST_ELEMENT_IN_ERROR") + '("flag-last" "GST_ELEMENT_FLAG_LAST") + ) +) + +(define-enum CoreError + (in-module "Gst") + (c-name "GstCoreError") + (gtype-id "GST_TYPE_CORE_ERROR") + (values + '("failed" "GST_CORE_ERROR_FAILED") + '("too-lazy" "GST_CORE_ERROR_TOO_LAZY") + '("not-implemented" "GST_CORE_ERROR_NOT_IMPLEMENTED") + '("state-change" "GST_CORE_ERROR_STATE_CHANGE") + '("pad" "GST_CORE_ERROR_PAD") + '("thread" "GST_CORE_ERROR_THREAD") + '("scheduler" "GST_CORE_ERROR_SCHEDULER") + '("negotiation" "GST_CORE_ERROR_NEGOTIATION") + '("event" "GST_CORE_ERROR_EVENT") + '("seek" "GST_CORE_ERROR_SEEK") + '("caps" "GST_CORE_ERROR_CAPS") + '("tag" "GST_CORE_ERROR_TAG") + '("num-errors" "GST_CORE_ERROR_NUM_ERRORS") + ) +) + +(define-enum LibraryError + (in-module "Gst") + (c-name "GstLibraryError") + (gtype-id "GST_TYPE_LIBRARY_ERROR") + (values + '("failed" "GST_LIBRARY_ERROR_FAILED") + '("too-lazy" "GST_LIBRARY_ERROR_TOO_LAZY") + '("init" "GST_LIBRARY_ERROR_INIT") + '("shutdown" "GST_LIBRARY_ERROR_SHUTDOWN") + '("settings" "GST_LIBRARY_ERROR_SETTINGS") + '("encode" "GST_LIBRARY_ERROR_ENCODE") + '("num-errors" "GST_LIBRARY_ERROR_NUM_ERRORS") + ) +) + +(define-enum ResourceError + (in-module "Gst") + (c-name "GstResourceError") + (gtype-id "GST_TYPE_RESOURCE_ERROR") + (values + '("failed" "GST_RESOURCE_ERROR_FAILED") + '("too-lazy" "GST_RESOURCE_ERROR_TOO_LAZY") + '("not-found" "GST_RESOURCE_ERROR_NOT_FOUND") + '("busy" "GST_RESOURCE_ERROR_BUSY") + '("open-read" "GST_RESOURCE_ERROR_OPEN_READ") + '("open-write" "GST_RESOURCE_ERROR_OPEN_WRITE") + '("open-read-write" "GST_RESOURCE_ERROR_OPEN_READ_WRITE") + '("close" "GST_RESOURCE_ERROR_CLOSE") + '("read" "GST_RESOURCE_ERROR_READ") + '("write" "GST_RESOURCE_ERROR_WRITE") + '("seek" "GST_RESOURCE_ERROR_SEEK") + '("sync" "GST_RESOURCE_ERROR_SYNC") + '("settings" "GST_RESOURCE_ERROR_SETTINGS") + '("num-errors" "GST_RESOURCE_ERROR_NUM_ERRORS") + ) +) + +(define-enum StreamError + (in-module "Gst") + (c-name "GstStreamError") + (gtype-id "GST_TYPE_STREAM_ERROR") + (values + '("failed" "GST_STREAM_ERROR_FAILED") + '("too-lazy" "GST_STREAM_ERROR_TOO_LAZY") + '("not-implemented" "GST_STREAM_ERROR_NOT_IMPLEMENTED") + '("type-not-found" "GST_STREAM_ERROR_TYPE_NOT_FOUND") + '("wrong-type" "GST_STREAM_ERROR_WRONG_TYPE") + '("codec-not-found" "GST_STREAM_ERROR_CODEC_NOT_FOUND") + '("decode" "GST_STREAM_ERROR_DECODE") + '("encode" "GST_STREAM_ERROR_ENCODE") + '("demux" "GST_STREAM_ERROR_DEMUX") + '("mux" "GST_STREAM_ERROR_MUX") + '("format" "GST_STREAM_ERROR_FORMAT") + '("num-errors" "GST_STREAM_ERROR_NUM_ERRORS") + ) +) + +(define-enum EventType + (in-module "Gst") + (c-name "GstEventType") + (gtype-id "GST_TYPE_EVENT_TYPE") + (values + '("unknown" "GST_EVENT_UNKNOWN") + '("eos" "GST_EVENT_EOS") + '("flush" "GST_EVENT_FLUSH") + '("empty" "GST_EVENT_EMPTY") + '("discontinuous" "GST_EVENT_DISCONTINUOUS") + '("qos" "GST_EVENT_QOS") + '("seek" "GST_EVENT_SEEK") + '("seek-segment" "GST_EVENT_SEEK_SEGMENT") + '("segment-done" "GST_EVENT_SEGMENT_DONE") + '("size" "GST_EVENT_SIZE") + '("rate" "GST_EVENT_RATE") + '("filler" "GST_EVENT_FILLER") + '("ts-offset" "GST_EVENT_TS_OFFSET") + '("interrupt" "GST_EVENT_INTERRUPT") + '("navigation" "GST_EVENT_NAVIGATION") + '("tag" "GST_EVENT_TAG") + ) +) + +(define-flags EventFlag + (in-module "Gst") + (c-name "GstEventFlag") + (gtype-id "GST_TYPE_EVENT_FLAG") + (values + '("event-flag-none" "GST_EVENT_FLAG_NONE") + '("rate-flag-negative" "GST_RATE_FLAG_NEGATIVE") + ) +) + +(define-flags SeekType + (in-module "Gst") + (c-name "GstSeekType") + (gtype-id "GST_TYPE_SEEK_TYPE") + (values + '("method-cur" "GST_SEEK_METHOD_CUR") + '("method-set" "GST_SEEK_METHOD_SET") + '("method-end" "GST_SEEK_METHOD_END") + '("flag-flush" "GST_SEEK_FLAG_FLUSH") + '("flag-accurate" "GST_SEEK_FLAG_ACCURATE") + '("flag-key-unit" "GST_SEEK_FLAG_KEY_UNIT") + '("flag-segment-loop" "GST_SEEK_FLAG_SEGMENT_LOOP") + ) +) + +(define-enum SeekAccuracy + (in-module "Gst") + (c-name "GstSeekAccuracy") + (gtype-id "GST_TYPE_SEEK_ACCURACY") + (values + '("certain" "GST_SEEK_CERTAIN") + '("fuzzy" "GST_SEEK_FUZZY") + ) +) + +(define-enum Format + (in-module "Gst") + (c-name "GstFormat") + (gtype-id "GST_TYPE_FORMAT") + (values + '("undefined" "GST_FORMAT_UNDEFINED") + '("default" "GST_FORMAT_DEFAULT") + '("bytes" "GST_FORMAT_BYTES") + '("time" "GST_FORMAT_TIME") + '("buffers" "GST_FORMAT_BUFFERS") + '("percent" "GST_FORMAT_PERCENT") + ) +) + +(define-enum IndexCertainty + (in-module "Gst") + (c-name "GstIndexCertainty") + (gtype-id "GST_TYPE_INDEX_CERTAINTY") + (values + '("unknown" "GST_INDEX_UNKNOWN") + '("certain" "GST_INDEX_CERTAIN") + '("fuzzy" "GST_INDEX_FUZZY") + ) +) + +(define-enum IndexEntryType + (in-module "Gst") + (c-name "GstIndexEntryType") + (gtype-id "GST_TYPE_INDEX_ENTRY_TYPE") + (values + '("id" "GST_INDEX_ENTRY_ID") + '("association" "GST_INDEX_ENTRY_ASSOCIATION") + '("object" "GST_INDEX_ENTRY_OBJECT") + '("format" "GST_INDEX_ENTRY_FORMAT") + ) +) + +(define-enum IndexLookupMethod + (in-module "Gst") + (c-name "GstIndexLookupMethod") + (gtype-id "GST_TYPE_INDEX_LOOKUP_METHOD") + (values + '("exact" "GST_INDEX_LOOKUP_EXACT") + '("before" "GST_INDEX_LOOKUP_BEFORE") + '("after" "GST_INDEX_LOOKUP_AFTER") + ) +) + +(define-flags AssocFlags + (in-module "Gst") + (c-name "GstAssocFlags") + (gtype-id "GST_TYPE_ASSOC_FLAGS") + (values + '("none" "GST_ASSOCIATION_FLAG_NONE") + '("key-unit" "GST_ASSOCIATION_FLAG_KEY_UNIT") + '("last" "GST_ASSOCIATION_FLAG_LAST") + ) +) + +(define-enum IndexResolverMethod + (in-module "Gst") + (c-name "GstIndexResolverMethod") + (gtype-id "GST_TYPE_INDEX_RESOLVER_METHOD") + (values + '("custom" "GST_INDEX_RESOLVER_CUSTOM") + '("gtype" "GST_INDEX_RESOLVER_GTYPE") + '("path" "GST_INDEX_RESOLVER_PATH") + ) +) + +(define-enum IndexFlags + (in-module "Gst") + (c-name "GstIndexFlags") + (gtype-id "GST_TYPE_INDEX_FLAGS") + (values + '("writable" "GST_INDEX_WRITABLE") + '("readable" "GST_INDEX_READABLE") + '("flag-last" "GST_INDEX_FLAG_LAST") + ) +) + +(define-enum DebugLevel + (in-module "Gst") + (c-name "GstDebugLevel") + (gtype-id "GST_TYPE_DEBUG_LEVEL") + (values + '("none" "GST_LEVEL_NONE") + '("error" "GST_LEVEL_ERROR") + '("warning" "GST_LEVEL_WARNING") + '("info" "GST_LEVEL_INFO") + '("debug" "GST_LEVEL_DEBUG") + '("log" "GST_LEVEL_LOG") + '("count" "GST_LEVEL_COUNT") + ) +) + +(define-enum DebugColorFlags + (in-module "Gst") + (c-name "GstDebugColorFlags") + (gtype-id "GST_TYPE_DEBUG_COLOR_FLAGS") + (values + '("fg-black" "GST_DEBUG_FG_BLACK") + '("fg-red" "GST_DEBUG_FG_RED") + '("fg-green" "GST_DEBUG_FG_GREEN") + '("fg-yellow" "GST_DEBUG_FG_YELLOW") + '("fg-blue" "GST_DEBUG_FG_BLUE") + '("fg-magenta" "GST_DEBUG_FG_MAGENTA") + '("fg-cyan" "GST_DEBUG_FG_CYAN") + '("fg-white" "GST_DEBUG_FG_WHITE") + '("bg-black" "GST_DEBUG_BG_BLACK") + '("bg-red" "GST_DEBUG_BG_RED") + '("bg-green" "GST_DEBUG_BG_GREEN") + '("bg-yellow" "GST_DEBUG_BG_YELLOW") + '("bg-blue" "GST_DEBUG_BG_BLUE") + '("bg-magenta" "GST_DEBUG_BG_MAGENTA") + '("bg-cyan" "GST_DEBUG_BG_CYAN") + '("bg-white" "GST_DEBUG_BG_WHITE") + '("bold" "GST_DEBUG_BOLD") + '("underline" "GST_DEBUG_UNDERLINE") + ) +) + +(define-enum ObjectFlags + (in-module "Gst") + (c-name "GstObjectFlags") + (gtype-id "GST_TYPE_OBJECT_FLAGS") + (values + '("destroyed" "GST_DESTROYED") + '("floating" "GST_FLOATING") + '("object-flag-last" "GST_OBJECT_FLAG_LAST") + ) +) + +(define-enum PadLinkReturn + (in-module "Gst") + (c-name "GstPadLinkReturn") + (gtype-id "GST_TYPE_PAD_LINK_RETURN") + (values + '("refused" "GST_PAD_LINK_REFUSED") + '("delayed" "GST_PAD_LINK_DELAYED") + '("ok" "GST_PAD_LINK_OK") + '("done" "GST_PAD_LINK_DONE") + ) +) + +(define-enum PadDirection + (in-module "Gst") + (c-name "GstPadDirection") + (gtype-id "GST_TYPE_PAD_DIRECTION") + (values + '("unknown" "GST_PAD_UNKNOWN") + '("src" "GST_PAD_SRC") + '("sink" "GST_PAD_SINK") + ) +) + +(define-enum PadFlags + (in-module "Gst") + (c-name "GstPadFlags") + (gtype-id "GST_TYPE_PAD_FLAGS") + (values + '("disabled" "GST_PAD_DISABLED") + '("negotiating" "GST_PAD_NEGOTIATING") + '("flag-last" "GST_PAD_FLAG_LAST") + ) +) + +(define-enum PadPresence + (in-module "Gst") + (c-name "GstPadPresence") + (gtype-id "GST_TYPE_PAD_PRESENCE") + (values + '("always" "GST_PAD_ALWAYS") + '("sometimes" "GST_PAD_SOMETIMES") + '("request" "GST_PAD_REQUEST") + ) +) + +(define-enum PadTemplateFlags + (in-module "Gst") + (c-name "GstPadTemplateFlags") + (gtype-id "GST_TYPE_PAD_TEMPLATE_FLAGS") + (values + '("ixed" "GST_PAD_TEMPLATE_FIXED") + '("lag-last" "GST_PAD_TEMPLATE_FLAG_LAST") + ) +) + +(define-enum ParseError + (in-module "Gst") + (c-name "GstParseError") + (gtype-id "GST_TYPE_PARSE_ERROR") + (values + '("syntax" "GST_PARSE_ERROR_SYNTAX") + '("no-such-element" "GST_PARSE_ERROR_NO_SUCH_ELEMENT") + '("no-such-property" "GST_PARSE_ERROR_NO_SUCH_PROPERTY") + '("link" "GST_PARSE_ERROR_LINK") + '("could-not-set-property" "GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY") + '("empty-bin" "GST_PARSE_ERROR_EMPTY_BIN") + '("empty" "GST_PARSE_ERROR_EMPTY") + ) +) + +(define-enum PluginError + (in-module "Gst") + (c-name "GstPluginError") + (gtype-id "GST_TYPE_PLUGIN_ERROR") + (values + '("module" "GST_PLUGIN_ERROR_MODULE") + '("dependencies" "GST_PLUGIN_ERROR_DEPENDENCIES") + '("name-mismatch" "GST_PLUGIN_ERROR_NAME_MISMATCH") + ) +) + +(define-enum QueryType + (in-module "Gst") + (c-name "GstQueryType") + (gtype-id "GST_TYPE_QUERY_TYPE") + (values + '("none" "GST_QUERY_NONE") + '("total" "GST_QUERY_TOTAL") + '("position" "GST_QUERY_POSITION") + '("latency" "GST_QUERY_LATENCY") + '("jitter" "GST_QUERY_JITTER") + '("start" "GST_QUERY_START") + '("segment-end" "GST_QUERY_SEGMENT_END") + '("rate" "GST_QUERY_RATE") + ) +) + +(define-flags RegistryReturn + (in-module "Gst") + (c-name "GstRegistryReturn") + (gtype-id "GST_TYPE_REGISTRY_RETURN") + (values + '("ok" "GST_REGISTRY_OK") + '("load-error" "GST_REGISTRY_LOAD_ERROR") + '("save-error" "GST_REGISTRY_SAVE_ERROR") + '("plugin-load-error" "GST_REGISTRY_PLUGIN_LOAD_ERROR") + '("plugin-signature-error" "GST_REGISTRY_PLUGIN_SIGNATURE_ERROR") + ) +) + +(define-flags RegistryFlags + (in-module "Gst") + (c-name "GstRegistryFlags") + (gtype-id "GST_TYPE_REGISTRY_FLAGS") + (values + '("readable" "GST_REGISTRY_READABLE") + '("writable" "GST_REGISTRY_WRITABLE") + '("exists" "GST_REGISTRY_EXISTS") + '("remote" "GST_REGISTRY_REMOTE") + '("delayed-loading" "GST_REGISTRY_DELAYED_LOADING") + ) +) + +(define-enum SchedulerFlags + (in-module "Gst") + (c-name "GstSchedulerFlags") + (gtype-id "GST_TYPE_SCHEDULER_FLAGS") + (values + '("fixed-clock" "GST_SCHEDULER_FLAG_FIXED_CLOCK") + '("last" "GST_SCHEDULER_FLAG_LAST") + ) +) + +(define-enum SchedulerState + (in-module "Gst") + (c-name "GstSchedulerState") + (gtype-id "GST_TYPE_SCHEDULER_STATE") + (values + '("none" "GST_SCHEDULER_STATE_NONE") + '("running" "GST_SCHEDULER_STATE_RUNNING") + '("stopped" "GST_SCHEDULER_STATE_STOPPED") + '("error" "GST_SCHEDULER_STATE_ERROR") + ) +) + +(define-enum TagMergeMode + (in-module "Gst") + (c-name "GstTagMergeMode") + (gtype-id "GST_TYPE_TAG_MERGE_MODE") + (values + '("undefined" "GST_TAG_MERGE_UNDEFINED") + '("replace-all" "GST_TAG_MERGE_REPLACE_ALL") + '("replace" "GST_TAG_MERGE_REPLACE") + '("append" "GST_TAG_MERGE_APPEND") + '("prepend" "GST_TAG_MERGE_PREPEND") + '("keep" "GST_TAG_MERGE_KEEP") + '("keep-all" "GST_TAG_MERGE_KEEP_ALL") + '("count" "GST_TAG_MERGE_COUNT") + ) +) + +(define-enum TagFlag + (in-module "Gst") + (c-name "GstTagFlag") + (gtype-id "GST_TYPE_TAG_FLAG") + (values + '("undefined" "GST_TAG_FLAG_UNDEFINED") + '("meta" "GST_TAG_FLAG_META") + '("encoded" "GST_TAG_FLAG_ENCODED") + '("decoded" "GST_TAG_FLAG_DECODED") + '("count" "GST_TAG_FLAG_COUNT") + ) +) + +(define-enum ThreadState + (in-module "Gst") + (c-name "GstThreadState") + (gtype-id "GST_TYPE_THREAD_STATE") + (values + '("state-spinning" "GST_THREAD_STATE_SPINNING") + '("state-reaping" "GST_THREAD_STATE_REAPING") + '("mutex-locked" "GST_THREAD_MUTEX_LOCKED") + '("flag-last" "GST_THREAD_FLAG_LAST") + ) +) + +(define-flags AllocTraceFlags + (in-module "Gst") + (c-name "GstAllocTraceFlags") + (gtype-id "GST_TYPE_ALLOC_TRACE_FLAGS") + (values + '("live" "GST_ALLOC_TRACE_LIVE") + '("mem-live" "GST_ALLOC_TRACE_MEM_LIVE") + ) +) + +(define-enum TypeFindProbability + (in-module "Gst") + (c-name "GstTypeFindProbability") + (gtype-id "GST_TYPE_TYPE_FIND_PROBABILITY") + (values + '("minimum" "GST_TYPE_FIND_MINIMUM") + '("possible" "GST_TYPE_FIND_POSSIBLE") + '("likely" "GST_TYPE_FIND_LIKELY") + '("nearly-certain" "GST_TYPE_FIND_NEARLY_CERTAIN") + '("maximum" "GST_TYPE_FIND_MAXIMUM") + ) +) + +(define-flags ElementState + (in-module "Gst") + (c-name "GstElementState") + (gtype-id "GST_TYPE_ELEMENT_STATE") + (values + '("void-pending" "GST_STATE_VOID_PENDING") + '("null" "GST_STATE_NULL") + '("ready" "GST_STATE_READY") + '("paused" "GST_STATE_PAUSED") + '("playing" "GST_STATE_PLAYING") + ) +) + +(define-enum ElementStateReturn + (in-module "Gst") + (c-name "GstElementStateReturn") + (gtype-id "GST_TYPE_ELEMENT_STATE_RETURN") + (values + '("failure" "GST_STATE_FAILURE") + '("success" "GST_STATE_SUCCESS") + '("async" "GST_STATE_ASYNC") + ) +) + +(define-enum Result + (in-module "Gst") + (c-name "GstResult") + (gtype-id "GST_TYPE_RESULT") + (values + '("ok" "GST_RESULT_OK") + '("nok" "GST_RESULT_NOK") + '("not-impl" "GST_RESULT_NOT_IMPL") + ) +) + +(define-enum URIType + (in-module "Gst") + (c-name "GstURIType") + (gtype-id "GST_TYPE_URI_TYPE") + (values + '("unknown" "GST_URI_UNKNOWN") + '("sink" "GST_URI_SINK") + '("src" "GST_URI_SRC") + ) +) + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstatomic.h + +(define-method init + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_init") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method destroy + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_destroy") + (return-type "none") +) + +(define-method set + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_set") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method read + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_read") + (return-type "gint") +) + +(define-method add + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_add") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method inc + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_inc") + (return-type "none") +) + +(define-method dec_and_test + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_dec_and_test") + (return-type "gboolean") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstbin.h + +(define-function gst_bin_get_type + (c-name "gst_bin_get_type") + (return-type "GType") +) + +(define-function gst_bin_new + (c-name "gst_bin_new") + (is-constructor-of "GstBin") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method add + (of-object "GstBin") + (c-name "gst_bin_add") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method add_many + (of-object "GstBin") + (c-name "gst_bin_add_many") + (return-type "none") + (parameters + '("GstElement*" "element_1") + ) + (varargs #t) +) + +(define-method remove + (of-object "GstBin") + (c-name "gst_bin_remove") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method remove_many + (of-object "GstBin") + (c-name "gst_bin_remove_many") + (return-type "none") + (parameters + '("GstElement*" "element_1") + ) + (varargs #t) +) + +(define-method get_by_name + (of-object "GstBin") + (c-name "gst_bin_get_by_name") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_by_name_recurse_up + (of-object "GstBin") + (c-name "gst_bin_get_by_name_recurse_up") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_list + (of-object "GstBin") + (c-name "gst_bin_get_list") + (return-type "const-GList*") +) + +(define-method get_by_interface + (of-object "GstBin") + (c-name "gst_bin_get_by_interface") + (return-type "GstElement*") + (parameters + '("GType" "interface") + ) +) + +(define-method get_all_by_interface + (of-object "GstBin") + (c-name "gst_bin_get_all_by_interface") + (return-type "GList*") + (parameters + '("GType" "interface") + ) +) + +(define-method iterate + (of-object "GstBin") + (c-name "gst_bin_iterate") + (return-type "gboolean") +) + +(define-method use_clock + (of-object "GstBin") + (c-name "gst_bin_use_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method get_clock + (of-object "GstBin") + (c-name "gst_bin_get_clock") + (return-type "GstClock*") +) + +(define-method auto_clock + (of-object "GstBin") + (c-name "gst_bin_auto_clock") + (return-type "none") +) + +(define-method sync_children_state + (of-object "GstBin") + (c-name "gst_bin_sync_children_state") + (return-type "GstElementStateReturn") +) + +(define-method child_state_change + (of-object "GstBin") + (c-name "gst_bin_child_state_change") + (return-type "none") + (parameters + '("GstElementState" "oldstate") + '("GstElementState" "newstate") + '("GstElement*" "child") + ) +) + +(define-method set_pre_iterate_function + (of-object "GstBin") + (c-name "gst_bin_set_pre_iterate_function") + (return-type "none") + (parameters + '("GstBinPrePostIterateFunction" "func") + '("gpointer" "user_data") + ) +) + +(define-method set_post_iterate_function + (of-object "GstBin") + (c-name "gst_bin_set_post_iterate_function") + (return-type "none") + (parameters + '("GstBinPrePostIterateFunction" "func") + '("gpointer" "user_data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstbuffer.h + +(define-function gst_buffer_get_type + (c-name "gst_buffer_get_type") + (return-type "GType") +) + +(define-function gst_buffer_new + (c-name "gst_buffer_new") + (is-constructor-of "GstBuffer") + (return-type "GstBuffer*") +) + +(define-function gst_buffer_new_and_alloc + (c-name "gst_buffer_new_and_alloc") + (return-type "GstBuffer*") + (parameters + '("guint" "size") + ) +) + +(define-method stamp + (of-object "GstBuffer") + (c-name "gst_buffer_stamp") + (return-type "none") + (parameters + '("const-GstBuffer*" "src") + ) +) + +(define-method create_sub + (of-object "GstBuffer") + (c-name "gst_buffer_create_sub") + (return-type "GstBuffer*") + (parameters + '("guint" "offset") + '("guint" "size") + ) +) + +(define-method merge + (of-object "GstBuffer") + (c-name "gst_buffer_merge") + (return-type "GstBuffer*") + (parameters + '("GstBuffer*" "buf2") + ) +) + +(define-method is_span_fast + (of-object "GstBuffer") + (c-name "gst_buffer_is_span_fast") + (return-type "gboolean") + (parameters + '("GstBuffer*" "buf2") + ) +) + +(define-method span + (of-object "GstBuffer") + (c-name "gst_buffer_span") + (return-type "GstBuffer*") + (parameters + '("guint32" "offset") + '("GstBuffer*" "buf2") + '("guint32" "len") + ) +) + +(define-function _gst_buffer_initialize + (c-name "_gst_buffer_initialize") + (return-type "none") +) + +(define-method default_free + (of-object "GstBuffer") + (c-name "gst_buffer_default_free") + (return-type "none") +) + +(define-method default_copy + (of-object "GstBuffer") + (c-name "gst_buffer_default_copy") + (return-type "GstBuffer*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstcaps.h + +(define-function _gst_caps_initialize + (c-name "_gst_caps_initialize") + (return-type "none") +) + +(define-function gst_caps_get_type + (c-name "gst_caps_get_type") + (return-type "GType") +) + +(define-function gst_caps_new_empty + (c-name "gst_caps_new_empty") + (return-type "GstCaps*") +) + +(define-function gst_caps_new_any + (c-name "gst_caps_new_any") + (return-type "GstCaps*") +) + +(define-function gst_caps_new_simple + (c-name "gst_caps_new_simple") + (return-type "GstCaps*") + (parameters + '("const-char*" "media_type") + '("const-char*" "fieldname") + ) + (varargs #t) +) + +(define-function gst_caps_new_full + (c-name "gst_caps_new_full") + (return-type "GstCaps*") + (parameters + '("GstStructure*" "struct1") + ) + (varargs #t) +) + +(define-function gst_caps_new_full_valist + (c-name "gst_caps_new_full_valist") + (return-type "GstCaps*") + (parameters + '("GstStructure*" "structure") + '("va_list" "var_args") + ) +) + +(define-method copy + (of-object "GstCaps") + (c-name "gst_caps_copy") + (return-type "GstCaps*") +) + +(define-method free + (of-object "GstCaps") + (c-name "gst_caps_free") + (return-type "none") +) + +(define-method get + (of-object "GstStaticCaps") + (c-name "gst_static_caps_get") + (return-type "const-GstCaps*") +) + +(define-method append + (of-object "GstCaps") + (c-name "gst_caps_append") + (return-type "none") + (parameters + '("GstCaps*" "caps2") + ) +) + +(define-method append_structure + (of-object "GstCaps") + (c-name "gst_caps_append_structure") + (return-type "none") + (parameters + '("GstStructure*" "structure") + ) +) + +(define-method split_one + (of-object "GstCaps") + (c-name "gst_caps_split_one") + (return-type "GstCaps*") +) + +(define-method get_size + (of-object "GstCaps") + (c-name "gst_caps_get_size") + (return-type "int") +) + +(define-method get_structure + (of-object "GstCaps") + (c-name "gst_caps_get_structure") + (return-type "GstStructure*") + (parameters + '("int" "index") + ) +) + +(define-method copy_1 + (of-object "GstCaps") + (c-name "gst_caps_copy_1") + (return-type "GstCaps*") +) + +(define-method set_simple + (of-object "GstCaps") + (c-name "gst_caps_set_simple") + (return-type "none") + (parameters + '("char*" "field") + ) + (varargs #t) +) + +(define-method set_simple_valist + (of-object "GstCaps") + (c-name "gst_caps_set_simple_valist") + (return-type "none") + (parameters + '("char*" "field") + '("va_list" "varargs") + ) +) + +(define-method is_any + (of-object "GstCaps") + (c-name "gst_caps_is_any") + (return-type "gboolean") +) + +(define-method is_empty + (of-object "GstCaps") + (c-name "gst_caps_is_empty") + (return-type "gboolean") +) + +(define-method is_chained + (of-object "GstCaps") + (c-name "gst_caps_is_chained") + (return-type "gboolean") +) + +(define-method is_fixed + (of-object "GstCaps") + (c-name "gst_caps_is_fixed") + (return-type "gboolean") +) + +(define-method is_equal_fixed + (of-object "GstCaps") + (c-name "gst_caps_is_equal_fixed") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method is_always_compatible + (of-object "GstCaps") + (c-name "gst_caps_is_always_compatible") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method intersect + (of-object "GstCaps") + (c-name "gst_caps_intersect") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method union + (of-object "GstCaps") + (c-name "gst_caps_union") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method normalize + (of-object "GstCaps") + (c-name "gst_caps_normalize") + (return-type "GstCaps*") +) + +(define-method simplify + (of-object "GstCaps") + (c-name "gst_caps_simplify") + (return-type "GstCaps*") +) + +(define-method save_thyself + (of-object "GstCaps") + (c-name "gst_caps_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-function gst_caps_load_thyself + (c-name "gst_caps_load_thyself") + (return-type "GstCaps*") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-function gst_caps_replace + (c-name "gst_caps_replace") + (return-type "none") + (parameters + '("GstCaps**" "caps") + '("GstCaps*" "newcaps") + ) +) + +(define-method to_string + (of-object "GstCaps") + (c-name "gst_caps_to_string") + (return-type "gchar*") +) + +(define-function gst_caps_from_string + (c-name "gst_caps_from_string") + (return-type "GstCaps*") + (parameters + '("const-gchar*" "string") + ) +) + +(define-function gst_caps_structure_fixate_field_nearest_int + (c-name "gst_caps_structure_fixate_field_nearest_int") + (return-type "gboolean") + (parameters + '("GstStructure*" "structure") + '("const-char*" "field_name") + '("int" "target") + ) +) + +(define-function gst_caps_structure_fixate_field_nearest_double + (c-name "gst_caps_structure_fixate_field_nearest_double") + (return-type "gboolean") + (parameters + '("GstStructure*" "structure") + '("const-char*" "field_name") + '("double" "target") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstclock.h + +(define-function gst_clock_get_type + (c-name "gst_clock_get_type") + (return-type "GType") +) + +(define-method set_speed + (of-object "GstClock") + (c-name "gst_clock_set_speed") + (return-type "gdouble") + (parameters + '("gdouble" "speed") + ) +) + +(define-method get_speed + (of-object "GstClock") + (c-name "gst_clock_get_speed") + (return-type "gdouble") +) + +(define-method set_resolution + (of-object "GstClock") + (c-name "gst_clock_set_resolution") + (return-type "guint64") + (parameters + '("guint64" "resolution") + ) +) + +(define-method get_resolution + (of-object "GstClock") + (c-name "gst_clock_get_resolution") + (return-type "guint64") +) + +(define-method set_active + (of-object "GstClock") + (c-name "gst_clock_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method is_active + (of-object "GstClock") + (c-name "gst_clock_is_active") + (return-type "gboolean") +) + +(define-method reset + (of-object "GstClock") + (c-name "gst_clock_reset") + (return-type "none") +) + +(define-method handle_discont + (of-object "GstClock") + (c-name "gst_clock_handle_discont") + (return-type "gboolean") + (parameters + '("guint64" "time") + ) +) + +(define-method get_time + (of-object "GstClock") + (c-name "gst_clock_get_time") + (return-type "GstClockTime") +) + +(define-method get_event_time + (of-object "GstClock") + (c-name "gst_clock_get_event_time") + (return-type "GstClockTime") +) + +(define-method get_next_id + (of-object "GstClock") + (c-name "gst_clock_get_next_id") + (return-type "GstClockID") +) + +(define-method new_single_shot_id + (of-object "GstClock") + (c-name "gst_clock_new_single_shot_id") + (return-type "GstClockID") + (parameters + '("GstClockTime" "time") + ) +) + +(define-method new_periodic_id + (of-object "GstClock") + (c-name "gst_clock_new_periodic_id") + (return-type "GstClockID") + (parameters + '("GstClockTime" "start_time") + '("GstClockTime" "interval") + ) +) + +(define-method get_time + (of-object "GstClockID") + (c-name "gst_clock_id_get_time") + (return-type "GstClockTime") +) + +(define-method wait + (of-object "GstClockID") + (c-name "gst_clock_id_wait") + (return-type "GstClockReturn") + (parameters + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method wait_async + (of-object "GstClockID") + (c-name "gst_clock_id_wait_async") + (return-type "GstClockReturn") + (parameters + '("GstClockCallback" "func") + '("gpointer" "user_data") + ) +) + +(define-method unschedule + (of-object "GstClockID") + (c-name "gst_clock_id_unschedule") + (return-type "none") +) + +(define-method unlock + (of-object "GstClockID") + (c-name "gst_clock_id_unlock") + (return-type "none") +) + +(define-method free + (of-object "GstClockID") + (c-name "gst_clock_id_free") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstconfig.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstcpu.h + +(define-function _gst_cpu_initialize + (c-name "_gst_cpu_initialize") + (return-type "none") + (parameters + '("gboolean" "useopt") + ) +) + +(define-function gst_cpu_get_flags + (c-name "gst_cpu_get_flags") + (return-type "GstCPUFlags") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstdata.h + +(define-method init + (of-object "GstData") + (c-name "gst_data_init") + (return-type "none") + (parameters + '("GType" "type") + '("guint16" "flags") + '("GstDataFreeFunction" "free") + '("GstDataCopyFunction" "copy") + ) +) + +(define-method dispose + (of-object "GstData") + (c-name "gst_data_dispose") + (return-type "none") +) + +(define-method copy_into + (of-object "GstData") + (c-name "gst_data_copy_into") + (return-type "none") + (parameters + '("GstData*" "target") + ) +) + +(define-method copy + (of-object "GstData") + (c-name "gst_data_copy") + (return-type "GstData*") +) + +(define-method is_writable + (of-object "GstData") + (c-name "gst_data_is_writable") + (return-type "gboolean") +) + +(define-method copy_on_write + (of-object "GstData") + (c-name "gst_data_copy_on_write") + (return-type "GstData*") +) + +(define-method free + (of-object "GstData") + (c-name "gst_data_free") + (return-type "none") +) + +(define-method ref + (of-object "GstData") + (c-name "gst_data_ref") + (return-type "GstData*") +) + +(define-method ref_by_count + (of-object "GstData") + (c-name "gst_data_ref_by_count") + (return-type "GstData*") + (parameters + '("gint" "count") + ) +) + +(define-method unref + (of-object "GstData") + (c-name "gst_data_unref") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstelement.h + +(define-method add_pad_template + (of-object "GstElementClass") + (c-name "gst_element_class_add_pad_template") + (return-type "none") + (parameters + '("GstPadTemplate*" "templ") + ) +) + +(define-method install_std_props + (of-object "GstElementClass") + (c-name "gst_element_class_install_std_props") + (return-type "none") + (parameters + '("const-gchar*" "first_name") + ) + (varargs #t) +) + +(define-method set_details + (of-object "GstElementClass") + (c-name "gst_element_class_set_details") + (return-type "none") + (parameters + '("const-GstElementDetails*" "details") + ) +) + +(define-function gst_element_default_error + (c-name "gst_element_default_error") + (return-type "none") + (parameters + '("GObject*" "object") + '("GstObject*" "orig") + '("GError*" "error") + '("gchar*" "debug") + ) +) + +(define-function gst_element_get_type + (c-name "gst_element_get_type") + (return-type "GType") +) + +(define-method set_loop_function + (of-object "GstElement") + (c-name "gst_element_set_loop_function") + (return-type "none") + (parameters + '("GstElementLoopFunction" "loop") + ) +) + +(define-method set + (of-object "GstElement") + (c-name "gst_element_set") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + ) + (varargs #t) +) + +(define-method get + (of-object "GstElement") + (c-name "gst_element_get") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + ) + (varargs #t) +) + +(define-method set_valist + (of-object "GstElement") + (c-name "gst_element_set_valist") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + '("va_list" "var_args") + ) +) + +(define-method get_valist + (of-object "GstElement") + (c-name "gst_element_get_valist") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + '("va_list" "var_args") + ) +) + +(define-method set_property + (of-object "GstElement") + (c-name "gst_element_set_property") + (return-type "none") + (parameters + '("const-gchar*" "property_name") + '("const-GValue*" "value") + ) +) + +(define-method get_property + (of-object "GstElement") + (c-name "gst_element_get_property") + (return-type "none") + (parameters + '("const-gchar*" "property_name") + '("GValue*" "value") + ) +) + +(define-method enable_threadsafe_properties + (of-object "GstElement") + (c-name "gst_element_enable_threadsafe_properties") + (return-type "none") +) + +(define-method disable_threadsafe_properties + (of-object "GstElement") + (c-name "gst_element_disable_threadsafe_properties") + (return-type "none") +) + +(define-method set_pending_properties + (of-object "GstElement") + (c-name "gst_element_set_pending_properties") + (return-type "none") +) + +(define-method requires_clock + (of-object "GstElement") + (c-name "gst_element_requires_clock") + (return-type "gboolean") +) + +(define-method provides_clock + (of-object "GstElement") + (c-name "gst_element_provides_clock") + (return-type "gboolean") +) + +(define-method get_clock + (of-object "GstElement") + (c-name "gst_element_get_clock") + (return-type "GstClock*") +) + +(define-method set_clock + (of-object "GstElement") + (c-name "gst_element_set_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method clock_wait + (of-object "GstElement") + (c-name "gst_element_clock_wait") + (return-type "GstClockReturn") + (parameters + '("GstClockID" "id") + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method get_time + (of-object "GstElement") + (c-name "gst_element_get_time") + (return-type "GstClockTime") +) + +(define-method wait + (of-object "GstElement") + (c-name "gst_element_wait") + (return-type "gboolean") + (parameters + '("GstClockTime" "timestamp") + ) +) + +(define-method set_time + (of-object "GstElement") + (c-name "gst_element_set_time") + (return-type "none") + (parameters + '("GstClockTime" "time") + ) +) + +(define-method adjust_time + (of-object "GstElement") + (c-name "gst_element_adjust_time") + (return-type "none") + (parameters + '("GstClockTimeDiff" "diff") + ) +) + +(define-method is_indexable + (of-object "GstElement") + (c-name "gst_element_is_indexable") + (return-type "gboolean") +) + +(define-method set_index + (of-object "GstElement") + (c-name "gst_element_set_index") + (return-type "none") + (parameters + '("GstIndex*" "index") + ) +) + +(define-method get_index + (of-object "GstElement") + (c-name "gst_element_get_index") + (return-type "GstIndex*") +) + +(define-method release_locks + (of-object "GstElement") + (c-name "gst_element_release_locks") + (return-type "gboolean") +) + +(define-method yield + (of-object "GstElement") + (c-name "gst_element_yield") + (return-type "none") +) + +(define-method interrupt + (of-object "GstElement") + (c-name "gst_element_interrupt") + (return-type "gboolean") +) + +(define-method set_scheduler + (of-object "GstElement") + (c-name "gst_element_set_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched") + ) +) + +(define-method get_scheduler + (of-object "GstElement") + (c-name "gst_element_get_scheduler") + (return-type "GstScheduler*") +) + +(define-method add_pad + (of-object "GstElement") + (c-name "gst_element_add_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method remove_pad + (of-object "GstElement") + (c-name "gst_element_remove_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method add_ghost_pad + (of-object "GstElement") + (c-name "gst_element_add_ghost_pad") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + '("const-gchar*" "name") + ) +) + +(define-method remove_ghost_pad + (of-object "GstElement") + (c-name "gst_element_remove_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_pad + (of-object "GstElement") + (c-name "gst_element_get_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_static_pad + (of-object "GstElement") + (c-name "gst_element_get_static_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_request_pad + (of-object "GstElement") + (c-name "gst_element_get_request_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method release_request_pad + (of-object "GstElement") + (c-name "gst_element_release_request_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_pad_list + (of-object "GstElement") + (c-name "gst_element_get_pad_list") + (return-type "const-GList*") +) + +(define-method get_compatible_pad + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_compatible_pad_filtered + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad_filtered") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method get_pad_template + (of-object "GstElementClass") + (c-name "gst_element_class_get_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_pad_template_list + (of-object "GstElementClass") + (c-name "gst_element_class_get_pad_template_list") + (return-type "GList*") +) + +(define-method get_pad_template + (of-object "GstElement") + (c-name "gst_element_get_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_pad_template_list + (of-object "GstElement") + (c-name "gst_element_get_pad_template_list") + (return-type "GList*") +) + +(define-method get_compatible_pad_template + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("GstPadTemplate*" "compattempl") + ) +) + +(define-method link + (of-object "GstElement") + (c-name "gst_element_link") + (return-type "gboolean") + (parameters + '("GstElement*" "dest") + ) +) + +(define-method link_filtered + (of-object "GstElement") + (c-name "gst_element_link_filtered") + (return-type "gboolean") + (parameters + '("GstElement*" "dest") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-function element_link_many + (c-name "gst_element_link_many") + (return-type "gboolean") + (parameters + '("GstElement*" "element_1") + '("GstElement*" "element_2") + ) + (varargs #t) +) + +(define-method unlink + (of-object "GstElement") + (c-name "gst_element_unlink") + (return-type "none") + (parameters + '("GstElement*" "dest") + ) +) + +(define-method unlink_many + (of-object "GstElement") + (c-name "gst_element_unlink_many") + (return-type "none") + (parameters + '("GstElement*" "element_2") + ) + (varargs #t) +) + +(define-method link_pads + (of-object "GstElement") + (c-name "gst_element_link_pads") + (return-type "gboolean") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + ) +) + +(define-method link_pads_filtered + (of-object "GstElement") + (c-name "gst_element_link_pads_filtered") + (return-type "gboolean") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method unlink_pads + (of-object "GstElement") + (c-name "gst_element_unlink_pads") + (return-type "none") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + ) +) + +(define-method get_event_masks + (of-object "GstElement") + (c-name "gst_element_get_event_masks") + (return-type "const-GstEventMask*") +) + +(define-method send_event + (of-object "GstElement") + (c-name "gst_element_send_event") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-method seek + (of-object "GstElement") + (c-name "gst_element_seek") + (return-type "gboolean") + (parameters + '("GstSeekType" "seek_type") + '("guint64" "offset") + ) +) + +(define-method get_query_types + (of-object "GstElement") + (c-name "gst_element_get_query_types") + (return-type "const-GstQueryType*") +) + +(define-method query + (of-object "GstElement") + (c-name "gst_element_query") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method get_formats + (of-object "GstElement") + (c-name "gst_element_get_formats") + (return-type "const-GstFormat*") +) + +(define-method convert + (of-object "GstElement") + (c-name "gst_element_convert") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method found_tags + (of-object "GstElement") + (c-name "gst_element_found_tags") + (return-type "none") + (parameters + '("const-GstTagList*" "tag_list") + ) +) + +(define-method found_tags_for_pad + (of-object "GstElement") + (c-name "gst_element_found_tags_for_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + '("GstClockTime" "timestamp") + '("GstTagList*" "list") + ) +) + +(define-method set_eos + (of-object "GstElement") + (c-name "gst_element_set_eos") + (return-type "none") +) + +(define-function _gst_element_error_printf + (c-name "_gst_element_error_printf") + (return-type "gchar*") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-method error_full + (of-object "GstElement") + (c-name "gst_element_error_full") + (return-type "none") + (parameters + '("GQuark" "domain") + '("gint" "code") + '("gchar*" "message") + '("gchar*" "debug") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + ) +) + +(define-method is_locked_state + (of-object "GstElement") + (c-name "gst_element_is_locked_state") + (return-type "gboolean") +) + +(define-method set_locked_state + (of-object "GstElement") + (c-name "gst_element_set_locked_state") + (return-type "none") + (parameters + '("gboolean" "locked_state") + ) +) + +(define-method sync_state_with_parent + (of-object "GstElement") + (c-name "gst_element_sync_state_with_parent") + (return-type "gboolean") +) + +(define-method get_state + (of-object "GstElement") + (c-name "gst_element_get_state") + (return-type "GstElementState") +) + +(define-method set_state + (of-object "GstElement") + (c-name "gst_element_set_state") + (return-type "GstElementStateReturn") + (parameters + '("GstElementState" "state") + ) +) + +(define-method wait_state_change + (of-object "GstElement") + (c-name "gst_element_wait_state_change") + (return-type "none") +) + +(define-method get_name + (of-object "GstElementState") + (c-name "gst_element_state_get_name") + (return-type "const-gchar*") +) + +(define-method get_factory + (of-object "GstElement") + (c-name "gst_element_get_factory") + (return-type "GstElementFactory*") +) + +(define-method get_managing_bin + (of-object "GstElement") + (c-name "gst_element_get_managing_bin") + (return-type "GstBin*") +) + +(define-function gst_element_factory_get_type + (c-name "gst_element_factory_get_type") + (return-type "GType") +) + +(define-function gst_element_register + (c-name "gst_element_register") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + '("const-gchar*" "elementname") + '("guint" "rank") + '("GType" "type") + ) +) + +(define-function gst_element_factory_find + (c-name "gst_element_factory_find") + (return-type "GstElementFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_element_type + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_element_type") + (return-type "GType") +) + +(define-method get_longname + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_longname") + (return-type "const-gchar*") +) + +(define-method get_klass + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_klass") + (return-type "const-gchar*") +) + +(define-method get_description + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_description") + (return-type "const-gchar*") +) + +(define-method get_author + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_author") + (return-type "const-gchar*") +) + +(define-method get_num_pad_templates + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_num_pad_templates") + (return-type "guint") +) + +(define-method get_pad_templates + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_pad_templates") + (return-type "const-GList*") +) + +(define-method get_uri_type + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_uri_type") + (return-type "guint") +) + +(define-method get_uri_protocols + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_uri_protocols") + (return-type "gchar**") +) + +(define-method create + (of-object "GstElementFactory") + (c-name "gst_element_factory_create") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_element_factory_make + (is-constructor-of "GstElement") + (c-name "gst_element_factory_make") + (return-type "GstElement*") + (parameters + '("const-gchar*" "factoryname") + '("const-gchar*" "name") + ) +) + +(define-method can_src_caps + (of-object "GstElementFactory") + (c-name "gst_element_factory_can_src_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method can_sink_caps + (of-object "GstElementFactory") + (c-name "gst_element_factory_can_sink_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method __add_pad_template + (of-object "GstElementFactory") + (c-name "__gst_element_factory_add_pad_template") + (return-type "none") + (parameters + '("GstPadTemplate*" "templ") + ) +) + +(define-method __add_interface + (of-object "GstElementFactory") + (c-name "__gst_element_factory_add_interface") + (return-type "none") + (parameters + '("const-gchar*" "interfacename") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstenumtypes.h + +(define-function gst_object_flags_get_type + (c-name "gst_object_flags_get_type") + (return-type "GType") +) + +(define-function gst_bin_flags_get_type + (c-name "gst_bin_flags_get_type") + (return-type "GType") +) + +(define-function gst_buffer_flag_get_type + (c-name "gst_buffer_flag_get_type") + (return-type "GType") +) + +(define-function gst_clock_entry_status_get_type + (c-name "gst_clock_entry_status_get_type") + (return-type "GType") +) + +(define-function gst_clock_entry_type_get_type + (c-name "gst_clock_entry_type_get_type") + (return-type "GType") +) + +(define-function gst_clock_return_get_type + (c-name "gst_clock_return_get_type") + (return-type "GType") +) + +(define-function gst_clock_flags_get_type + (c-name "gst_clock_flags_get_type") + (return-type "GType") +) + +(define-function gst_cpu_flags_get_type + (c-name "gst_cpu_flags_get_type") + (return-type "GType") +) + +(define-function gst_data_flags_get_type + (c-name "gst_data_flags_get_type") + (return-type "GType") +) + +(define-function gst_element_flags_get_type + (c-name "gst_element_flags_get_type") + (return-type "GType") +) + +(define-function gst_core_error_get_type + (c-name "gst_core_error_get_type") + (return-type "GType") +) + +(define-function gst_library_error_get_type + (c-name "gst_library_error_get_type") + (return-type "GType") +) + +(define-function gst_resource_error_get_type + (c-name "gst_resource_error_get_type") + (return-type "GType") +) + +(define-function gst_stream_error_get_type + (c-name "gst_stream_error_get_type") + (return-type "GType") +) + +(define-function gst_event_type_get_type + (c-name "gst_event_type_get_type") + (return-type "GType") +) + +(define-function gst_event_flag_get_type + (c-name "gst_event_flag_get_type") + (return-type "GType") +) + +(define-function gst_seek_type_get_type + (c-name "gst_seek_type_get_type") + (return-type "GType") +) + +(define-function gst_seek_accuracy_get_type + (c-name "gst_seek_accuracy_get_type") + (return-type "GType") +) + +(define-function gst_format_get_type + (c-name "gst_format_get_type") + (return-type "GType") +) + +(define-function gst_index_certainty_get_type + (c-name "gst_index_certainty_get_type") + (return-type "GType") +) + +(define-function gst_index_entry_type_get_type + (c-name "gst_index_entry_type_get_type") + (return-type "GType") +) + +(define-function gst_index_lookup_method_get_type + (c-name "gst_index_lookup_method_get_type") + (return-type "GType") +) + +(define-function gst_assoc_flags_get_type + (c-name "gst_assoc_flags_get_type") + (return-type "GType") +) + +(define-function gst_index_resolver_method_get_type + (c-name "gst_index_resolver_method_get_type") + (return-type "GType") +) + +(define-function gst_index_flags_get_type + (c-name "gst_index_flags_get_type") + (return-type "GType") +) + +(define-function gst_debug_level_get_type + (c-name "gst_debug_level_get_type") + (return-type "GType") +) + +(define-function gst_debug_color_flags_get_type + (c-name "gst_debug_color_flags_get_type") + (return-type "GType") +) + +(define-function gst_pad_link_return_get_type + (c-name "gst_pad_link_return_get_type") + (return-type "GType") +) + +(define-function gst_pad_direction_get_type + (c-name "gst_pad_direction_get_type") + (return-type "GType") +) + +(define-function gst_pad_flags_get_type + (c-name "gst_pad_flags_get_type") + (return-type "GType") +) + +(define-function gst_pad_presence_get_type + (c-name "gst_pad_presence_get_type") + (return-type "GType") +) + +(define-function gst_pad_template_flags_get_type + (c-name "gst_pad_template_flags_get_type") + (return-type "GType") +) + +(define-function gst_plugin_error_get_type + (c-name "gst_plugin_error_get_type") + (return-type "GType") +) + +(define-function gst_query_type_get_type + (c-name "gst_query_type_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_flags_get_type + (c-name "gst_scheduler_flags_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_state_get_type + (c-name "gst_scheduler_state_get_type") + (return-type "GType") +) + +(define-function gst_tag_merge_mode_get_type + (c-name "gst_tag_merge_mode_get_type") + (return-type "GType") +) + +(define-function gst_tag_flag_get_type + (c-name "gst_tag_flag_get_type") + (return-type "GType") +) + +(define-function gst_thread_state_get_type + (c-name "gst_thread_state_get_type") + (return-type "GType") +) + +(define-function gst_alloc_trace_flags_get_type + (c-name "gst_alloc_trace_flags_get_type") + (return-type "GType") +) + +(define-function gst_type_find_probability_get_type + (c-name "gst_type_find_probability_get_type") + (return-type "GType") +) + +(define-function gst_element_state_get_type + (c-name "gst_element_state_get_type") + (return-type "GType") +) + +(define-function gst_element_state_return_get_type + (c-name "gst_element_state_return_get_type") + (return-type "GType") +) + +(define-function gst_result_get_type + (c-name "gst_result_get_type") + (return-type "GType") +) + +(define-function gst_uri_type_get_type + (c-name "gst_uri_type_get_type") + (return-type "GType") +) + +(define-function gst_registry_return_get_type + (c-name "gst_registry_return_get_type") + (return-type "GType") +) + +(define-function gst_registry_flags_get_type + (c-name "gst_registry_flags_get_type") + (return-type "GType") +) + +(define-function gst_parse_error_get_type + (c-name "gst_parse_error_get_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsterror.h + +(define-function gst_core_error_quark + (c-name "gst_core_error_quark") + (return-type "GQuark") +) + +(define-function gst_library_error_quark + (c-name "gst_library_error_quark") + (return-type "GQuark") +) + +(define-function gst_resource_error_quark + (c-name "gst_resource_error_quark") + (return-type "GQuark") +) + +(define-function gst_stream_error_quark + (c-name "gst_stream_error_quark") + (return-type "GQuark") +) + +(define-function gst_error_get_message + (c-name "gst_error_get_message") + (return-type "gchar*") + (parameters + '("GQuark" "domain") + '("gint" "code") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstevent.h + +(define-function _gst_event_initialize + (c-name "_gst_event_initialize") + (return-type "none") +) + +(define-function gst_event_get_type + (c-name "gst_event_get_type") + (return-type "GType") +) + +(define-function gst_event_new + (c-name "gst_event_new") + (is-constructor-of "GstEvent") + (return-type "GstEvent*") + (parameters + '("GstEventType" "type") + ) +) + +(define-method s_contains + (of-object "GstEventMask") + (c-name "gst_event_masks_contains") + (return-type "gboolean") + (parameters + '("GstEventMask*" "mask") + ) +) + +(define-function gst_event_new_seek + (c-name "gst_event_new_seek") + (return-type "GstEvent*") + (parameters + '("GstSeekType" "type") + '("gint64" "offset") + ) +) + +(define-function gst_event_new_segment_seek + (c-name "gst_event_new_segment_seek") + (return-type "GstEvent*") + (parameters + '("GstSeekType" "type") + '("gint64" "start") + '("gint64" "stop") + ) +) + +(define-function gst_event_new_size + (c-name "gst_event_new_size") + (return-type "GstEvent*") + (parameters + '("GstFormat" "format") + '("gint64" "value") + ) +) + +(define-function gst_event_new_discontinuous + (c-name "gst_event_new_discontinuous") + (return-type "GstEvent*") + (parameters + '("gboolean" "new_media") + '("GstFormat" "format1") + ) + (varargs #t) +) + +(define-function gst_event_new_discontinuous_valist + (c-name "gst_event_new_discontinuous_valist") + (return-type "GstEvent*") + (parameters + '("gboolean" "new_media") + '("GstFormat" "format1") + '("va_list" "var_args") + ) +) + +(define-method discont_get_value + (of-object "GstEvent") + (c-name "gst_event_discont_get_value") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + '("gint64*" "value") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstfilter.h + +(define-function gst_filter_run + (c-name "gst_filter_run") + (return-type "GList*") + (parameters + '("const-GList*" "list") + '("GstFilterFunc" "func") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstformat.h + +(define-function _gst_format_initialize + (c-name "_gst_format_initialize") + (return-type "none") +) + +(define-function gst_format_register + (c-name "gst_format_register") + (return-type "GstFormat") + (parameters + '("const-gchar*" "nick") + '("const-gchar*" "description") + ) +) + +(define-function gst_format_get_by_nick + (c-name "gst_format_get_by_nick") + (return-type "GstFormat") + (parameters + '("const-gchar*" "nick") + ) +) + +(define-method s_contains + (of-object "GstFormat") + (c-name "gst_formats_contains") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + ) +) + +(define-method get_details + (of-object "GstFormat") + (c-name "gst_format_get_details") + (return-type "const-GstFormatDefinition*") +) + +(define-function gst_format_get_definitions + (c-name "gst_format_get_definitions") + (return-type "const-GList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gst.h + +(define-function gst_init + (c-name "gst_init") + (return-type "none") + (parameters + '("int*" "argc") + '("char**[]" "argv") + ) +) + +(define-function gst_init_check + (c-name "gst_init_check") + (return-type "gboolean") + (parameters + '("int*" "argc") + '("char**[]" "argv") + ) +) + +(define-function gst_init_with_popt_table + (c-name "gst_init_with_popt_table") + (return-type "none") + (parameters + '("int*" "argc") + '("char**[]" "argv") + '("const-GstPoptOption*" "popt_options") + ) +) + +(define-function gst_init_check_with_popt_table + (c-name "gst_init_check_with_popt_table") + (return-type "gboolean") + (parameters + '("int*" "argc") + '("char**[]" "argv") + '("const-GstPoptOption*" "popt_options") + ) +) + +(define-function gst_init_get_popt_table + (c-name "gst_init_get_popt_table") + (return-type "const-GstPoptOption*") +) + +(define-function gst_use_threads + (c-name "gst_use_threads") + (return-type "none") + (parameters + '("gboolean" "use_threads") + ) +) + +(define-function gst_has_threads + (c-name "gst_has_threads") + (return-type "gboolean") +) + +(define-function gst_main + (c-name "gst_main") + (return-type "none") +) + +(define-function gst_main_quit + (c-name "gst_main_quit") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstindex.h + +(define-function gst_index_get_type + (c-name "gst_index_get_type") + (return-type "GType") +) + +(define-function gst_index_new + (c-name "gst_index_new") + (is-constructor-of "GstIndex") + (return-type "GstIndex*") +) + +(define-method commit + (of-object "GstIndex") + (c-name "gst_index_commit") + (return-type "none") + (parameters + '("gint" "id") + ) +) + +(define-method get_group + (of-object "GstIndex") + (c-name "gst_index_get_group") + (return-type "gint") +) + +(define-method new_group + (of-object "GstIndex") + (c-name "gst_index_new_group") + (return-type "gint") +) + +(define-method set_group + (of-object "GstIndex") + (c-name "gst_index_set_group") + (return-type "gboolean") + (parameters + '("gint" "groupnum") + ) +) + +(define-method set_certainty + (of-object "GstIndex") + (c-name "gst_index_set_certainty") + (return-type "none") + (parameters + '("GstIndexCertainty" "certainty") + ) +) + +(define-method get_certainty + (of-object "GstIndex") + (c-name "gst_index_get_certainty") + (return-type "GstIndexCertainty") +) + +(define-method set_filter + (of-object "GstIndex") + (c-name "gst_index_set_filter") + (return-type "none") + (parameters + '("GstIndexFilter" "filter") + '("gpointer" "user_data") + ) +) + +(define-method set_resolver + (of-object "GstIndex") + (c-name "gst_index_set_resolver") + (return-type "none") + (parameters + '("GstIndexResolver" "resolver") + '("gpointer" "user_data") + ) +) + +(define-method get_writer_id + (of-object "GstIndex") + (c-name "gst_index_get_writer_id") + (return-type "gboolean") + (parameters + '("GstObject*" "writer") + '("gint*" "id") + ) +) + +(define-method add_format + (of-object "GstIndex") + (c-name "gst_index_add_format") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstFormat" "format") + ) +) + +(define-method add_association + (of-object "GstIndex") + (c-name "gst_index_add_association") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + ) + (varargs #t) +) + +(define-method add_object + (of-object "GstIndex") + (c-name "gst_index_add_object") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("gchar*" "key") + '("GType" "type") + '("gpointer" "object") + ) +) + +(define-method add_id + (of-object "GstIndex") + (c-name "gst_index_add_id") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("gchar*" "description") + ) +) + +(define-method get_assoc_entry + (of-object "GstIndex") + (c-name "gst_index_get_assoc_entry") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstIndexLookupMethod" "method") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + ) +) + +(define-method get_assoc_entry_full + (of-object "GstIndex") + (c-name "gst_index_get_assoc_entry_full") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstIndexLookupMethod" "method") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + '("GCompareDataFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-function gst_index_entry_get_type + (c-name "gst_index_entry_get_type") + (return-type "GType") +) + +(define-method copy + (of-object "GstIndexEntry") + (c-name "gst_index_entry_copy") + (return-type "GstIndexEntry*") +) + +(define-method free + (of-object "GstIndexEntry") + (c-name "gst_index_entry_free") + (return-type "none") +) + +(define-method assoc_map + (of-object "GstIndexEntry") + (c-name "gst_index_entry_assoc_map") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + '("gint64*" "value") + ) +) + +(define-function gst_index_factory_get_type + (c-name "gst_index_factory_get_type") + (return-type "GType") +) + +(define-function gst_index_factory_new + (c-name "gst_index_factory_new") + (is-constructor-of "GstIndexFactory") + (return-type "GstIndexFactory*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "longdesc") + '("GType" "type") + ) +) + +(define-method destroy + (of-object "GstIndexFactory") + (c-name "gst_index_factory_destroy") + (return-type "none") +) + +(define-function gst_index_factory_find + (c-name "gst_index_factory_find") + (return-type "GstIndexFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method create + (of-object "GstIndexFactory") + (c-name "gst_index_factory_create") + (return-type "GstIndex*") +) + +(define-function gst_index_factory_make + (c-name "gst_index_factory_make") + (return-type "GstIndex*") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstinfo.h + +(define-function _gst_debug_init + (c-name "_gst_debug_init") + (return-type "none") +) + +(define-function gst_debug_log + (c-name "gst_debug_log") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function gst_debug_log_valist + (c-name "gst_debug_log_valist") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("const-gchar*" "format") + '("va_list" "args") + ) +) + +(define-method get + (of-object "GstDebugMessage") + (c-name "gst_debug_message_get") + (return-type "const-gchar*") +) + +(define-function gst_debug_log_default + (c-name "gst_debug_log_default") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("GstDebugMessage*" "message") + '("gpointer" "unused") + ) +) + +(define-method get_name + (of-object "GstDebugLevel") + (c-name "gst_debug_level_get_name") + (return-type "const-gchar*") +) + +(define-function gst_debug_add_log_function + (c-name "gst_debug_add_log_function") + (return-type "none") + (parameters + '("GstLogFunction" "func") + '("gpointer" "data") + ) +) + +(define-function gst_debug_remove_log_function + (c-name "gst_debug_remove_log_function") + (return-type "guint") + (parameters + '("GstLogFunction" "func") + ) +) + +(define-function gst_debug_remove_log_function_by_data + (c-name "gst_debug_remove_log_function_by_data") + (return-type "guint") + (parameters + '("gpointer" "data") + ) +) + +(define-function gst_debug_set_active + (c-name "gst_debug_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-function gst_debug_is_active + (c-name "gst_debug_is_active") + (return-type "gboolean") +) + +(define-function gst_debug_set_colored + (c-name "gst_debug_set_colored") + (return-type "none") + (parameters + '("gboolean" "colored") + ) +) + +(define-function gst_debug_is_colored + (c-name "gst_debug_is_colored") + (return-type "gboolean") +) + +(define-function gst_debug_set_default_threshold + (c-name "gst_debug_set_default_threshold") + (return-type "none") + (parameters + '("GstDebugLevel" "level") + ) +) + +(define-function gst_debug_get_default_threshold + (c-name "gst_debug_get_default_threshold") + (return-type "GstDebugLevel") +) + +(define-function gst_debug_set_threshold_for_name + (c-name "gst_debug_set_threshold_for_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("GstDebugLevel" "level") + ) +) + +(define-function gst_debug_unset_threshold_for_name + (c-name "gst_debug_unset_threshold_for_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function _gst_debug_category_new + (c-name "_gst_debug_category_new") + (is-constructor-of "GstDebugCategory") + (return-type "GstDebugCategory*") + (parameters + '("gchar*" "name") + '("guint" "color") + '("gchar*" "description") + ) +) + +(define-method free + (of-object "GstDebugCategory") + (c-name "gst_debug_category_free") + (return-type "none") +) + +(define-method set_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_set_threshold") + (return-type "none") + (parameters + '("GstDebugLevel" "level") + ) +) + +(define-method reset_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_reset_threshold") + (return-type "none") +) + +(define-method get_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_threshold") + (return-type "GstDebugLevel") +) + +(define-method get_name + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_name") + (return-type "const-gchar*") +) + +(define-method get_color + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_color") + (return-type "guint") +) + +(define-method get_description + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_description") + (return-type "const-gchar*") +) + +(define-function gst_debug_get_all_categories + (c-name "gst_debug_get_all_categories") + (return-type "GSList*") +) + +(define-function gst_debug_construct_term_color + (c-name "gst_debug_construct_term_color") + (return-type "gchar*") + (parameters + '("guint" "colorinfo") + ) +) + +(define-function _gst_debug_register_funcptr + (c-name "_gst_debug_register_funcptr") + (return-type "void*") + (parameters + '("void*" "ptr") + '("gchar*" "ptrname") + ) +) + +(define-function _gst_debug_nameof_funcptr + (c-name "_gst_debug_nameof_funcptr") + (return-type "const-gchar*") + (parameters + '("void*" "ptr") + ) +) + +(define-function gst_debug_print_stack_trace + (c-name "gst_debug_print_stack_trace") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstinterface.h + +(define-function gst_implements_interface_get_type + (c-name "gst_implements_interface_get_type") + (return-type "GType") +) + +(define-method implements_interface + (of-object "GstElement") + (c-name "gst_element_implements_interface") + (return-type "gboolean") + (parameters + '("GType" "iface_type") + ) +) + +(define-function gst_implements_interface_cast + (c-name "gst_implements_interface_cast") + (return-type "gpointer") + (parameters + '("gpointer" "from") + '("GType" "type") + ) +) + +(define-function gst_implements_interface_check + (c-name "gst_implements_interface_check") + (return-type "gboolean") + (parameters + '("gpointer" "from") + '("GType" "type") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstlog.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmacros.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmarshal.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmemchunk.h + +(define-function gst_mem_chunk_new + (c-name "gst_mem_chunk_new") + (is-constructor-of "GstMemChunk") + (return-type "GstMemChunk*") + (parameters + '("gchar*" "name") + '("gint" "atom_size") + '("gulong" "area_size") + '("gint" "type") + ) +) + +(define-method destroy + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_destroy") + (return-type "none") +) + +(define-method alloc + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_alloc") + (return-type "gpointer") +) + +(define-method alloc0 + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_alloc0") + (return-type "gpointer") +) + +(define-method free + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_free") + (return-type "none") + (parameters + '("gpointer" "mem") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstobject.h + +(define-function gst_object_get_type + (c-name "gst_object_get_type") + (return-type "GType") +) + +(define-method set_name + (of-object "GstObject") + (c-name "gst_object_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_name + (of-object "GstObject") + (c-name "gst_object_get_name") + (return-type "const-gchar*") +) + +(define-method set_parent + (of-object "GstObject") + (c-name "gst_object_set_parent") + (return-type "none") + (parameters + '("GstObject*" "parent") + ) +) + +(define-method get_parent + (of-object "GstObject") + (c-name "gst_object_get_parent") + (return-type "GstObject*") +) + +(define-method unparent + (of-object "GstObject") + (c-name "gst_object_unparent") + (return-type "none") +) + +(define-function gst_object_default_deep_notify + (c-name "gst_object_default_deep_notify") + (return-type "none") + (parameters + '("GObject*" "object") + '("GstObject*" "orig") + '("GParamSpec*" "pspec") + '("gchar**" "excluded_props") + ) +) + +(define-function gst_object_check_uniqueness + (c-name "gst_object_check_uniqueness") + (return-type "gboolean") + (parameters + '("GList*" "list") + '("const-gchar*" "name") + ) +) + +(define-method save_thyself + (of-object "GstObject") + (c-name "gst_object_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-method restore_thyself + (of-object "GstObject") + (c-name "gst_object_restore_thyself") + (return-type "none") + (parameters + '("xmlNodePtr" "self") + ) +) + +(define-method ref + (of-object "GstObject") + (c-name "gst_object_ref") + (return-type "GstObject*") +) + +(define-method unref + (of-object "GstObject") + (c-name "gst_object_unref") + (return-type "none") +) + +(define-method sink + (of-object "GstObject") + (c-name "gst_object_sink") + (return-type "none") +) + +(define-function gst_object_replace + (c-name "gst_object_replace") + (return-type "none") + (parameters + '("GstObject**" "oldobj") + '("GstObject*" "newobj") + ) +) + +(define-method get_path_string + (of-object "GstObject") + (c-name "gst_object_get_path_string") + (return-type "gchar*") +) + +(define-function gst_class_signal_connect + (c-name "gst_class_signal_connect") + (return-type "guint") + (parameters + '("GstObjectClass*" "klass") + '("const-gchar*" "name") + '("gpointer" "func") + '("gpointer" "func_data") + ) +) + +(define-function gst_class_signal_emit_by_name + (c-name "gst_class_signal_emit_by_name") + (return-type "none") + (parameters + '("GstObject*" "object") + '("const-gchar*" "name") + '("xmlNodePtr" "self") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpad.h + +(define-function gst_pad_get_type + (c-name "gst_pad_get_type") + (return-type "GType") +) + +(define-function gst_real_pad_get_type + (c-name "gst_real_pad_get_type") + (return-type "GType") +) + +(define-function gst_ghost_pad_get_type + (c-name "gst_ghost_pad_get_type") + (return-type "GType") +) + +(define-function gst_pad_new + (c-name "gst_pad_new") + (is-constructor-of "GstPad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + '("GstPadDirection" "direction") + ) +) + +(define-function gst_pad_new_from_template + (c-name "gst_pad_new_from_template") + (return-type "GstPad*") + (parameters + '("GstPadTemplate*" "templ") + '("const-gchar*" "name") + ) +) + +(define-function gst_pad_custom_new + (c-name "gst_pad_custom_new") + (is-constructor-of "GstPadCustom") + (return-type "GstPad*") + (parameters + '("GType" "type") + '("const-gchar*" "name") + '("GstPadDirection" "direction") + ) +) + +(define-function gst_pad_custom_new_from_template + (c-name "gst_pad_custom_new_from_template") + (return-type "GstPad*") + (parameters + '("GType" "type") + '("GstPadTemplate*" "templ") + '("const-gchar*" "name") + ) +) + +(define-method set_name + (of-object "GstPad") + (c-name "gst_pad_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_name + (of-object "GstPad") + (c-name "gst_pad_get_name") + (return-type "const-gchar*") +) + +(define-method get_direction + (of-object "GstPad") + (c-name "gst_pad_get_direction") + (return-type "GstPadDirection") +) + +(define-method set_active + (of-object "GstPad") + (c-name "gst_pad_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method is_active + (of-object "GstPad") + (c-name "gst_pad_is_active") + (return-type "gboolean") +) + +(define-method set_element_private + (of-object "GstPad") + (c-name "gst_pad_set_element_private") + (return-type "none") + (parameters + '("gpointer" "priv") + ) +) + +(define-method get_element_private + (of-object "GstPad") + (c-name "gst_pad_get_element_private") + (return-type "gpointer") +) + +(define-method set_parent + (of-object "GstPad") + (c-name "gst_pad_set_parent") + (return-type "none") + (parameters + '("GstElement*" "parent") + ) +) + +(define-method get_parent + (of-object "GstPad") + (c-name "gst_pad_get_parent") + (return-type "GstElement*") +) + +(define-method get_real_parent + (of-object "GstPad") + (c-name "gst_pad_get_real_parent") + (return-type "GstElement*") +) + +(define-method get_scheduler + (of-object "GstPad") + (c-name "gst_pad_get_scheduler") + (return-type "GstScheduler*") +) + +(define-method add_ghost_pad + (of-object "GstPad") + (c-name "gst_pad_add_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "ghostpad") + ) +) + +(define-method remove_ghost_pad + (of-object "GstPad") + (c-name "gst_pad_remove_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "ghostpad") + ) +) + +(define-method get_ghost_pad_list + (of-object "GstPad") + (c-name "gst_pad_get_ghost_pad_list") + (return-type "GList*") +) + +(define-method get_pad_template + (of-object "GstPad") + (c-name "gst_pad_get_pad_template") + (return-type "GstPadTemplate*") +) + +(define-method set_bufferalloc_function + (of-object "GstPad") + (c-name "gst_pad_set_bufferalloc_function") + (return-type "none") + (parameters + '("GstPadBufferAllocFunction" "bufferalloc") + ) +) + +(define-method alloc_buffer + (of-object "GstPad") + (c-name "gst_pad_alloc_buffer") + (return-type "GstBuffer*") + (parameters + '("guint64" "offset") + '("gint" "size") + ) +) + +(define-method set_chain_function + (of-object "GstPad") + (c-name "gst_pad_set_chain_function") + (return-type "none") + (parameters + '("GstPadChainFunction" "chain") + ) +) + +(define-method set_get_function + (of-object "GstPad") + (c-name "gst_pad_set_get_function") + (return-type "none") + (parameters + '("GstPadGetFunction" "get") + ) +) + +(define-method set_event_function + (of-object "GstPad") + (c-name "gst_pad_set_event_function") + (return-type "none") + (parameters + '("GstPadEventFunction" "event") + ) +) + +(define-method set_event_mask_function + (of-object "GstPad") + (c-name "gst_pad_set_event_mask_function") + (return-type "none") + (parameters + '("GstPadEventMaskFunction" "mask_func") + ) +) + +(define-method get_event_masks + (of-object "GstPad") + (c-name "gst_pad_get_event_masks") + (return-type "const-GstEventMask*") +) + +(define-method get_event_masks_default + (of-object "GstPad") + (c-name "gst_pad_get_event_masks_default") + (return-type "const-GstEventMask*") +) + +(define-method set_link_function + (of-object "GstPad") + (c-name "gst_pad_set_link_function") + (return-type "none") + (parameters + '("GstPadLinkFunction" "link") + ) +) + +(define-method can_link + (of-object "GstPad") + (c-name "gst_pad_can_link") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method can_link_filtered + (of-object "GstPad") + (c-name "gst_pad_can_link_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method set_unlink_function + (of-object "GstPad") + (c-name "gst_pad_set_unlink_function") + (return-type "none") + (parameters + '("GstPadUnlinkFunction" "unlink") + ) +) + +(define-method link + (of-object "GstPad") + (c-name "gst_pad_link") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method link_filtered + (of-object "GstPad") + (c-name "gst_pad_link_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method unlink + (of-object "GstPad") + (c-name "gst_pad_unlink") + (return-type "none") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method is_linked + (of-object "GstPad") + (c-name "gst_pad_is_linked") + (return-type "gboolean") +) + +(define-method get_peer + (of-object "GstPad") + (c-name "gst_pad_get_peer") + (return-type "GstPad*") +) + +(define-method get_negotiated_caps + (of-object "GstPad") + (c-name "gst_pad_get_negotiated_caps") + (return-type "const-GstCaps*") +) + +(define-method is_negotiated + (of-object "GstPad") + (c-name "gst_pad_is_negotiated") + (return-type "gboolean") +) + +(define-method get_caps + (of-object "GstPad") + (c-name "gst_pad_get_caps") + (return-type "GstCaps*") +) + +(define-method get_pad_template_caps + (of-object "GstPad") + (c-name "gst_pad_get_pad_template_caps") + (return-type "const-GstCaps*") +) + +(define-method try_set_caps + (of-object "GstPad") + (c-name "gst_pad_try_set_caps") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method try_set_caps_nonfixed + (of-object "GstPad") + (c-name "gst_pad_try_set_caps_nonfixed") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method check_compatibility + (of-object "GstPad") + (c-name "gst_pad_check_compatibility") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method set_getcaps_function + (of-object "GstPad") + (c-name "gst_pad_set_getcaps_function") + (return-type "none") + (parameters + '("GstPadGetCapsFunction" "getcaps") + ) +) + +(define-method set_fixate_function + (of-object "GstPad") + (c-name "gst_pad_set_fixate_function") + (return-type "none") + (parameters + '("GstPadFixateFunction" "fixate") + ) +) + +(define-method proxy_getcaps + (of-object "GstPad") + (c-name "gst_pad_proxy_getcaps") + (return-type "GstCaps*") +) + +(define-method proxy_pad_link + (of-object "GstPad") + (c-name "gst_pad_proxy_pad_link") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method proxy_fixate + (of-object "GstPad") + (c-name "gst_pad_proxy_fixate") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method proxy_link + (of-object "GstPad") + (c-name "gst_pad_proxy_link") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method set_explicit_caps + (of-object "GstPad") + (c-name "gst_pad_set_explicit_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method use_explicit_caps + (of-object "GstPad") + (c-name "gst_pad_use_explicit_caps") + (return-type "none") +) + +(define-method relink_filtered + (of-object "GstPad") + (c-name "gst_pad_relink_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method perform_negotiate + (of-object "GstPad") + (c-name "gst_pad_perform_negotiate") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method renegotiate + (of-object "GstPad") + (c-name "gst_pad_renegotiate") + (return-type "GstPadLinkReturn") +) + +(define-method unnegotiate + (of-object "GstPad") + (c-name "gst_pad_unnegotiate") + (return-type "none") +) + +(define-method try_relink_filtered + (of-object "GstPad") + (c-name "gst_pad_try_relink_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method get_allowed_caps + (of-object "GstPad") + (c-name "gst_pad_get_allowed_caps") + (return-type "GstCaps*") +) + +(define-method caps_change_notify + (of-object "GstPad") + (c-name "gst_pad_caps_change_notify") + (return-type "none") +) + +(define-method recover_caps_error + (of-object "GstPad") + (c-name "gst_pad_recover_caps_error") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "allowed") + ) +) + +(define-method push + (of-object "GstPad") + (c-name "gst_pad_push") + (return-type "none") + (parameters + '("GstData*" "data") + ) +) + +(define-method pull + (of-object "GstPad") + (c-name "gst_pad_pull") + (return-type "GstData*") +) + +(define-method send_event + (of-object "GstPad") + (c-name "gst_pad_send_event") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-method event_default + (of-object "GstPad") + (c-name "gst_pad_event_default") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-function gst_pad_selectv + (c-name "gst_pad_selectv") + (return-type "GstPad*") + (parameters + '("GList*" "padlist") + ) +) + +(define-method select + (of-object "GstPad") + (c-name "gst_pad_select") + (return-type "GstPad*") + (parameters + ) + (varargs #t) +) + +(define-method select_valist + (of-object "GstPad") + (c-name "gst_pad_select_valist") + (return-type "GstPad*") + (parameters + '("va_list" "varargs") + ) +) + +(define-method set_formats_function + (of-object "GstPad") + (c-name "gst_pad_set_formats_function") + (return-type "none") + (parameters + '("GstPadFormatsFunction" "formats") + ) +) + +(define-method get_formats + (of-object "GstPad") + (c-name "gst_pad_get_formats") + (return-type "const-GstFormat*") +) + +(define-method get_formats_default + (of-object "GstPad") + (c-name "gst_pad_get_formats_default") + (return-type "const-GstFormat*") +) + +(define-method set_convert_function + (of-object "GstPad") + (c-name "gst_pad_set_convert_function") + (return-type "none") + (parameters + '("GstPadConvertFunction" "convert") + ) +) + +(define-method convert + (of-object "GstPad") + (c-name "gst_pad_convert") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method convert_default + (of-object "GstPad") + (c-name "gst_pad_convert_default") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method set_query_function + (of-object "GstPad") + (c-name "gst_pad_set_query_function") + (return-type "none") + (parameters + '("GstPadQueryFunction" "query") + ) +) + +(define-method set_query_type_function + (of-object "GstPad") + (c-name "gst_pad_set_query_type_function") + (return-type "none") + (parameters + '("GstPadQueryTypeFunction" "type_func") + ) +) + +(define-method get_query_types + (of-object "GstPad") + (c-name "gst_pad_get_query_types") + (return-type "const-GstQueryType*") +) + +(define-method get_query_types_default + (of-object "GstPad") + (c-name "gst_pad_get_query_types_default") + (return-type "const-GstQueryType*") +) + +(define-method query + (of-object "GstPad") + (c-name "gst_pad_query") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method query_default + (of-object "GstPad") + (c-name "gst_pad_query_default") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method set_internal_link_function + (of-object "GstPad") + (c-name "gst_pad_set_internal_link_function") + (return-type "none") + (parameters + '("GstPadIntLinkFunction" "intlink") + ) +) + +(define-method get_internal_links + (of-object "GstPad") + (c-name "gst_pad_get_internal_links") + (return-type "GList*") +) + +(define-method get_internal_links_default + (of-object "GstPad") + (c-name "gst_pad_get_internal_links_default") + (return-type "GList*") +) + +(define-method dispatcher + (of-object "GstPad") + (c-name "gst_pad_dispatcher") + (return-type "gboolean") + (parameters + '("GstPadDispatcherFunction" "dispatch") + '("gpointer" "data") + ) +) + +(define-function gst_pad_load_and_link + (c-name "gst_pad_load_and_link") + (return-type "none") + (parameters + '("xmlNodePtr" "self") + '("GstObject*" "parent") + ) +) + +(define-function gst_ghost_pad_new + (c-name "gst_ghost_pad_new") + (is-constructor-of "GstGhostPad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + '("GstPad*" "pad") + ) +) + +(define-function gst_pad_template_get_type + (c-name "gst_pad_template_get_type") + (return-type "GType") +) + +(define-function gst_pad_template_new + (c-name "gst_pad_template_new") + (is-constructor-of "GstPadTemplate") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name_template") + '("GstPadDirection" "direction") + '("GstPadPresence" "presence") + '("GstCaps*" "caps") + ) +) + +(define-method get + (of-object "GstStaticPadTemplate") + (c-name "gst_static_pad_template_get") + (return-type "GstPadTemplate*") +) + +(define-method get_caps + (of-object "GstPadTemplate") + (c-name "gst_pad_template_get_caps") + (return-type "const-GstCaps*") +) + +(define-method get_caps_by_name + (of-object "GstPadTemplate") + (c-name "gst_pad_template_get_caps_by_name") + (return-type "const-GstCaps*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_ghost_pad_save_thyself + (c-name "gst_ghost_pad_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("GstPad*" "pad") + '("xmlNodePtr" "parent") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstparse.h + +(define-function gst_parse_error_quark + (c-name "gst_parse_error_quark") + (return-type "GQuark") +) + +(define-function gst_parse_launch + (c-name "gst_parse_launch") + (return-type "GstElement*") + (parameters + '("const-gchar*" "pipeline_description") + '("GError**" "error") + ) +) + +(define-function gst_parse_launchv + (c-name "gst_parse_launchv") + (return-type "GstElement*") + (parameters + '("const-gchar**" "argv") + '("GError**" "error") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpipeline.h + +(define-function gst_pipeline_get_type + (c-name "gst_pipeline_get_type") + (return-type "GType") +) + +(define-function gst_pipeline_new + (c-name "gst_pipeline_new") + (is-constructor-of "GstPipeline") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpluginfeature.h + +(define-function gst_plugin_feature_get_type + (c-name "gst_plugin_feature_get_type") + (return-type "GType") +) + +(define-method ensure_loaded + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_ensure_loaded") + (return-type "gboolean") +) + +(define-method unload_thyself + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_unload_thyself") + (return-type "none") +) + +(define-method type_name_filter + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_type_name_filter") + (return-type "gboolean") + (parameters + '("GstTypeNameData*" "data") + ) +) + +(define-method set_rank + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_set_rank") + (return-type "none") + (parameters + '("guint" "rank") + ) +) + +(define-method set_name + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_rank + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_get_rank") + (return-type "guint") +) + +(define-method get_name + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_get_name") + (return-type "const-gchar*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstplugin.h + +(define-function gst_plugin_error_quark + (c-name "gst_plugin_error_quark") + (return-type "GQuark") +) + +(define-function gst_plugin_get_type + (c-name "gst_plugin_get_type") + (return-type "GType") +) + +(define-function _gst_plugin_initialize + (c-name "_gst_plugin_initialize") + (return-type "none") +) + +(define-function _gst_plugin_register_static + (c-name "_gst_plugin_register_static") + (return-type "none") + (parameters + '("GstPluginDesc*" "desc") + ) +) + +(define-method get_name + (of-object "GstPlugin") + (c-name "gst_plugin_get_name") + (return-type "const-gchar*") +) + +(define-method get_description + (of-object "GstPlugin") + (c-name "gst_plugin_get_description") + (return-type "const-gchar*") +) + +(define-method get_filename + (of-object "GstPlugin") + (c-name "gst_plugin_get_filename") + (return-type "const-gchar*") +) + +(define-method get_license + (of-object "GstPlugin") + (c-name "gst_plugin_get_license") + (return-type "const-gchar*") +) + +(define-method get_package + (of-object "GstPlugin") + (c-name "gst_plugin_get_package") + (return-type "const-gchar*") +) + +(define-method get_origin + (of-object "GstPlugin") + (c-name "gst_plugin_get_origin") + (return-type "const-gchar*") +) + +(define-method get_module + (of-object "GstPlugin") + (c-name "gst_plugin_get_module") + (return-type "GModule*") +) + +(define-method is_loaded + (of-object "GstPlugin") + (c-name "gst_plugin_is_loaded") + (return-type "gboolean") +) + +(define-method feature_filter + (of-object "GstPlugin") + (c-name "gst_plugin_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_plugin_list_feature_filter + (c-name "gst_plugin_list_feature_filter") + (return-type "GList*") + (parameters + '("GList*" "list") + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method name_filter + (of-object "GstPlugin") + (c-name "gst_plugin_name_filter") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_feature_list + (of-object "GstPlugin") + (c-name "gst_plugin_get_feature_list") + (return-type "GList*") +) + +(define-method find_feature + (of-object "GstPlugin") + (c-name "gst_plugin_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-function gst_plugin_load_file + (c-name "gst_plugin_load_file") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "filename") + '("GError**" "error") + ) +) + +(define-method unload_plugin + (of-object "GstPlugin") + (c-name "gst_plugin_unload_plugin") + (return-type "gboolean") +) + +(define-method add_feature + (of-object "GstPlugin") + (c-name "gst_plugin_add_feature") + (return-type "none") + (parameters + '("GstPluginFeature*" "feature") + ) +) + +(define-function gst_plugin_load + (c-name "gst_plugin_load") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_library_load + (c-name "gst_library_load") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstprobe.h + +(define-function gst_probe_new + (c-name "gst_probe_new") + (is-constructor-of "GstProbe") + (return-type "GstProbe*") + (parameters + '("gboolean" "single_shot") + '("GstProbeCallback" "callback") + '("gpointer" "user_data") + ) +) + +(define-method destroy + (of-object "GstProbe") + (c-name "gst_probe_destroy") + (return-type "none") +) + +(define-method perform + (of-object "GstProbe") + (c-name "gst_probe_perform") + (return-type "gboolean") + (parameters + '("GstData**" "data") + ) +) + +(define-function gst_probe_dispatcher_new + (c-name "gst_probe_dispatcher_new") + (is-constructor-of "GstProbeDispatcher") + (return-type "GstProbeDispatcher*") +) + +(define-method destroy + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_destroy") + (return-type "none") +) + +(define-method init + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_init") + (return-type "none") +) + +(define-method set_active + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method add_probe + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_add_probe") + (return-type "none") + (parameters + '("GstProbe*" "probe") + ) +) + +(define-method remove_probe + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_remove_probe") + (return-type "none") + (parameters + '("GstProbe*" "probe") + ) +) + +(define-method dispatch + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_dispatch") + (return-type "gboolean") + (parameters + '("GstData**" "data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstquery.h + +(define-function _gst_query_type_initialize + (c-name "_gst_query_type_initialize") + (return-type "none") +) + +(define-function gst_query_type_register + (c-name "gst_query_type_register") + (return-type "GstQueryType") + (parameters + '("const-gchar*" "nick") + '("const-gchar*" "description") + ) +) + +(define-function gst_query_type_get_by_nick + (c-name "gst_query_type_get_by_nick") + (return-type "GstQueryType") + (parameters + '("const-gchar*" "nick") + ) +) + +(define-method s_contains + (of-object "GstQueryType") + (c-name "gst_query_types_contains") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + ) +) + +(define-method get_details + (of-object "GstQueryType") + (c-name "gst_query_type_get_details") + (return-type "const-GstQueryTypeDefinition*") +) + +(define-function gst_query_type_get_definitions + (c-name "gst_query_type_get_definitions") + (return-type "const-GList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstqueue.h + +(define-function gst_queue_get_type + (c-name "gst_queue_get_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstregistry.h + +(define-function gst_registry_get_type + (c-name "gst_registry_get_type") + (return-type "GType") +) + +(define-method load + (of-object "GstRegistry") + (c-name "gst_registry_load") + (return-type "gboolean") +) + +(define-method is_loaded + (of-object "GstRegistry") + (c-name "gst_registry_is_loaded") + (return-type "gboolean") +) + +(define-method save + (of-object "GstRegistry") + (c-name "gst_registry_save") + (return-type "gboolean") +) + +(define-method rebuild + (of-object "GstRegistry") + (c-name "gst_registry_rebuild") + (return-type "gboolean") +) + +(define-method unload + (of-object "GstRegistry") + (c-name "gst_registry_unload") + (return-type "gboolean") +) + +(define-method add_path + (of-object "GstRegistry") + (c-name "gst_registry_add_path") + (return-type "none") + (parameters + '("const-gchar*" "path") + ) +) + +(define-method get_path_list + (of-object "GstRegistry") + (c-name "gst_registry_get_path_list") + (return-type "GList*") +) + +(define-method clear_paths + (of-object "GstRegistry") + (c-name "gst_registry_clear_paths") + (return-type "none") +) + +(define-method add_plugin + (of-object "GstRegistry") + (c-name "gst_registry_add_plugin") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method remove_plugin + (of-object "GstRegistry") + (c-name "gst_registry_remove_plugin") + (return-type "none") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method plugin_filter + (of-object "GstRegistry") + (c-name "gst_registry_plugin_filter") + (return-type "GList*") + (parameters + '("GstPluginFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method feature_filter + (of-object "GstRegistry") + (c-name "gst_registry_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method find_plugin + (of-object "GstRegistry") + (c-name "gst_registry_find_plugin") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method find_feature + (of-object "GstRegistry") + (c-name "gst_registry_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-method load_plugin + (of-object "GstRegistry") + (c-name "gst_registry_load_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method unload_plugin + (of-object "GstRegistry") + (c-name "gst_registry_unload_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method update_plugin + (of-object "GstRegistry") + (c-name "gst_registry_update_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstregistrypool.h + +(define-function gst_registry_pool_list + (c-name "gst_registry_pool_list") + (return-type "GList*") +) + +(define-method pool_add + (of-object "GstRegistry") + (c-name "gst_registry_pool_add") + (return-type "none") + (parameters + '("guint" "priority") + ) +) + +(define-method pool_remove + (of-object "GstRegistry") + (c-name "gst_registry_pool_remove") + (return-type "none") +) + +(define-function gst_registry_pool_add_plugin + (c-name "gst_registry_pool_add_plugin") + (return-type "none") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-function gst_registry_pool_load_all + (c-name "gst_registry_pool_load_all") + (return-type "none") +) + +(define-function gst_registry_pool_plugin_filter + (c-name "gst_registry_pool_plugin_filter") + (return-type "GList*") + (parameters + '("GstPluginFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_registry_pool_feature_filter + (c-name "gst_registry_pool_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_registry_pool_plugin_list + (c-name "gst_registry_pool_plugin_list") + (return-type "GList*") +) + +(define-function gst_registry_pool_feature_list + (c-name "gst_registry_pool_feature_list") + (return-type "GList*") + (parameters + '("GType" "type") + ) +) + +(define-function gst_registry_pool_find_plugin + (c-name "gst_registry_pool_find_plugin") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_registry_pool_find_feature + (c-name "gst_registry_pool_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-function gst_registry_pool_get_prefered + (c-name "gst_registry_pool_get_prefered") + (return-type "GstRegistry*") + (parameters + '("GstRegistryFlags" "flags") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstscheduler.h + +(define-function gst_scheduler_get_type + (c-name "gst_scheduler_get_type") + (return-type "GType") +) + +(define-method setup + (of-object "GstScheduler") + (c-name "gst_scheduler_setup") + (return-type "none") +) + +(define-method reset + (of-object "GstScheduler") + (c-name "gst_scheduler_reset") + (return-type "none") +) + +(define-method add_element + (of-object "GstScheduler") + (c-name "gst_scheduler_add_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method remove_element + (of-object "GstScheduler") + (c-name "gst_scheduler_remove_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method add_scheduler + (of-object "GstScheduler") + (c-name "gst_scheduler_add_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched2") + ) +) + +(define-method remove_scheduler + (of-object "GstScheduler") + (c-name "gst_scheduler_remove_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched2") + ) +) + +(define-method state_transition + (of-object "GstScheduler") + (c-name "gst_scheduler_state_transition") + (return-type "GstElementStateReturn") + (parameters + '("GstElement*" "element") + '("gint" "transition") + ) +) + +(define-method scheduling_change + (of-object "GstScheduler") + (c-name "gst_scheduler_scheduling_change") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method lock_element + (of-object "GstScheduler") + (c-name "gst_scheduler_lock_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method unlock_element + (of-object "GstScheduler") + (c-name "gst_scheduler_unlock_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method yield + (of-object "GstScheduler") + (c-name "gst_scheduler_yield") + (return-type "gboolean") + (parameters + '("GstElement*" "element") + ) +) + +(define-method interrupt + (of-object "GstScheduler") + (c-name "gst_scheduler_interrupt") + (return-type "gboolean") + (parameters + '("GstElement*" "element") + ) +) + +(define-method error + (of-object "GstScheduler") + (c-name "gst_scheduler_error") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method pad_link + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_link") + (return-type "none") + (parameters + '("GstPad*" "srcpad") + '("GstPad*" "sinkpad") + ) +) + +(define-method pad_unlink + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_unlink") + (return-type "none") + (parameters + '("GstPad*" "srcpad") + '("GstPad*" "sinkpad") + ) +) + +(define-method pad_select + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_select") + (return-type "GstPad*") + (parameters + '("GList*" "padlist") + ) +) + +(define-method clock_wait + (of-object "GstScheduler") + (c-name "gst_scheduler_clock_wait") + (return-type "GstClockReturn") + (parameters + '("GstElement*" "element") + '("GstClockID" "id") + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method iterate + (of-object "GstScheduler") + (c-name "gst_scheduler_iterate") + (return-type "gboolean") +) + +(define-method use_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_use_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method set_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_set_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method get_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_get_clock") + (return-type "GstClock*") +) + +(define-method auto_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_auto_clock") + (return-type "none") +) + +(define-method show + (of-object "GstScheduler") + (c-name "gst_scheduler_show") + (return-type "none") +) + +(define-function gst_scheduler_factory_get_type + (c-name "gst_scheduler_factory_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_factory_new + (c-name "gst_scheduler_factory_new") + (is-constructor-of "GstSchedulerFactory") + (return-type "GstSchedulerFactory*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "longdesc") + '("GType" "type") + ) +) + +(define-method destroy + (of-object "GstSchedulerFactory") + (c-name "gst_scheduler_factory_destroy") + (return-type "none") +) + +(define-function gst_scheduler_factory_find + (c-name "gst_scheduler_factory_find") + (return-type "GstSchedulerFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method create + (of-object "GstSchedulerFactory") + (c-name "gst_scheduler_factory_create") + (return-type "GstScheduler*") + (parameters + '("GstElement*" "parent") + ) +) + +(define-function gst_scheduler_factory_make + (c-name "gst_scheduler_factory_make") + (return-type "GstScheduler*") + (parameters + '("const-gchar*" "name") + '("GstElement*" "parent") + ) +) + +(define-function gst_scheduler_factory_set_default_name + (c-name "gst_scheduler_factory_set_default_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_scheduler_factory_get_default_name + (c-name "gst_scheduler_factory_get_default_name") + (return-type "const-gchar*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gststructure.h + +(define-function gst_structure_get_type + (c-name "gst_structure_get_type") + (return-type "GType") +) + +(define-function _gst_structure_initialize + (c-name "_gst_structure_initialize") + (return-type "none") +) + +(define-function gst_structure_empty_new + (c-name "gst_structure_empty_new") + (is-constructor-of "GstStructureEmpty") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_structure_id_empty_new + (c-name "gst_structure_id_empty_new") + (is-constructor-of "GstStructureIdEmpty") + (return-type "GstStructure*") + (parameters + '("GQuark" "quark") + ) +) + +(define-function gst_structure_new + (c-name "gst_structure_new") + (is-constructor-of "GstStructure") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "firstfield") + ) + (varargs #t) +) + +(define-function gst_structure_new_valist + (c-name "gst_structure_new_valist") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "firstfield") + '("va_list" "varargs") + ) +) + +(define-method copy + (of-object "GstStructure") + (c-name "gst_structure_copy") + (return-type "GstStructure*") +) + +(define-method free + (of-object "GstStructure") + (c-name "gst_structure_free") + (return-type "none") +) + +(define-method get_name + (of-object "GstStructure") + (c-name "gst_structure_get_name") + (return-type "const-gchar*") +) + +(define-method set_name + (of-object "GstStructure") + (c-name "gst_structure_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method id_set_value + (of-object "GstStructure") + (c-name "gst_structure_id_set_value") + (return-type "none") + (parameters + '("GQuark" "field") + '("const-GValue*" "value") + ) +) + +(define-method set_value + (of-object "GstStructure") + (c-name "gst_structure_set_value") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("const-GValue*" "value") + ) +) + +(define-method set + (of-object "GstStructure") + (c-name "gst_structure_set") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) + (varargs #t) +) + +(define-method set_valist + (of-object "GstStructure") + (c-name "gst_structure_set_valist") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("va_list" "varargs") + ) +) + +(define-method id_get_value + (of-object "GstStructure") + (c-name "gst_structure_id_get_value") + (return-type "const-GValue*") + (parameters + '("GQuark" "field") + ) +) + +(define-method get_value + (of-object "GstStructure") + (c-name "gst_structure_get_value") + (return-type "const-GValue*") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method remove_field + (of-object "GstStructure") + (c-name "gst_structure_remove_field") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method remove_fields + (of-object "GstStructure") + (c-name "gst_structure_remove_fields") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) + (varargs #t) +) + +(define-method remove_fields_valist + (of-object "GstStructure") + (c-name "gst_structure_remove_fields_valist") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("va_list" "varargs") + ) +) + +(define-method remove_all_fields + (of-object "GstStructure") + (c-name "gst_structure_remove_all_fields") + (return-type "none") +) + +(define-method get_field_type + (of-object "GstStructure") + (c-name "gst_structure_get_field_type") + (return-type "GType") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method foreach + (of-object "GstStructure") + (c-name "gst_structure_foreach") + (return-type "gboolean") + (parameters + '("GstStructureForeachFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method n_fields + (of-object "GstStructure") + (c-name "gst_structure_n_fields") + (return-type "gint") +) + +(define-method has_field + (of-object "GstStructure") + (c-name "gst_structure_has_field") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method has_field_typed + (of-object "GstStructure") + (c-name "gst_structure_has_field_typed") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("GType" "type") + ) +) + +(define-method get_boolean + (of-object "GstStructure") + (c-name "gst_structure_get_boolean") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gboolean*" "value") + ) +) + +(define-method get_int + (of-object "GstStructure") + (c-name "gst_structure_get_int") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gint*" "value") + ) +) + +(define-method get_fourcc + (of-object "GstStructure") + (c-name "gst_structure_get_fourcc") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("guint32*" "value") + ) +) + +(define-method get_double + (of-object "GstStructure") + (c-name "gst_structure_get_double") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gdouble*" "value") + ) +) + +(define-method get_string + (of-object "GstStructure") + (c-name "gst_structure_get_string") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method to_string + (of-object "GstStructure") + (c-name "gst_structure_to_string") + (return-type "gchar*") +) + +(define-function gst_structure_from_string + (c-name "gst_structure_from_string") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "string") + '("gchar**" "end") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstsystemclock.h + +(define-function gst_system_clock_get_type + (c-name "gst_system_clock_get_type") + (return-type "GType") +) + +(define-function gst_system_clock_obtain + (c-name "gst_system_clock_obtain") + (return-type "GstClock*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttag.h + +(define-function _gst_tag_initialize + (c-name "_gst_tag_initialize") + (return-type "none") +) + +(define-function gst_tag_list_get_type + (c-name "gst_tag_list_get_type") + (return-type "GType") +) + +(define-function gst_tag_register + (c-name "gst_tag_register") + (return-type "none") + (parameters + '("gchar*" "name") + '("GstTagFlag" "flag") + '("GType" "type") + '("gchar*" "nick") + '("gchar*" "blurb") + '("GstTagMergeFunc" "func") + ) +) + +(define-function gst_tag_merge_use_first + (c-name "gst_tag_merge_use_first") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function gst_tag_merge_strings_with_comma + (c-name "gst_tag_merge_strings_with_comma") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function gst_tag_exists + (c-name "gst_tag_exists") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_type + (c-name "gst_tag_get_type") + (return-type "GType") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_nick + (c-name "gst_tag_get_nick") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_description + (c-name "gst_tag_get_description") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_is_fixed + (c-name "gst_tag_is_fixed") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_list_new + (c-name "gst_tag_list_new") + (is-constructor-of "GstTagList") + (return-type "GstTagList*") +) + +(define-function gst_is_tag_list + (c-name "gst_is_tag_list") + (return-type "gboolean") + (parameters + '("gconstpointer" "p") + ) +) + +(define-method copy + (of-object "GstTagList") + (c-name "gst_tag_list_copy") + (return-type "GstTagList*") +) + +(define-method insert + (of-object "GstTagList") + (c-name "gst_tag_list_insert") + (return-type "none") + (parameters + '("const-GstTagList*" "from") + '("GstTagMergeMode" "mode") + ) +) + +(define-method merge + (of-object "GstTagList") + (c-name "gst_tag_list_merge") + (return-type "GstTagList*") + (parameters + '("const-GstTagList*" "list2") + '("GstTagMergeMode" "mode") + ) +) + +(define-method free + (of-object "GstTagList") + (c-name "gst_tag_list_free") + (return-type "none") +) + +(define-method get_tag_size + (of-object "GstTagList") + (c-name "gst_tag_list_get_tag_size") + (return-type "guint") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-method add + (of-object "GstTagList") + (c-name "gst_tag_list_add") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_values + (of-object "GstTagList") + (c-name "gst_tag_list_add_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_valist + (of-object "GstTagList") + (c-name "gst_tag_list_add_valist") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method add_valist_values + (of-object "GstTagList") + (c-name "gst_tag_list_add_valist_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method remove_tag + (of-object "GstTagList") + (c-name "gst_tag_list_remove_tag") + (return-type "none") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-method foreach + (of-object "GstTagList") + (c-name "gst_tag_list_foreach") + (return-type "none") + (parameters + '("GstTagForeachFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method get_value_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_value_index") + (return-type "const-GValue*") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + ) +) + +(define-function gst_tag_list_copy_value + (c-name "gst_tag_list_copy_value") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GstTagList*" "list") + '("const-gchar*" "tag") + ) +) + +(define-method get_char + (of-object "GstTagList") + (c-name "gst_tag_list_get_char") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gchar*" "value") + ) +) + +(define-method get_char_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_char_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gchar*" "value") + ) +) + +(define-method get_uchar + (of-object "GstTagList") + (c-name "gst_tag_list_get_uchar") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guchar*" "value") + ) +) + +(define-method get_uchar_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uchar_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guchar*" "value") + ) +) + +(define-method get_boolean + (of-object "GstTagList") + (c-name "gst_tag_list_get_boolean") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gboolean*" "value") + ) +) + +(define-method get_boolean_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_boolean_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gboolean*" "value") + ) +) + +(define-method get_int + (of-object "GstTagList") + (c-name "gst_tag_list_get_int") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gint*" "value") + ) +) + +(define-method get_int_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_int_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gint*" "value") + ) +) + +(define-method get_uint + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint*" "value") + ) +) + +(define-method get_uint_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guint*" "value") + ) +) + +(define-method get_long + (of-object "GstTagList") + (c-name "gst_tag_list_get_long") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("glong*" "value") + ) +) + +(define-method get_long_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_long_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("glong*" "value") + ) +) + +(define-method get_ulong + (of-object "GstTagList") + (c-name "gst_tag_list_get_ulong") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gulong*" "value") + ) +) + +(define-method get_ulong_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_ulong_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gulong*" "value") + ) +) + +(define-method get_int64 + (of-object "GstTagList") + (c-name "gst_tag_list_get_int64") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gint64*" "value") + ) +) + +(define-method get_int64_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_int64_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gint64*" "value") + ) +) + +(define-method get_uint64 + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint64") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint64*" "value") + ) +) + +(define-method get_uint64_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint64_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guint64*" "value") + ) +) + +(define-method get_float + (of-object "GstTagList") + (c-name "gst_tag_list_get_float") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gfloat*" "value") + ) +) + +(define-method get_float_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_float_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gfloat*" "value") + ) +) + +(define-method get_double + (of-object "GstTagList") + (c-name "gst_tag_list_get_double") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gdouble*" "value") + ) +) + +(define-method get_double_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_double_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gdouble*" "value") + ) +) + +(define-method get_string + (of-object "GstTagList") + (c-name "gst_tag_list_get_string") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gchar**" "value") + ) +) + +(define-method get_string_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_string_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gchar**" "value") + ) +) + +(define-method get_pointer + (of-object "GstTagList") + (c-name "gst_tag_list_get_pointer") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gpointer*" "value") + ) +) + +(define-method get_pointer_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_pointer_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gpointer*" "value") + ) +) + +(define-function gst_event_new_tag + (c-name "gst_event_new_tag") + (return-type "GstEvent*") + (parameters + '("GstTagList*" "list") + ) +) + +(define-method tag_get_list + (of-object "GstEvent") + (c-name "gst_event_tag_get_list") + (return-type "GstTagList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttaginterface.h + +(define-function gst_tag_setter_get_type + (c-name "gst_tag_setter_get_type") + (return-type "GType") +) + +(define-method merge + (of-object "GstTagSetter") + (c-name "gst_tag_setter_merge") + (return-type "none") + (parameters + '("const-GstTagList*" "list") + '("GstTagMergeMode" "mode") + ) +) + +(define-method add + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_values + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_valist + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_valist") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method add_valist_values + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_valist_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method get_list + (of-object "GstTagSetter") + (c-name "gst_tag_setter_get_list") + (return-type "const-GstTagList*") +) + +(define-method set_merge_mode + (of-object "GstTagSetter") + (c-name "gst_tag_setter_set_merge_mode") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + ) +) + +(define-method get_merge_mode + (of-object "GstTagSetter") + (c-name "gst_tag_setter_get_merge_mode") + (return-type "GstTagMergeMode") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstthread.h + +(define-function gst_thread_get_type + (c-name "gst_thread_get_type") + (return-type "GType") +) + +(define-function gst_thread_new + (c-name "gst_thread_new") + (is-constructor-of "GstThread") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method set_priority + (of-object "GstThread") + (c-name "gst_thread_set_priority") + (return-type "none") + (parameters + '("GThreadPriority" "priority") + ) +) + +(define-function gst_thread_get_current + (c-name "gst_thread_get_current") + (return-type "GstThread*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttrace.h + +(define-function gst_trace_new + (c-name "gst_trace_new") + (is-constructor-of "GstTrace") + (return-type "GstTrace*") + (parameters + '("gchar*" "filename") + '("gint" "size") + ) +) + +(define-method destroy + (of-object "GstTrace") + (c-name "gst_trace_destroy") + (return-type "none") +) + +(define-method flush + (of-object "GstTrace") + (c-name "gst_trace_flush") + (return-type "none") +) + +(define-method text_flush + (of-object "GstTrace") + (c-name "gst_trace_text_flush") + (return-type "none") +) + +(define-method set_default + (of-object "GstTrace") + (c-name "gst_trace_set_default") + (return-type "none") +) + +(define-method _add_entry + (of-object "GstTrace") + (c-name "_gst_trace_add_entry") + (return-type "none") + (parameters + '("guint32" "seq") + '("guint32" "data") + '("gchar*" "msg") + ) +) + +(define-function gst_trace_read_tsc + (c-name "gst_trace_read_tsc") + (return-type "none") + (parameters + '("gint64*" "dst") + ) +) + +(define-function gst_alloc_trace_available + (c-name "gst_alloc_trace_available") + (return-type "gboolean") +) + +(define-function gst_alloc_trace_list + (c-name "gst_alloc_trace_list") + (return-type "const-GList*") +) + +(define-function _gst_alloc_trace_register + (c-name "_gst_alloc_trace_register") + (return-type "GstAllocTrace*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_alloc_trace_live_all + (c-name "gst_alloc_trace_live_all") + (return-type "int") +) + +(define-function gst_alloc_trace_print_all + (c-name "gst_alloc_trace_print_all") + (return-type "none") +) + +(define-function gst_alloc_trace_set_flags_all + (c-name "gst_alloc_trace_set_flags_all") + (return-type "none") + (parameters + '("GstAllocTraceFlags" "flags") + ) +) + +(define-function gst_alloc_trace_get + (c-name "gst_alloc_trace_get") + (return-type "GstAllocTrace*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method print + (of-object "GstAllocTrace") + (c-name "gst_alloc_trace_print") + (return-type "none") +) + +(define-method set_flags + (of-object "GstAllocTrace") + (c-name "gst_alloc_trace_set_flags") + (return-type "none") + (parameters + '("GstAllocTraceFlags" "flags") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttrashstack.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttypefind.h + +(define-method peek + (of-object "GstTypeFind") + (c-name "gst_type_find_peek") + (return-type "guint8*") + (parameters + '("gint64" "offset") + '("guint" "size") + ) +) + +(define-method suggest + (of-object "GstTypeFind") + (c-name "gst_type_find_suggest") + (return-type "none") + (parameters + '("guint" "probability") + '("const-GstCaps*" "caps") + ) +) + +(define-method get_length + (of-object "GstTypeFind") + (c-name "gst_type_find_get_length") + (return-type "guint64") +) + +(define-function gst_type_find_register + (c-name "gst_type_find_register") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + '("const-gchar*" "name") + '("guint" "rank") + '("GstTypeFindFunction" "func") + '("gchar**" "extensions") + '("const-GstCaps*" "possible_caps") + '("gpointer" "data") + ) +) + +(define-function gst_type_find_factory_get_type + (c-name "gst_type_find_factory_get_type") + (return-type "GType") +) + +(define-function gst_type_find_factory_get_list + (c-name "gst_type_find_factory_get_list") + (return-type "GList*") +) + +(define-method get_extensions + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_get_extensions") + (return-type "gchar**") +) + +(define-method get_caps + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_get_caps") + (return-type "const-GstCaps*") +) + +(define-method call_function + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_call_function") + (return-type "none") + (parameters + '("GstTypeFind*" "find") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttypes.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsturi.h + +(define-function gst_uri_protocol_is_valid + (c-name "gst_uri_protocol_is_valid") + (return-type "gboolean") + (parameters + '("const-gchar*" "protocol") + ) +) + +(define-function gst_uri_is_valid + (c-name "gst_uri_is_valid") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_get_protocol + (c-name "gst_uri_get_protocol") + (return-type "gchar*") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_get_location + (c-name "gst_uri_get_location") + (return-type "gchar*") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_construct + (c-name "gst_uri_construct") + (return-type "gchar*") + (parameters + '("const-gchar*" "protocol") + '("const-gchar*" "location") + ) +) + +(define-function gst_element_make_from_uri + (c-name "gst_element_make_from_uri") + (return-type "GstElement*") + (parameters + '("const-GstURIType" "type") + '("const-gchar*" "uri") + '("const-gchar*" "elementname") + ) +) + +(define-function gst_uri_handler_get_type + (c-name "gst_uri_handler_get_type") + (return-type "GType") +) + +(define-method get_uri_type + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_uri_type") + (return-type "guint") +) + +(define-method get_protocols + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_protocols") + (return-type "gchar**") +) + +(define-method get_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_uri") + (return-type "const-gchar*") +) + +(define-method set_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_set_uri") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-method new_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_new_uri") + (return-type "none") + (parameters + '("const-gchar*" "uri") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsturitype.h + +(define-function gst_uri_get_uri_type + (c-name "gst_uri_get_uri_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstutils.h + +(define-function gst_util_set_value_from_string + (c-name "gst_util_set_value_from_string") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-gchar*" "value_str") + ) +) + +(define-function gst_util_set_object_arg + (c-name "gst_util_set_object_arg") + (return-type "none") + (parameters + '("GObject*" "object") + '("const-gchar*" "name") + '("const-gchar*" "value") + ) +) + +(define-function gst_util_dump_mem + (c-name "gst_util_dump_mem") + (return-type "none") + (parameters + '("guchar*" "mem") + '("guint" "size") + ) +) + +(define-function gst_print_pad_caps + (c-name "gst_print_pad_caps") + (return-type "none") + (parameters + '("GString*" "buf") + '("gint" "indent") + '("GstPad*" "pad") + ) +) + +(define-function gst_print_element_args + (c-name "gst_print_element_args") + (return-type "none") + (parameters + '("GString*" "buf") + '("gint" "indent") + '("GstElement*" "element") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstvalue.h + +(define-function gst_value_list_prepend_value + (c-name "gst_value_list_prepend_value") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GValue*" "prepend_value") + ) +) + +(define-function gst_value_list_append_value + (c-name "gst_value_list_append_value") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GValue*" "append_value") + ) +) + +(define-function gst_value_list_get_size + (c-name "gst_value_list_get_size") + (return-type "guint") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_list_get_value + (c-name "gst_value_list_get_value") + (return-type "const-GValue*") + (parameters + '("const-GValue*" "value") + '("guint" "index") + ) +) + +(define-function gst_value_list_concat + (c-name "gst_value_list_concat") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_set_fourcc + (c-name "gst_value_set_fourcc") + (return-type "none") + (parameters + '("GValue*" "value") + '("guint32" "fourcc") + ) +) + +(define-function gst_value_get_fourcc + (c-name "gst_value_get_fourcc") + (return-type "guint32") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_int_range + (c-name "gst_value_set_int_range") + (return-type "none") + (parameters + '("GValue*" "value") + '("int" "start") + '("int" "end") + ) +) + +(define-function gst_value_get_int_range_min + (c-name "gst_value_get_int_range_min") + (return-type "int") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_int_range_max + (c-name "gst_value_get_int_range_max") + (return-type "int") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_double_range + (c-name "gst_value_set_double_range") + (return-type "none") + (parameters + '("GValue*" "value") + '("double" "start") + '("double" "end") + ) +) + +(define-function gst_value_get_double_range_min + (c-name "gst_value_get_double_range_min") + (return-type "double") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_double_range_max + (c-name "gst_value_get_double_range_max") + (return-type "double") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_caps + (c-name "gst_value_get_caps") + (return-type "const-GstCaps*") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_caps + (c-name "gst_value_set_caps") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GstCaps*" "caps") + ) +) + +(define-function gst_value_can_compare + (c-name "gst_value_can_compare") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_compare + (c-name "gst_value_compare") + (return-type "int") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_can_union + (c-name "gst_value_can_union") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_union + (c-name "gst_value_union") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_register_union_func + (c-name "gst_value_register_union_func") + (return-type "none") + (parameters + '("GType" "type1") + '("GType" "type2") + '("GstValueUnionFunc" "func") + ) +) + +(define-function gst_value_can_intersect + (c-name "gst_value_can_intersect") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_intersect + (c-name "gst_value_intersect") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_register_intersect_func + (c-name "gst_value_register_intersect_func") + (return-type "none") + (parameters + '("GType" "type1") + '("GType" "type2") + '("GstValueIntersectFunc" "func") + ) +) + +(define-function gst_value_register + (c-name "gst_value_register") + (return-type "none") + (parameters + '("const-GstValueTable*" "table") + ) +) + +(define-function gst_value_init_and_copy + (c-name "gst_value_init_and_copy") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function _gst_value_initialize + (c-name "_gst_value_initialize") + (return-type "none") +) + +(define-function gst_value_serialize + (c-name "gst_value_serialize") + (return-type "gchar*") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_deserialize + (c-name "gst_value_deserialize") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-gchar*" "src") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstversion.h + +(define-function gst_version + (c-name "gst_version") + (return-type "none") + (parameters + '("guint*" "major") + '("guint*" "minor") + '("guint*" "micro") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstxml.h + +(define-function gst_xml_get_type + (c-name "gst_xml_get_type") + (return-type "GType") +) + +(define-function gst_xml_write + (c-name "gst_xml_write") + (return-type "xmlDocPtr") + (parameters + '("GstElement*" "element") + ) +) + +(define-function gst_xml_write_file + (c-name "gst_xml_write_file") + (return-type "gint") + (parameters + '("GstElement*" "element") + '("FILE*" "out") + ) +) + +(define-function gst_xml_new + (c-name "gst_xml_new") + (is-constructor-of "GstXml") + (return-type "GstXML*") +) + +(define-method parse_doc + (of-object "GstXML") + (c-name "gst_xml_parse_doc") + (return-type "gboolean") + (parameters + '("xmlDocPtr" "doc") + '("const-guchar*" "root") + ) +) + +(define-method parse_file + (of-object "GstXML") + (c-name "gst_xml_parse_file") + (return-type "gboolean") + (parameters + '("const-guchar*" "fname") + '("const-guchar*" "root") + ) +) + +(define-method parse_memory + (of-object "GstXML") + (c-name "gst_xml_parse_memory") + (return-type "gboolean") + (parameters + '("guchar*" "buffer") + '("guint" "size") + '("const-gchar*" "root") + ) +) + +(define-method get_element + (of-object "GstXML") + (c-name "gst_xml_get_element") + (return-type "GstElement*") + (parameters + '("const-guchar*" "name") + ) +) + +(define-method get_topelements + (of-object "GstXML") + (c-name "gst_xml_get_topelements") + (return-type "GList*") +) + +(define-function gst_xml_make_element + (c-name "gst_xml_make_element") + (return-type "GstElement*") + (parameters + '("xmlNodePtr" "cur") + '("GstObject*" "parent") + ) +) + + +;; -*- scheme -*- +;; +;; Boxed types +;; + +(define-boxed Buffer + (in-module "Gst") + (c-name "GstBuffer") + (gtype-id "GST_TYPE_BUFFER") +) + +(define-boxed Caps + (in-module "Gst") + (c-name "GstCaps") + (gtype-id "GST_TYPE_CAPS") +) + +(define-boxed Event + (in-module "Gst") + (c-name "GstEvent") + (gtype-id "GST_TYPE_EVENT") +) + +;; +;; Accelerate common GstBin iterate loop +;; + +(define-function iterate_bin_all + (c-name "iterate_bin_all") + (return-type "none") + (parameters + '("GstBin*" "bin") + ) +) + +(define-function add_iterate_bin + (c-name "add_iterate_bin") + (return-type "guint") + (parameters + '("GstBin*" "bin") + ) +) + +(define-function remove_iterate_bin + (c-name "remove_iterate_bin") + (return-type "none") + (parameters + '("guint" "id") + ) +) + +;; +;; HACK +;; + +(define-method get_data + (of-object "GstBuffer") + (c-name "gst_buffer_get_data") + (return-type "char*") +) + +(define-method set_data + (of-object "GstBuffer") + (c-name "gst_buffer_set_data") + (return-type "none") + (parameters + '("char*" "data") + ) +) + + +;; +;; 0.7 Boxed types +;; + +(define-boxed Structure + (in-module "Gst") + (c-name "GstStructure") + (gtype-id "GST_TYPE_STRUCTURE") +) + +(define-boxed TagList + (in-module "Gst") + (c-name "GstTagList") + (gtype-id "GST_TYPE_TAG_LIST") +) diff --git a/gstreamer/gstreamer.defs b/gstreamer/gstreamer.defs new file mode 100644 index 0000000000..0dafc62c87 --- /dev/null +++ b/gstreamer/gstreamer.defs @@ -0,0 +1,6968 @@ +;; -*- scheme -*- +; object definitions ... +(define-object Object + (in-module "Gst") + (parent "GObject") + (c-name "GstObject") + (gtype-id "GST_TYPE_OBJECT") +) + +(define-object Index + (in-module "Gst") + (parent "GstObject") + (c-name "GstIndex") + (gtype-id "GST_TYPE_INDEX") +) + +(define-object Element + (in-module "Gst") + (parent "GstObject") + (c-name "GstElement") + (gtype-id "GST_TYPE_ELEMENT") +) + +(define-object Bin + (in-module "Gst") + (parent "GstElement") + (c-name "GstBin") + (gtype-id "GST_TYPE_BIN") +) + +(define-object Clock + (in-module "Gst") + (parent "GstObject") + (c-name "GstClock") + (gtype-id "GST_TYPE_CLOCK") +) + +(define-object Pad + (in-module "Gst") + (parent "GstObject") + (c-name "GstPad") + (gtype-id "GST_TYPE_PAD") +) + +(define-object GhostPad + (in-module "Gst") + (parent "GstPad") + (c-name "GstGhostPad") + (gtype-id "GST_TYPE_GHOST_PAD") +) + +(define-object PadTemplate + (in-module "Gst") + (parent "GstObject") + (c-name "GstPadTemplate") + (gtype-id "GST_TYPE_PAD_TEMPLATE") +) + +(define-object Pipeline + (in-module "Gst") + (parent "GstBin") + (c-name "GstPipeline") + (gtype-id "GST_TYPE_PIPELINE") +) + +(define-object PluginFeature + (in-module "Gst") + (parent "GObject") + (c-name "GstPluginFeature") + (gtype-id "GST_TYPE_PLUGIN_FEATURE") +) + +(define-object IndexFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstIndexFactory") + (gtype-id "GST_TYPE_INDEX_FACTORY") +) + +(define-object ElementFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstElementFactory") + (gtype-id "GST_TYPE_ELEMENT_FACTORY") +) + +(define-object Queue + (in-module "Gst") + (parent "GstElement") + (c-name "GstQueue") + (gtype-id "GST_TYPE_QUEUE") +) + +(define-object RealPad + (in-module "Gst") + (parent "GstPad") + (c-name "GstRealPad") + (gtype-id "GST_TYPE_REAL_PAD") +) + +(define-object Registry + (in-module "Gst") + (parent "GObject") + (c-name "GstRegistry") + (gtype-id "GST_TYPE_REGISTRY") +) + +(define-object Scheduler + (in-module "Gst") + (parent "GstObject") + (c-name "GstScheduler") + (gtype-id "GST_TYPE_SCHEDULER") +) + +(define-object SchedulerFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstSchedulerFactory") + (gtype-id "GST_TYPE_SCHEDULER_FACTORY") +) + +(define-object SystemClock + (in-module "Gst") + (parent "GstClock") + (c-name "GstSystemClock") + (gtype-id "GST_TYPE_SYSTEM_CLOCK") +) + +(define-object Thread + (in-module "Gst") + (parent "GstBin") + (c-name "GstThread") + (gtype-id "GST_TYPE_THREAD") +) + +(define-object TypeFindFactory + (in-module "Gst") + (parent "GstPluginFeature") + (c-name "GstTypeFindFactory") + (gtype-id "GST_TYPE_TYPE_FIND_FACTORY") +) + +(define-object XML + (in-module "Gst") + (parent "GstObject") + (c-name "GstXML") + (gtype-id "GST_TYPE_XML") +) + +;; Enumerations and flags ... + +(define-enum BinFlags + (in-module "Gst") + (c-name "GstBinFlags") + (gtype-id "GST_TYPE_BIN_FLAGS") + (values + '("flag-manager" "GST_BIN_FLAG_MANAGER") + '("self-schedulable" "GST_BIN_SELF_SCHEDULABLE") + '("flag-prefer-cothreads" "GST_BIN_FLAG_PREFER_COTHREADS") + '("flag-fixed-clock" "GST_BIN_FLAG_FIXED_CLOCK") + '("flag-last" "GST_BIN_FLAG_LAST") + ) +) + +(define-enum BufferFlag + (in-module "Gst") + (c-name "GstBufferFlag") + (gtype-id "GST_TYPE_BUFFER_FLAG") + (values + '("readonly" "GST_BUFFER_READONLY") + '("subbuffer" "GST_BUFFER_SUBBUFFER") + '("original" "GST_BUFFER_ORIGINAL") + '("dontfree" "GST_BUFFER_DONTFREE") + '("key-unit" "GST_BUFFER_KEY_UNIT") + '("dontkeep" "GST_BUFFER_DONTKEEP") + '("flag-last" "GST_BUFFER_FLAG_LAST") + ) +) + +(define-enum ClockEntryStatus + (in-module "Gst") + (c-name "GstClockEntryStatus") + (gtype-id "GST_TYPE_CLOCK_ENTRY_STATUS") + (values + '("ok" "GST_CLOCK_ENTRY_OK") + '("early" "GST_CLOCK_ENTRY_EARLY") + '("restart" "GST_CLOCK_ENTRY_RESTART") + ) +) + +(define-enum ClockEntryType + (in-module "Gst") + (c-name "GstClockEntryType") + (gtype-id "GST_TYPE_CLOCK_ENTRY_TYPE") + (values + '("single" "GST_CLOCK_ENTRY_SINGLE") + '("periodic" "GST_CLOCK_ENTRY_PERIODIC") + ) +) + +(define-enum ClockReturn + (in-module "Gst") + (c-name "GstClockReturn") + (gtype-id "GST_TYPE_CLOCK_RETURN") + (values + '("stopped" "GST_CLOCK_STOPPED") + '("timeout" "GST_CLOCK_TIMEOUT") + '("early" "GST_CLOCK_EARLY") + '("error" "GST_CLOCK_ERROR") + '("unsupported" "GST_CLOCK_UNSUPPORTED") + ) +) + +(define-flags ClockFlags + (in-module "Gst") + (c-name "GstClockFlags") + (gtype-id "GST_TYPE_CLOCK_FLAGS") + (values + '("do-single-sync" "GST_CLOCK_FLAG_CAN_DO_SINGLE_SYNC") + '("do-single-async" "GST_CLOCK_FLAG_CAN_DO_SINGLE_ASYNC") + '("do-periodic-sync" "GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC") + '("do-periodic-async" "GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC") + '("set-resolution" "GST_CLOCK_FLAG_CAN_SET_RESOLUTION") + '("set-speed" "GST_CLOCK_FLAG_CAN_SET_SPEED") + ) +) + +(define-flags CPUFlags + (in-module "Gst") + (c-name "GstCPUFlags") + (gtype-id "GST_TYPE_CPU_FLAGS") + (values + '("mmx" "GST_CPU_FLAG_MMX") + '("sse" "GST_CPU_FLAG_SSE") + '("mmxext" "GST_CPU_FLAG_MMXEXT") + '("3dnow" "GST_CPU_FLAG_3DNOW") + ) +) + +(define-enum DataFlags + (in-module "Gst") + (c-name "GstDataFlags") + (gtype-id "GST_TYPE_DATA_FLAGS") + (values + '("readonly" "GST_DATA_READONLY") + '("flag-last" "GST_DATA_FLAG_LAST") + ) +) + +(define-enum ElementFlags + (in-module "Gst") + (c-name "GstElementFlags") + (gtype-id "GST_TYPE_ELEMENT_FLAGS") + (values + '("complex" "GST_ELEMENT_COMPLEX") + '("decoupled" "GST_ELEMENT_DECOUPLED") + '("thread-suggested" "GST_ELEMENT_THREAD_SUGGESTED") + '("infinite-loop" "GST_ELEMENT_INFINITE_LOOP") + '("new-loopfunc" "GST_ELEMENT_NEW_LOOPFUNC") + '("event-aware" "GST_ELEMENT_EVENT_AWARE") + '("use-threadsafe-properties" "GST_ELEMENT_USE_THREADSAFE_PROPERTIES") + '("scheduler-private1" "GST_ELEMENT_SCHEDULER_PRIVATE1") + '("scheduler-private2" "GST_ELEMENT_SCHEDULER_PRIVATE2") + '("locked-state" "GST_ELEMENT_LOCKED_STATE") + '("in-error" "GST_ELEMENT_IN_ERROR") + '("flag-last" "GST_ELEMENT_FLAG_LAST") + ) +) + +(define-enum CoreError + (in-module "Gst") + (c-name "GstCoreError") + (gtype-id "GST_TYPE_CORE_ERROR") + (values + '("failed" "GST_CORE_ERROR_FAILED") + '("too-lazy" "GST_CORE_ERROR_TOO_LAZY") + '("not-implemented" "GST_CORE_ERROR_NOT_IMPLEMENTED") + '("state-change" "GST_CORE_ERROR_STATE_CHANGE") + '("pad" "GST_CORE_ERROR_PAD") + '("thread" "GST_CORE_ERROR_THREAD") + '("scheduler" "GST_CORE_ERROR_SCHEDULER") + '("negotiation" "GST_CORE_ERROR_NEGOTIATION") + '("event" "GST_CORE_ERROR_EVENT") + '("seek" "GST_CORE_ERROR_SEEK") + '("caps" "GST_CORE_ERROR_CAPS") + '("tag" "GST_CORE_ERROR_TAG") + '("num-errors" "GST_CORE_ERROR_NUM_ERRORS") + ) +) + +(define-enum LibraryError + (in-module "Gst") + (c-name "GstLibraryError") + (gtype-id "GST_TYPE_LIBRARY_ERROR") + (values + '("failed" "GST_LIBRARY_ERROR_FAILED") + '("too-lazy" "GST_LIBRARY_ERROR_TOO_LAZY") + '("init" "GST_LIBRARY_ERROR_INIT") + '("shutdown" "GST_LIBRARY_ERROR_SHUTDOWN") + '("settings" "GST_LIBRARY_ERROR_SETTINGS") + '("encode" "GST_LIBRARY_ERROR_ENCODE") + '("num-errors" "GST_LIBRARY_ERROR_NUM_ERRORS") + ) +) + +(define-enum ResourceError + (in-module "Gst") + (c-name "GstResourceError") + (gtype-id "GST_TYPE_RESOURCE_ERROR") + (values + '("failed" "GST_RESOURCE_ERROR_FAILED") + '("too-lazy" "GST_RESOURCE_ERROR_TOO_LAZY") + '("not-found" "GST_RESOURCE_ERROR_NOT_FOUND") + '("busy" "GST_RESOURCE_ERROR_BUSY") + '("open-read" "GST_RESOURCE_ERROR_OPEN_READ") + '("open-write" "GST_RESOURCE_ERROR_OPEN_WRITE") + '("open-read-write" "GST_RESOURCE_ERROR_OPEN_READ_WRITE") + '("close" "GST_RESOURCE_ERROR_CLOSE") + '("read" "GST_RESOURCE_ERROR_READ") + '("write" "GST_RESOURCE_ERROR_WRITE") + '("seek" "GST_RESOURCE_ERROR_SEEK") + '("sync" "GST_RESOURCE_ERROR_SYNC") + '("settings" "GST_RESOURCE_ERROR_SETTINGS") + '("num-errors" "GST_RESOURCE_ERROR_NUM_ERRORS") + ) +) + +(define-enum StreamError + (in-module "Gst") + (c-name "GstStreamError") + (gtype-id "GST_TYPE_STREAM_ERROR") + (values + '("failed" "GST_STREAM_ERROR_FAILED") + '("too-lazy" "GST_STREAM_ERROR_TOO_LAZY") + '("not-implemented" "GST_STREAM_ERROR_NOT_IMPLEMENTED") + '("type-not-found" "GST_STREAM_ERROR_TYPE_NOT_FOUND") + '("wrong-type" "GST_STREAM_ERROR_WRONG_TYPE") + '("codec-not-found" "GST_STREAM_ERROR_CODEC_NOT_FOUND") + '("decode" "GST_STREAM_ERROR_DECODE") + '("encode" "GST_STREAM_ERROR_ENCODE") + '("demux" "GST_STREAM_ERROR_DEMUX") + '("mux" "GST_STREAM_ERROR_MUX") + '("format" "GST_STREAM_ERROR_FORMAT") + '("num-errors" "GST_STREAM_ERROR_NUM_ERRORS") + ) +) + +(define-enum EventType + (in-module "Gst") + (c-name "GstEventType") + (gtype-id "GST_TYPE_EVENT_TYPE") + (values + '("unknown" "GST_EVENT_UNKNOWN") + '("eos" "GST_EVENT_EOS") + '("flush" "GST_EVENT_FLUSH") + '("empty" "GST_EVENT_EMPTY") + '("discontinuous" "GST_EVENT_DISCONTINUOUS") + '("qos" "GST_EVENT_QOS") + '("seek" "GST_EVENT_SEEK") + '("seek-segment" "GST_EVENT_SEEK_SEGMENT") + '("segment-done" "GST_EVENT_SEGMENT_DONE") + '("size" "GST_EVENT_SIZE") + '("rate" "GST_EVENT_RATE") + '("filler" "GST_EVENT_FILLER") + '("ts-offset" "GST_EVENT_TS_OFFSET") + '("interrupt" "GST_EVENT_INTERRUPT") + '("navigation" "GST_EVENT_NAVIGATION") + '("tag" "GST_EVENT_TAG") + ) +) + +(define-flags EventFlag + (in-module "Gst") + (c-name "GstEventFlag") + (gtype-id "GST_TYPE_EVENT_FLAG") + (values + '("event-flag-none" "GST_EVENT_FLAG_NONE") + '("rate-flag-negative" "GST_RATE_FLAG_NEGATIVE") + ) +) + +(define-flags SeekType + (in-module "Gst") + (c-name "GstSeekType") + (gtype-id "GST_TYPE_SEEK_TYPE") + (values + '("method-cur" "GST_SEEK_METHOD_CUR") + '("method-set" "GST_SEEK_METHOD_SET") + '("method-end" "GST_SEEK_METHOD_END") + '("flag-flush" "GST_SEEK_FLAG_FLUSH") + '("flag-accurate" "GST_SEEK_FLAG_ACCURATE") + '("flag-key-unit" "GST_SEEK_FLAG_KEY_UNIT") + '("flag-segment-loop" "GST_SEEK_FLAG_SEGMENT_LOOP") + ) +) + +(define-enum SeekAccuracy + (in-module "Gst") + (c-name "GstSeekAccuracy") + (gtype-id "GST_TYPE_SEEK_ACCURACY") + (values + '("certain" "GST_SEEK_CERTAIN") + '("fuzzy" "GST_SEEK_FUZZY") + ) +) + +(define-enum Format + (in-module "Gst") + (c-name "GstFormat") + (gtype-id "GST_TYPE_FORMAT") + (values + '("undefined" "GST_FORMAT_UNDEFINED") + '("default" "GST_FORMAT_DEFAULT") + '("bytes" "GST_FORMAT_BYTES") + '("time" "GST_FORMAT_TIME") + '("buffers" "GST_FORMAT_BUFFERS") + '("percent" "GST_FORMAT_PERCENT") + ) +) + +(define-enum IndexCertainty + (in-module "Gst") + (c-name "GstIndexCertainty") + (gtype-id "GST_TYPE_INDEX_CERTAINTY") + (values + '("unknown" "GST_INDEX_UNKNOWN") + '("certain" "GST_INDEX_CERTAIN") + '("fuzzy" "GST_INDEX_FUZZY") + ) +) + +(define-enum IndexEntryType + (in-module "Gst") + (c-name "GstIndexEntryType") + (gtype-id "GST_TYPE_INDEX_ENTRY_TYPE") + (values + '("id" "GST_INDEX_ENTRY_ID") + '("association" "GST_INDEX_ENTRY_ASSOCIATION") + '("object" "GST_INDEX_ENTRY_OBJECT") + '("format" "GST_INDEX_ENTRY_FORMAT") + ) +) + +(define-enum IndexLookupMethod + (in-module "Gst") + (c-name "GstIndexLookupMethod") + (gtype-id "GST_TYPE_INDEX_LOOKUP_METHOD") + (values + '("exact" "GST_INDEX_LOOKUP_EXACT") + '("before" "GST_INDEX_LOOKUP_BEFORE") + '("after" "GST_INDEX_LOOKUP_AFTER") + ) +) + +(define-flags AssocFlags + (in-module "Gst") + (c-name "GstAssocFlags") + (gtype-id "GST_TYPE_ASSOC_FLAGS") + (values + '("none" "GST_ASSOCIATION_FLAG_NONE") + '("key-unit" "GST_ASSOCIATION_FLAG_KEY_UNIT") + '("last" "GST_ASSOCIATION_FLAG_LAST") + ) +) + +(define-enum IndexResolverMethod + (in-module "Gst") + (c-name "GstIndexResolverMethod") + (gtype-id "GST_TYPE_INDEX_RESOLVER_METHOD") + (values + '("custom" "GST_INDEX_RESOLVER_CUSTOM") + '("gtype" "GST_INDEX_RESOLVER_GTYPE") + '("path" "GST_INDEX_RESOLVER_PATH") + ) +) + +(define-enum IndexFlags + (in-module "Gst") + (c-name "GstIndexFlags") + (gtype-id "GST_TYPE_INDEX_FLAGS") + (values + '("writable" "GST_INDEX_WRITABLE") + '("readable" "GST_INDEX_READABLE") + '("flag-last" "GST_INDEX_FLAG_LAST") + ) +) + +(define-enum DebugLevel + (in-module "Gst") + (c-name "GstDebugLevel") + (gtype-id "GST_TYPE_DEBUG_LEVEL") + (values + '("none" "GST_LEVEL_NONE") + '("error" "GST_LEVEL_ERROR") + '("warning" "GST_LEVEL_WARNING") + '("info" "GST_LEVEL_INFO") + '("debug" "GST_LEVEL_DEBUG") + '("log" "GST_LEVEL_LOG") + '("count" "GST_LEVEL_COUNT") + ) +) + +(define-enum DebugColorFlags + (in-module "Gst") + (c-name "GstDebugColorFlags") + (gtype-id "GST_TYPE_DEBUG_COLOR_FLAGS") + (values + '("fg-black" "GST_DEBUG_FG_BLACK") + '("fg-red" "GST_DEBUG_FG_RED") + '("fg-green" "GST_DEBUG_FG_GREEN") + '("fg-yellow" "GST_DEBUG_FG_YELLOW") + '("fg-blue" "GST_DEBUG_FG_BLUE") + '("fg-magenta" "GST_DEBUG_FG_MAGENTA") + '("fg-cyan" "GST_DEBUG_FG_CYAN") + '("fg-white" "GST_DEBUG_FG_WHITE") + '("bg-black" "GST_DEBUG_BG_BLACK") + '("bg-red" "GST_DEBUG_BG_RED") + '("bg-green" "GST_DEBUG_BG_GREEN") + '("bg-yellow" "GST_DEBUG_BG_YELLOW") + '("bg-blue" "GST_DEBUG_BG_BLUE") + '("bg-magenta" "GST_DEBUG_BG_MAGENTA") + '("bg-cyan" "GST_DEBUG_BG_CYAN") + '("bg-white" "GST_DEBUG_BG_WHITE") + '("bold" "GST_DEBUG_BOLD") + '("underline" "GST_DEBUG_UNDERLINE") + ) +) + +(define-enum ObjectFlags + (in-module "Gst") + (c-name "GstObjectFlags") + (gtype-id "GST_TYPE_OBJECT_FLAGS") + (values + '("destroyed" "GST_DESTROYED") + '("floating" "GST_FLOATING") + '("object-flag-last" "GST_OBJECT_FLAG_LAST") + ) +) + +(define-enum PadLinkReturn + (in-module "Gst") + (c-name "GstPadLinkReturn") + (gtype-id "GST_TYPE_PAD_LINK_RETURN") + (values + '("refused" "GST_PAD_LINK_REFUSED") + '("delayed" "GST_PAD_LINK_DELAYED") + '("ok" "GST_PAD_LINK_OK") + '("done" "GST_PAD_LINK_DONE") + ) +) + +(define-enum PadDirection + (in-module "Gst") + (c-name "GstPadDirection") + (gtype-id "GST_TYPE_PAD_DIRECTION") + (values + '("unknown" "GST_PAD_UNKNOWN") + '("src" "GST_PAD_SRC") + '("sink" "GST_PAD_SINK") + ) +) + +(define-enum PadFlags + (in-module "Gst") + (c-name "GstPadFlags") + (gtype-id "GST_TYPE_PAD_FLAGS") + (values + '("disabled" "GST_PAD_DISABLED") + '("negotiating" "GST_PAD_NEGOTIATING") + '("flag-last" "GST_PAD_FLAG_LAST") + ) +) + +(define-enum PadPresence + (in-module "Gst") + (c-name "GstPadPresence") + (gtype-id "GST_TYPE_PAD_PRESENCE") + (values + '("always" "GST_PAD_ALWAYS") + '("sometimes" "GST_PAD_SOMETIMES") + '("request" "GST_PAD_REQUEST") + ) +) + +(define-enum PadTemplateFlags + (in-module "Gst") + (c-name "GstPadTemplateFlags") + (gtype-id "GST_TYPE_PAD_TEMPLATE_FLAGS") + (values + '("ixed" "GST_PAD_TEMPLATE_FIXED") + '("lag-last" "GST_PAD_TEMPLATE_FLAG_LAST") + ) +) + +(define-enum ParseError + (in-module "Gst") + (c-name "GstParseError") + (gtype-id "GST_TYPE_PARSE_ERROR") + (values + '("syntax" "GST_PARSE_ERROR_SYNTAX") + '("no-such-element" "GST_PARSE_ERROR_NO_SUCH_ELEMENT") + '("no-such-property" "GST_PARSE_ERROR_NO_SUCH_PROPERTY") + '("link" "GST_PARSE_ERROR_LINK") + '("could-not-set-property" "GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY") + '("empty-bin" "GST_PARSE_ERROR_EMPTY_BIN") + '("empty" "GST_PARSE_ERROR_EMPTY") + ) +) + +(define-enum PluginError + (in-module "Gst") + (c-name "GstPluginError") + (gtype-id "GST_TYPE_PLUGIN_ERROR") + (values + '("module" "GST_PLUGIN_ERROR_MODULE") + '("dependencies" "GST_PLUGIN_ERROR_DEPENDENCIES") + '("name-mismatch" "GST_PLUGIN_ERROR_NAME_MISMATCH") + ) +) + +(define-enum QueryType + (in-module "Gst") + (c-name "GstQueryType") + (gtype-id "GST_TYPE_QUERY_TYPE") + (values + '("none" "GST_QUERY_NONE") + '("total" "GST_QUERY_TOTAL") + '("position" "GST_QUERY_POSITION") + '("latency" "GST_QUERY_LATENCY") + '("jitter" "GST_QUERY_JITTER") + '("start" "GST_QUERY_START") + '("segment-end" "GST_QUERY_SEGMENT_END") + '("rate" "GST_QUERY_RATE") + ) +) + +(define-flags RegistryReturn + (in-module "Gst") + (c-name "GstRegistryReturn") + (gtype-id "GST_TYPE_REGISTRY_RETURN") + (values + '("ok" "GST_REGISTRY_OK") + '("load-error" "GST_REGISTRY_LOAD_ERROR") + '("save-error" "GST_REGISTRY_SAVE_ERROR") + '("plugin-load-error" "GST_REGISTRY_PLUGIN_LOAD_ERROR") + '("plugin-signature-error" "GST_REGISTRY_PLUGIN_SIGNATURE_ERROR") + ) +) + +(define-flags RegistryFlags + (in-module "Gst") + (c-name "GstRegistryFlags") + (gtype-id "GST_TYPE_REGISTRY_FLAGS") + (values + '("readable" "GST_REGISTRY_READABLE") + '("writable" "GST_REGISTRY_WRITABLE") + '("exists" "GST_REGISTRY_EXISTS") + '("remote" "GST_REGISTRY_REMOTE") + '("delayed-loading" "GST_REGISTRY_DELAYED_LOADING") + ) +) + +(define-enum SchedulerFlags + (in-module "Gst") + (c-name "GstSchedulerFlags") + (gtype-id "GST_TYPE_SCHEDULER_FLAGS") + (values + '("fixed-clock" "GST_SCHEDULER_FLAG_FIXED_CLOCK") + '("last" "GST_SCHEDULER_FLAG_LAST") + ) +) + +(define-enum SchedulerState + (in-module "Gst") + (c-name "GstSchedulerState") + (gtype-id "GST_TYPE_SCHEDULER_STATE") + (values + '("none" "GST_SCHEDULER_STATE_NONE") + '("running" "GST_SCHEDULER_STATE_RUNNING") + '("stopped" "GST_SCHEDULER_STATE_STOPPED") + '("error" "GST_SCHEDULER_STATE_ERROR") + ) +) + +(define-enum TagMergeMode + (in-module "Gst") + (c-name "GstTagMergeMode") + (gtype-id "GST_TYPE_TAG_MERGE_MODE") + (values + '("undefined" "GST_TAG_MERGE_UNDEFINED") + '("replace-all" "GST_TAG_MERGE_REPLACE_ALL") + '("replace" "GST_TAG_MERGE_REPLACE") + '("append" "GST_TAG_MERGE_APPEND") + '("prepend" "GST_TAG_MERGE_PREPEND") + '("keep" "GST_TAG_MERGE_KEEP") + '("keep-all" "GST_TAG_MERGE_KEEP_ALL") + '("count" "GST_TAG_MERGE_COUNT") + ) +) + +(define-enum TagFlag + (in-module "Gst") + (c-name "GstTagFlag") + (gtype-id "GST_TYPE_TAG_FLAG") + (values + '("undefined" "GST_TAG_FLAG_UNDEFINED") + '("meta" "GST_TAG_FLAG_META") + '("encoded" "GST_TAG_FLAG_ENCODED") + '("decoded" "GST_TAG_FLAG_DECODED") + '("count" "GST_TAG_FLAG_COUNT") + ) +) + +(define-enum ThreadState + (in-module "Gst") + (c-name "GstThreadState") + (gtype-id "GST_TYPE_THREAD_STATE") + (values + '("state-spinning" "GST_THREAD_STATE_SPINNING") + '("state-reaping" "GST_THREAD_STATE_REAPING") + '("mutex-locked" "GST_THREAD_MUTEX_LOCKED") + '("flag-last" "GST_THREAD_FLAG_LAST") + ) +) + +(define-flags AllocTraceFlags + (in-module "Gst") + (c-name "GstAllocTraceFlags") + (gtype-id "GST_TYPE_ALLOC_TRACE_FLAGS") + (values + '("live" "GST_ALLOC_TRACE_LIVE") + '("mem-live" "GST_ALLOC_TRACE_MEM_LIVE") + ) +) + +(define-enum TypeFindProbability + (in-module "Gst") + (c-name "GstTypeFindProbability") + (gtype-id "GST_TYPE_TYPE_FIND_PROBABILITY") + (values + '("minimum" "GST_TYPE_FIND_MINIMUM") + '("possible" "GST_TYPE_FIND_POSSIBLE") + '("likely" "GST_TYPE_FIND_LIKELY") + '("nearly-certain" "GST_TYPE_FIND_NEARLY_CERTAIN") + '("maximum" "GST_TYPE_FIND_MAXIMUM") + ) +) + +(define-flags ElementState + (in-module "Gst") + (c-name "GstElementState") + (gtype-id "GST_TYPE_ELEMENT_STATE") + (values + '("void-pending" "GST_STATE_VOID_PENDING") + '("null" "GST_STATE_NULL") + '("ready" "GST_STATE_READY") + '("paused" "GST_STATE_PAUSED") + '("playing" "GST_STATE_PLAYING") + ) +) + +(define-enum ElementStateReturn + (in-module "Gst") + (c-name "GstElementStateReturn") + (gtype-id "GST_TYPE_ELEMENT_STATE_RETURN") + (values + '("failure" "GST_STATE_FAILURE") + '("success" "GST_STATE_SUCCESS") + '("async" "GST_STATE_ASYNC") + ) +) + +(define-enum Result + (in-module "Gst") + (c-name "GstResult") + (gtype-id "GST_TYPE_RESULT") + (values + '("ok" "GST_RESULT_OK") + '("nok" "GST_RESULT_NOK") + '("not-impl" "GST_RESULT_NOT_IMPL") + ) +) + +(define-enum URIType + (in-module "Gst") + (c-name "GstURIType") + (gtype-id "GST_TYPE_URI_TYPE") + (values + '("unknown" "GST_URI_UNKNOWN") + '("sink" "GST_URI_SINK") + '("src" "GST_URI_SRC") + ) +) + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstatomic.h + +(define-method init + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_init") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method destroy + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_destroy") + (return-type "none") +) + +(define-method set + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_set") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method read + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_read") + (return-type "gint") +) + +(define-method add + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_add") + (return-type "none") + (parameters + '("gint" "val") + ) +) + +(define-method inc + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_inc") + (return-type "none") +) + +(define-method dec_and_test + (of-object "GstAtomicInt") + (c-name "gst_atomic_int_dec_and_test") + (return-type "gboolean") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstbin.h + +(define-function gst_bin_get_type + (c-name "gst_bin_get_type") + (return-type "GType") +) + +(define-function gst_bin_new + (c-name "gst_bin_new") + (is-constructor-of "GstBin") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method add + (of-object "GstBin") + (c-name "gst_bin_add") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method add_many + (of-object "GstBin") + (c-name "gst_bin_add_many") + (return-type "none") + (parameters + '("GstElement*" "element_1") + ) + (varargs #t) +) + +(define-method remove + (of-object "GstBin") + (c-name "gst_bin_remove") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method remove_many + (of-object "GstBin") + (c-name "gst_bin_remove_many") + (return-type "none") + (parameters + '("GstElement*" "element_1") + ) + (varargs #t) +) + +(define-method get_by_name + (of-object "GstBin") + (c-name "gst_bin_get_by_name") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_by_name_recurse_up + (of-object "GstBin") + (c-name "gst_bin_get_by_name_recurse_up") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_list + (of-object "GstBin") + (c-name "gst_bin_get_list") + (return-type "const-GList*") +) + +(define-method get_by_interface + (of-object "GstBin") + (c-name "gst_bin_get_by_interface") + (return-type "GstElement*") + (parameters + '("GType" "interface") + ) +) + +(define-method get_all_by_interface + (of-object "GstBin") + (c-name "gst_bin_get_all_by_interface") + (return-type "GList*") + (parameters + '("GType" "interface") + ) +) + +(define-method iterate + (of-object "GstBin") + (c-name "gst_bin_iterate") + (return-type "gboolean") +) + +(define-method use_clock + (of-object "GstBin") + (c-name "gst_bin_use_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method get_clock + (of-object "GstBin") + (c-name "gst_bin_get_clock") + (return-type "GstClock*") +) + +(define-method auto_clock + (of-object "GstBin") + (c-name "gst_bin_auto_clock") + (return-type "none") +) + +(define-method sync_children_state + (of-object "GstBin") + (c-name "gst_bin_sync_children_state") + (return-type "GstElementStateReturn") +) + +(define-method child_state_change + (of-object "GstBin") + (c-name "gst_bin_child_state_change") + (return-type "none") + (parameters + '("GstElementState" "oldstate") + '("GstElementState" "newstate") + '("GstElement*" "child") + ) +) + +(define-method set_pre_iterate_function + (of-object "GstBin") + (c-name "gst_bin_set_pre_iterate_function") + (return-type "none") + (parameters + '("GstBinPrePostIterateFunction" "func") + '("gpointer" "user_data") + ) +) + +(define-method set_post_iterate_function + (of-object "GstBin") + (c-name "gst_bin_set_post_iterate_function") + (return-type "none") + (parameters + '("GstBinPrePostIterateFunction" "func") + '("gpointer" "user_data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstbuffer.h + +(define-function gst_buffer_get_type + (c-name "gst_buffer_get_type") + (return-type "GType") +) + +(define-function gst_buffer_new + (c-name "gst_buffer_new") + (is-constructor-of "GstBuffer") + (return-type "GstBuffer*") +) + +(define-function gst_buffer_new_and_alloc + (c-name "gst_buffer_new_and_alloc") + (return-type "GstBuffer*") + (parameters + '("guint" "size") + ) +) + +(define-method stamp + (of-object "GstBuffer") + (c-name "gst_buffer_stamp") + (return-type "none") + (parameters + '("const-GstBuffer*" "src") + ) +) + +(define-method create_sub + (of-object "GstBuffer") + (c-name "gst_buffer_create_sub") + (return-type "GstBuffer*") + (parameters + '("guint" "offset") + '("guint" "size") + ) +) + +(define-method merge + (of-object "GstBuffer") + (c-name "gst_buffer_merge") + (return-type "GstBuffer*") + (parameters + '("GstBuffer*" "buf2") + ) +) + +(define-method is_span_fast + (of-object "GstBuffer") + (c-name "gst_buffer_is_span_fast") + (return-type "gboolean") + (parameters + '("GstBuffer*" "buf2") + ) +) + +(define-method span + (of-object "GstBuffer") + (c-name "gst_buffer_span") + (return-type "GstBuffer*") + (parameters + '("guint32" "offset") + '("GstBuffer*" "buf2") + '("guint32" "len") + ) +) + +(define-function _gst_buffer_initialize + (c-name "_gst_buffer_initialize") + (return-type "none") +) + +(define-method default_free + (of-object "GstBuffer") + (c-name "gst_buffer_default_free") + (return-type "none") +) + +(define-method default_copy + (of-object "GstBuffer") + (c-name "gst_buffer_default_copy") + (return-type "GstBuffer*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstcaps.h + +(define-function _gst_caps_initialize + (c-name "_gst_caps_initialize") + (return-type "none") +) + +(define-function gst_caps_get_type + (c-name "gst_caps_get_type") + (return-type "GType") +) + +(define-function gst_caps_new_empty + (c-name "gst_caps_new_empty") + (return-type "GstCaps*") +) + +(define-function gst_caps_new_any + (c-name "gst_caps_new_any") + (return-type "GstCaps*") +) + +(define-function gst_caps_new_simple + (c-name "gst_caps_new_simple") + (return-type "GstCaps*") + (parameters + '("const-char*" "media_type") + '("const-char*" "fieldname") + ) + (varargs #t) +) + +(define-function gst_caps_new_full + (c-name "gst_caps_new_full") + (return-type "GstCaps*") + (parameters + '("GstStructure*" "struct1") + ) + (varargs #t) +) + +(define-function gst_caps_new_full_valist + (c-name "gst_caps_new_full_valist") + (return-type "GstCaps*") + (parameters + '("GstStructure*" "structure") + '("va_list" "var_args") + ) +) + +(define-method copy + (of-object "GstCaps") + (c-name "gst_caps_copy") + (return-type "GstCaps*") +) + +(define-method free + (of-object "GstCaps") + (c-name "gst_caps_free") + (return-type "none") +) + +(define-method get + (of-object "GstStaticCaps") + (c-name "gst_static_caps_get") + (return-type "const-GstCaps*") +) + +(define-method append + (of-object "GstCaps") + (c-name "gst_caps_append") + (return-type "none") + (parameters + '("GstCaps*" "caps2") + ) +) + +(define-method append_structure + (of-object "GstCaps") + (c-name "gst_caps_append_structure") + (return-type "none") + (parameters + '("GstStructure*" "structure") + ) +) + +(define-method split_one + (of-object "GstCaps") + (c-name "gst_caps_split_one") + (return-type "GstCaps*") +) + +(define-method get_size + (of-object "GstCaps") + (c-name "gst_caps_get_size") + (return-type "int") +) + +(define-method get_structure + (of-object "GstCaps") + (c-name "gst_caps_get_structure") + (return-type "GstStructure*") + (parameters + '("int" "index") + ) +) + +(define-method copy_1 + (of-object "GstCaps") + (c-name "gst_caps_copy_1") + (return-type "GstCaps*") +) + +(define-method set_simple + (of-object "GstCaps") + (c-name "gst_caps_set_simple") + (return-type "none") + (parameters + '("char*" "field") + ) + (varargs #t) +) + +(define-method set_simple_valist + (of-object "GstCaps") + (c-name "gst_caps_set_simple_valist") + (return-type "none") + (parameters + '("char*" "field") + '("va_list" "varargs") + ) +) + +(define-method is_any + (of-object "GstCaps") + (c-name "gst_caps_is_any") + (return-type "gboolean") +) + +(define-method is_empty + (of-object "GstCaps") + (c-name "gst_caps_is_empty") + (return-type "gboolean") +) + +(define-method is_chained + (of-object "GstCaps") + (c-name "gst_caps_is_chained") + (return-type "gboolean") +) + +(define-method is_fixed + (of-object "GstCaps") + (c-name "gst_caps_is_fixed") + (return-type "gboolean") +) + +(define-method is_equal_fixed + (of-object "GstCaps") + (c-name "gst_caps_is_equal_fixed") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method is_always_compatible + (of-object "GstCaps") + (c-name "gst_caps_is_always_compatible") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method intersect + (of-object "GstCaps") + (c-name "gst_caps_intersect") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method union + (of-object "GstCaps") + (c-name "gst_caps_union") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps2") + ) +) + +(define-method normalize + (of-object "GstCaps") + (c-name "gst_caps_normalize") + (return-type "GstCaps*") +) + +(define-method simplify + (of-object "GstCaps") + (c-name "gst_caps_simplify") + (return-type "GstCaps*") +) + +(define-method save_thyself + (of-object "GstCaps") + (c-name "gst_caps_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-function gst_caps_load_thyself + (c-name "gst_caps_load_thyself") + (return-type "GstCaps*") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-function gst_caps_replace + (c-name "gst_caps_replace") + (return-type "none") + (parameters + '("GstCaps**" "caps") + '("GstCaps*" "newcaps") + ) +) + +(define-method to_string + (of-object "GstCaps") + (c-name "gst_caps_to_string") + (return-type "gchar*") +) + +(define-function gst_caps_from_string + (c-name "gst_caps_from_string") + (return-type "GstCaps*") + (parameters + '("const-gchar*" "string") + ) +) + +(define-function gst_caps_structure_fixate_field_nearest_int + (c-name "gst_caps_structure_fixate_field_nearest_int") + (return-type "gboolean") + (parameters + '("GstStructure*" "structure") + '("const-char*" "field_name") + '("int" "target") + ) +) + +(define-function gst_caps_structure_fixate_field_nearest_double + (c-name "gst_caps_structure_fixate_field_nearest_double") + (return-type "gboolean") + (parameters + '("GstStructure*" "structure") + '("const-char*" "field_name") + '("double" "target") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstclock.h + +(define-function gst_clock_get_type + (c-name "gst_clock_get_type") + (return-type "GType") +) + +(define-method set_speed + (of-object "GstClock") + (c-name "gst_clock_set_speed") + (return-type "gdouble") + (parameters + '("gdouble" "speed") + ) +) + +(define-method get_speed + (of-object "GstClock") + (c-name "gst_clock_get_speed") + (return-type "gdouble") +) + +(define-method set_resolution + (of-object "GstClock") + (c-name "gst_clock_set_resolution") + (return-type "guint64") + (parameters + '("guint64" "resolution") + ) +) + +(define-method get_resolution + (of-object "GstClock") + (c-name "gst_clock_get_resolution") + (return-type "guint64") +) + +(define-method set_active + (of-object "GstClock") + (c-name "gst_clock_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method is_active + (of-object "GstClock") + (c-name "gst_clock_is_active") + (return-type "gboolean") +) + +(define-method reset + (of-object "GstClock") + (c-name "gst_clock_reset") + (return-type "none") +) + +(define-method handle_discont + (of-object "GstClock") + (c-name "gst_clock_handle_discont") + (return-type "gboolean") + (parameters + '("guint64" "time") + ) +) + +(define-method get_time + (of-object "GstClock") + (c-name "gst_clock_get_time") + (return-type "GstClockTime") +) + +(define-method get_event_time + (of-object "GstClock") + (c-name "gst_clock_get_event_time") + (return-type "GstClockTime") +) + +(define-method get_next_id + (of-object "GstClock") + (c-name "gst_clock_get_next_id") + (return-type "GstClockID") +) + +(define-method new_single_shot_id + (of-object "GstClock") + (c-name "gst_clock_new_single_shot_id") + (return-type "GstClockID") + (parameters + '("GstClockTime" "time") + ) +) + +(define-method new_periodic_id + (of-object "GstClock") + (c-name "gst_clock_new_periodic_id") + (return-type "GstClockID") + (parameters + '("GstClockTime" "start_time") + '("GstClockTime" "interval") + ) +) + +(define-method get_time + (of-object "GstClockID") + (c-name "gst_clock_id_get_time") + (return-type "GstClockTime") +) + +(define-method wait + (of-object "GstClockID") + (c-name "gst_clock_id_wait") + (return-type "GstClockReturn") + (parameters + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method wait_async + (of-object "GstClockID") + (c-name "gst_clock_id_wait_async") + (return-type "GstClockReturn") + (parameters + '("GstClockCallback" "func") + '("gpointer" "user_data") + ) +) + +(define-method unschedule + (of-object "GstClockID") + (c-name "gst_clock_id_unschedule") + (return-type "none") +) + +(define-method unlock + (of-object "GstClockID") + (c-name "gst_clock_id_unlock") + (return-type "none") +) + +(define-method free + (of-object "GstClockID") + (c-name "gst_clock_id_free") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstconfig.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstcpu.h + +(define-function _gst_cpu_initialize + (c-name "_gst_cpu_initialize") + (return-type "none") + (parameters + '("gboolean" "useopt") + ) +) + +(define-function gst_cpu_get_flags + (c-name "gst_cpu_get_flags") + (return-type "GstCPUFlags") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstdata.h + +(define-method init + (of-object "GstData") + (c-name "gst_data_init") + (return-type "none") + (parameters + '("GType" "type") + '("guint16" "flags") + '("GstDataFreeFunction" "free") + '("GstDataCopyFunction" "copy") + ) +) + +(define-method dispose + (of-object "GstData") + (c-name "gst_data_dispose") + (return-type "none") +) + +(define-method copy_into + (of-object "GstData") + (c-name "gst_data_copy_into") + (return-type "none") + (parameters + '("GstData*" "target") + ) +) + +(define-method copy + (of-object "GstData") + (c-name "gst_data_copy") + (return-type "GstData*") +) + +(define-method is_writable + (of-object "GstData") + (c-name "gst_data_is_writable") + (return-type "gboolean") +) + +(define-method copy_on_write + (of-object "GstData") + (c-name "gst_data_copy_on_write") + (return-type "GstData*") +) + +(define-method free + (of-object "GstData") + (c-name "gst_data_free") + (return-type "none") +) + +(define-method ref + (of-object "GstData") + (c-name "gst_data_ref") + (return-type "GstData*") +) + +(define-method ref_by_count + (of-object "GstData") + (c-name "gst_data_ref_by_count") + (return-type "GstData*") + (parameters + '("gint" "count") + ) +) + +(define-method unref + (of-object "GstData") + (c-name "gst_data_unref") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstelement.h + +(define-method add_pad_template + (of-object "GstElementClass") + (c-name "gst_element_class_add_pad_template") + (return-type "none") + (parameters + '("GstPadTemplate*" "templ") + ) +) + +(define-method install_std_props + (of-object "GstElementClass") + (c-name "gst_element_class_install_std_props") + (return-type "none") + (parameters + '("const-gchar*" "first_name") + ) + (varargs #t) +) + +(define-method set_details + (of-object "GstElementClass") + (c-name "gst_element_class_set_details") + (return-type "none") + (parameters + '("const-GstElementDetails*" "details") + ) +) + +(define-function gst_element_default_error + (c-name "gst_element_default_error") + (return-type "none") + (parameters + '("GObject*" "object") + '("GstObject*" "orig") + '("GError*" "error") + '("gchar*" "debug") + ) +) + +(define-function gst_element_get_type + (c-name "gst_element_get_type") + (return-type "GType") +) + +(define-method set_loop_function + (of-object "GstElement") + (c-name "gst_element_set_loop_function") + (return-type "none") + (parameters + '("GstElementLoopFunction" "loop") + ) +) + +(define-method set + (of-object "GstElement") + (c-name "gst_element_set") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + ) + (varargs #t) +) + +(define-method get + (of-object "GstElement") + (c-name "gst_element_get") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + ) + (varargs #t) +) + +(define-method set_valist + (of-object "GstElement") + (c-name "gst_element_set_valist") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + '("va_list" "var_args") + ) +) + +(define-method get_valist + (of-object "GstElement") + (c-name "gst_element_get_valist") + (return-type "none") + (parameters + '("const-gchar*" "first_property_name") + '("va_list" "var_args") + ) +) + +(define-method set_property + (of-object "GstElement") + (c-name "gst_element_set_property") + (return-type "none") + (parameters + '("const-gchar*" "property_name") + '("const-GValue*" "value") + ) +) + +(define-method get_property + (of-object "GstElement") + (c-name "gst_element_get_property") + (return-type "none") + (parameters + '("const-gchar*" "property_name") + '("GValue*" "value") + ) +) + +(define-method enable_threadsafe_properties + (of-object "GstElement") + (c-name "gst_element_enable_threadsafe_properties") + (return-type "none") +) + +(define-method disable_threadsafe_properties + (of-object "GstElement") + (c-name "gst_element_disable_threadsafe_properties") + (return-type "none") +) + +(define-method set_pending_properties + (of-object "GstElement") + (c-name "gst_element_set_pending_properties") + (return-type "none") +) + +(define-method requires_clock + (of-object "GstElement") + (c-name "gst_element_requires_clock") + (return-type "gboolean") +) + +(define-method provides_clock + (of-object "GstElement") + (c-name "gst_element_provides_clock") + (return-type "gboolean") +) + +(define-method get_clock + (of-object "GstElement") + (c-name "gst_element_get_clock") + (return-type "GstClock*") +) + +(define-method set_clock + (of-object "GstElement") + (c-name "gst_element_set_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method clock_wait + (of-object "GstElement") + (c-name "gst_element_clock_wait") + (return-type "GstClockReturn") + (parameters + '("GstClockID" "id") + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method get_time + (of-object "GstElement") + (c-name "gst_element_get_time") + (return-type "GstClockTime") +) + +(define-method wait + (of-object "GstElement") + (c-name "gst_element_wait") + (return-type "gboolean") + (parameters + '("GstClockTime" "timestamp") + ) +) + +(define-method set_time + (of-object "GstElement") + (c-name "gst_element_set_time") + (return-type "none") + (parameters + '("GstClockTime" "time") + ) +) + +(define-method adjust_time + (of-object "GstElement") + (c-name "gst_element_adjust_time") + (return-type "none") + (parameters + '("GstClockTimeDiff" "diff") + ) +) + +(define-method is_indexable + (of-object "GstElement") + (c-name "gst_element_is_indexable") + (return-type "gboolean") +) + +(define-method set_index + (of-object "GstElement") + (c-name "gst_element_set_index") + (return-type "none") + (parameters + '("GstIndex*" "index") + ) +) + +(define-method get_index + (of-object "GstElement") + (c-name "gst_element_get_index") + (return-type "GstIndex*") +) + +(define-method release_locks + (of-object "GstElement") + (c-name "gst_element_release_locks") + (return-type "gboolean") +) + +(define-method yield + (of-object "GstElement") + (c-name "gst_element_yield") + (return-type "none") +) + +(define-method interrupt + (of-object "GstElement") + (c-name "gst_element_interrupt") + (return-type "gboolean") +) + +(define-method set_scheduler + (of-object "GstElement") + (c-name "gst_element_set_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched") + ) +) + +(define-method get_scheduler + (of-object "GstElement") + (c-name "gst_element_get_scheduler") + (return-type "GstScheduler*") +) + +(define-method add_pad + (of-object "GstElement") + (c-name "gst_element_add_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method remove_pad + (of-object "GstElement") + (c-name "gst_element_remove_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method add_ghost_pad + (of-object "GstElement") + (c-name "gst_element_add_ghost_pad") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + '("const-gchar*" "name") + ) +) + +(define-method remove_ghost_pad + (of-object "GstElement") + (c-name "gst_element_remove_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_pad + (of-object "GstElement") + (c-name "gst_element_get_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_static_pad + (of-object "GstElement") + (c-name "gst_element_get_static_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_request_pad + (of-object "GstElement") + (c-name "gst_element_get_request_pad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method release_request_pad + (of-object "GstElement") + (c-name "gst_element_release_request_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_pad_list + (of-object "GstElement") + (c-name "gst_element_get_pad_list") + (return-type "const-GList*") +) + +(define-method get_compatible_pad + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + ) +) + +(define-method get_compatible_pad_filtered + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad_filtered") + (return-type "GstPad*") + (parameters + '("GstPad*" "pad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method get_pad_template + (of-object "GstElementClass") + (c-name "gst_element_class_get_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_pad_template_list + (of-object "GstElementClass") + (c-name "gst_element_class_get_pad_template_list") + (return-type "GList*") +) + +(define-method get_pad_template + (of-object "GstElement") + (c-name "gst_element_get_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_pad_template_list + (of-object "GstElement") + (c-name "gst_element_get_pad_template_list") + (return-type "GList*") +) + +(define-method get_compatible_pad_template + (of-object "GstElement") + (c-name "gst_element_get_compatible_pad_template") + (return-type "GstPadTemplate*") + (parameters + '("GstPadTemplate*" "compattempl") + ) +) + +(define-method link + (of-object "GstElement") + (c-name "gst_element_link") + (return-type "gboolean") + (parameters + '("GstElement*" "dest") + ) +) + +(define-method link_filtered + (of-object "GstElement") + (c-name "gst_element_link_filtered") + (return-type "gboolean") + (parameters + '("GstElement*" "dest") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-function element_link_many + (c-name "gst_element_link_many") + (return-type "gboolean") + (parameters + '("GstElement*" "element_1") + '("GstElement*" "element_2") + ) + (varargs #t) +) + +(define-method unlink + (of-object "GstElement") + (c-name "gst_element_unlink") + (return-type "none") + (parameters + '("GstElement*" "dest") + ) +) + +(define-method unlink_many + (of-object "GstElement") + (c-name "gst_element_unlink_many") + (return-type "none") + (parameters + '("GstElement*" "element_2") + ) + (varargs #t) +) + +(define-method link_pads + (of-object "GstElement") + (c-name "gst_element_link_pads") + (return-type "gboolean") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + ) +) + +(define-method link_pads_filtered + (of-object "GstElement") + (c-name "gst_element_link_pads_filtered") + (return-type "gboolean") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method unlink_pads + (of-object "GstElement") + (c-name "gst_element_unlink_pads") + (return-type "none") + (parameters + '("const-gchar*" "srcpadname") + '("GstElement*" "dest") + '("const-gchar*" "destpadname") + ) +) + +(define-method get_event_masks + (of-object "GstElement") + (c-name "gst_element_get_event_masks") + (return-type "const-GstEventMask*") +) + +(define-method send_event + (of-object "GstElement") + (c-name "gst_element_send_event") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-method seek + (of-object "GstElement") + (c-name "gst_element_seek") + (return-type "gboolean") + (parameters + '("GstSeekType" "seek_type") + '("guint64" "offset") + ) +) + +(define-method get_query_types + (of-object "GstElement") + (c-name "gst_element_get_query_types") + (return-type "const-GstQueryType*") +) + +(define-method query + (of-object "GstElement") + (c-name "gst_element_query") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method get_formats + (of-object "GstElement") + (c-name "gst_element_get_formats") + (return-type "const-GstFormat*") +) + +(define-method convert + (of-object "GstElement") + (c-name "gst_element_convert") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method found_tags + (of-object "GstElement") + (c-name "gst_element_found_tags") + (return-type "none") + (parameters + '("const-GstTagList*" "tag_list") + ) +) + +(define-method found_tags_for_pad + (of-object "GstElement") + (c-name "gst_element_found_tags_for_pad") + (return-type "none") + (parameters + '("GstPad*" "pad") + '("GstClockTime" "timestamp") + '("GstTagList*" "list") + ) +) + +(define-method set_eos + (of-object "GstElement") + (c-name "gst_element_set_eos") + (return-type "none") +) + +(define-function _gst_element_error_printf + (c-name "_gst_element_error_printf") + (return-type "gchar*") + (parameters + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-method error_full + (of-object "GstElement") + (c-name "gst_element_error_full") + (return-type "none") + (parameters + '("GQuark" "domain") + '("gint" "code") + '("gchar*" "message") + '("gchar*" "debug") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + ) +) + +(define-method is_locked_state + (of-object "GstElement") + (c-name "gst_element_is_locked_state") + (return-type "gboolean") +) + +(define-method set_locked_state + (of-object "GstElement") + (c-name "gst_element_set_locked_state") + (return-type "none") + (parameters + '("gboolean" "locked_state") + ) +) + +(define-method sync_state_with_parent + (of-object "GstElement") + (c-name "gst_element_sync_state_with_parent") + (return-type "gboolean") +) + +(define-method get_state + (of-object "GstElement") + (c-name "gst_element_get_state") + (return-type "GstElementState") +) + +(define-method set_state + (of-object "GstElement") + (c-name "gst_element_set_state") + (return-type "GstElementStateReturn") + (parameters + '("GstElementState" "state") + ) +) + +(define-method wait_state_change + (of-object "GstElement") + (c-name "gst_element_wait_state_change") + (return-type "none") +) + +(define-method get_name + (of-object "GstElementState") + (c-name "gst_element_state_get_name") + (return-type "const-gchar*") +) + +(define-method get_factory + (of-object "GstElement") + (c-name "gst_element_get_factory") + (return-type "GstElementFactory*") +) + +(define-method get_managing_bin + (of-object "GstElement") + (c-name "gst_element_get_managing_bin") + (return-type "GstBin*") +) + +(define-function gst_element_factory_get_type + (c-name "gst_element_factory_get_type") + (return-type "GType") +) + +(define-function gst_element_register + (c-name "gst_element_register") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + '("const-gchar*" "elementname") + '("guint" "rank") + '("GType" "type") + ) +) + +(define-function gst_element_factory_find + (c-name "gst_element_factory_find") + (return-type "GstElementFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_element_type + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_element_type") + (return-type "GType") +) + +(define-method get_longname + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_longname") + (return-type "const-gchar*") +) + +(define-method get_klass + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_klass") + (return-type "const-gchar*") +) + +(define-method get_description + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_description") + (return-type "const-gchar*") +) + +(define-method get_author + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_author") + (return-type "const-gchar*") +) + +(define-method get_num_pad_templates + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_num_pad_templates") + (return-type "guint") +) + +(define-method get_pad_templates + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_pad_templates") + (return-type "const-GList*") +) + +(define-method get_uri_type + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_uri_type") + (return-type "guint") +) + +(define-method get_uri_protocols + (of-object "GstElementFactory") + (c-name "gst_element_factory_get_uri_protocols") + (return-type "gchar**") +) + +(define-method create + (of-object "GstElementFactory") + (c-name "gst_element_factory_create") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_element_factory_make + (is-constructor-of "GstElement") + (c-name "gst_element_factory_make") + (return-type "GstElement*") + (parameters + '("const-gchar*" "factoryname") + '("const-gchar*" "name") + ) +) + +(define-method can_src_caps + (of-object "GstElementFactory") + (c-name "gst_element_factory_can_src_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method can_sink_caps + (of-object "GstElementFactory") + (c-name "gst_element_factory_can_sink_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method __add_pad_template + (of-object "GstElementFactory") + (c-name "__gst_element_factory_add_pad_template") + (return-type "none") + (parameters + '("GstPadTemplate*" "templ") + ) +) + +(define-method __add_interface + (of-object "GstElementFactory") + (c-name "__gst_element_factory_add_interface") + (return-type "none") + (parameters + '("const-gchar*" "interfacename") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstenumtypes.h + +(define-function gst_object_flags_get_type + (c-name "gst_object_flags_get_type") + (return-type "GType") +) + +(define-function gst_bin_flags_get_type + (c-name "gst_bin_flags_get_type") + (return-type "GType") +) + +(define-function gst_buffer_flag_get_type + (c-name "gst_buffer_flag_get_type") + (return-type "GType") +) + +(define-function gst_clock_entry_status_get_type + (c-name "gst_clock_entry_status_get_type") + (return-type "GType") +) + +(define-function gst_clock_entry_type_get_type + (c-name "gst_clock_entry_type_get_type") + (return-type "GType") +) + +(define-function gst_clock_return_get_type + (c-name "gst_clock_return_get_type") + (return-type "GType") +) + +(define-function gst_clock_flags_get_type + (c-name "gst_clock_flags_get_type") + (return-type "GType") +) + +(define-function gst_cpu_flags_get_type + (c-name "gst_cpu_flags_get_type") + (return-type "GType") +) + +(define-function gst_data_flags_get_type + (c-name "gst_data_flags_get_type") + (return-type "GType") +) + +(define-function gst_element_flags_get_type + (c-name "gst_element_flags_get_type") + (return-type "GType") +) + +(define-function gst_core_error_get_type + (c-name "gst_core_error_get_type") + (return-type "GType") +) + +(define-function gst_library_error_get_type + (c-name "gst_library_error_get_type") + (return-type "GType") +) + +(define-function gst_resource_error_get_type + (c-name "gst_resource_error_get_type") + (return-type "GType") +) + +(define-function gst_stream_error_get_type + (c-name "gst_stream_error_get_type") + (return-type "GType") +) + +(define-function gst_event_type_get_type + (c-name "gst_event_type_get_type") + (return-type "GType") +) + +(define-function gst_event_flag_get_type + (c-name "gst_event_flag_get_type") + (return-type "GType") +) + +(define-function gst_seek_type_get_type + (c-name "gst_seek_type_get_type") + (return-type "GType") +) + +(define-function gst_seek_accuracy_get_type + (c-name "gst_seek_accuracy_get_type") + (return-type "GType") +) + +(define-function gst_format_get_type + (c-name "gst_format_get_type") + (return-type "GType") +) + +(define-function gst_index_certainty_get_type + (c-name "gst_index_certainty_get_type") + (return-type "GType") +) + +(define-function gst_index_entry_type_get_type + (c-name "gst_index_entry_type_get_type") + (return-type "GType") +) + +(define-function gst_index_lookup_method_get_type + (c-name "gst_index_lookup_method_get_type") + (return-type "GType") +) + +(define-function gst_assoc_flags_get_type + (c-name "gst_assoc_flags_get_type") + (return-type "GType") +) + +(define-function gst_index_resolver_method_get_type + (c-name "gst_index_resolver_method_get_type") + (return-type "GType") +) + +(define-function gst_index_flags_get_type + (c-name "gst_index_flags_get_type") + (return-type "GType") +) + +(define-function gst_debug_level_get_type + (c-name "gst_debug_level_get_type") + (return-type "GType") +) + +(define-function gst_debug_color_flags_get_type + (c-name "gst_debug_color_flags_get_type") + (return-type "GType") +) + +(define-function gst_pad_link_return_get_type + (c-name "gst_pad_link_return_get_type") + (return-type "GType") +) + +(define-function gst_pad_direction_get_type + (c-name "gst_pad_direction_get_type") + (return-type "GType") +) + +(define-function gst_pad_flags_get_type + (c-name "gst_pad_flags_get_type") + (return-type "GType") +) + +(define-function gst_pad_presence_get_type + (c-name "gst_pad_presence_get_type") + (return-type "GType") +) + +(define-function gst_pad_template_flags_get_type + (c-name "gst_pad_template_flags_get_type") + (return-type "GType") +) + +(define-function gst_plugin_error_get_type + (c-name "gst_plugin_error_get_type") + (return-type "GType") +) + +(define-function gst_query_type_get_type + (c-name "gst_query_type_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_flags_get_type + (c-name "gst_scheduler_flags_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_state_get_type + (c-name "gst_scheduler_state_get_type") + (return-type "GType") +) + +(define-function gst_tag_merge_mode_get_type + (c-name "gst_tag_merge_mode_get_type") + (return-type "GType") +) + +(define-function gst_tag_flag_get_type + (c-name "gst_tag_flag_get_type") + (return-type "GType") +) + +(define-function gst_thread_state_get_type + (c-name "gst_thread_state_get_type") + (return-type "GType") +) + +(define-function gst_alloc_trace_flags_get_type + (c-name "gst_alloc_trace_flags_get_type") + (return-type "GType") +) + +(define-function gst_type_find_probability_get_type + (c-name "gst_type_find_probability_get_type") + (return-type "GType") +) + +(define-function gst_element_state_get_type + (c-name "gst_element_state_get_type") + (return-type "GType") +) + +(define-function gst_element_state_return_get_type + (c-name "gst_element_state_return_get_type") + (return-type "GType") +) + +(define-function gst_result_get_type + (c-name "gst_result_get_type") + (return-type "GType") +) + +(define-function gst_uri_type_get_type + (c-name "gst_uri_type_get_type") + (return-type "GType") +) + +(define-function gst_registry_return_get_type + (c-name "gst_registry_return_get_type") + (return-type "GType") +) + +(define-function gst_registry_flags_get_type + (c-name "gst_registry_flags_get_type") + (return-type "GType") +) + +(define-function gst_parse_error_get_type + (c-name "gst_parse_error_get_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsterror.h + +(define-function gst_core_error_quark + (c-name "gst_core_error_quark") + (return-type "GQuark") +) + +(define-function gst_library_error_quark + (c-name "gst_library_error_quark") + (return-type "GQuark") +) + +(define-function gst_resource_error_quark + (c-name "gst_resource_error_quark") + (return-type "GQuark") +) + +(define-function gst_stream_error_quark + (c-name "gst_stream_error_quark") + (return-type "GQuark") +) + +(define-function gst_error_get_message + (c-name "gst_error_get_message") + (return-type "gchar*") + (parameters + '("GQuark" "domain") + '("gint" "code") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstevent.h + +(define-function _gst_event_initialize + (c-name "_gst_event_initialize") + (return-type "none") +) + +(define-function gst_event_get_type + (c-name "gst_event_get_type") + (return-type "GType") +) + +(define-function gst_event_new + (c-name "gst_event_new") + (is-constructor-of "GstEvent") + (return-type "GstEvent*") + (parameters + '("GstEventType" "type") + ) +) + +(define-method s_contains + (of-object "GstEventMask") + (c-name "gst_event_masks_contains") + (return-type "gboolean") + (parameters + '("GstEventMask*" "mask") + ) +) + +(define-function gst_event_new_seek + (c-name "gst_event_new_seek") + (return-type "GstEvent*") + (parameters + '("GstSeekType" "type") + '("gint64" "offset") + ) +) + +(define-function gst_event_new_segment_seek + (c-name "gst_event_new_segment_seek") + (return-type "GstEvent*") + (parameters + '("GstSeekType" "type") + '("gint64" "start") + '("gint64" "stop") + ) +) + +(define-function gst_event_new_size + (c-name "gst_event_new_size") + (return-type "GstEvent*") + (parameters + '("GstFormat" "format") + '("gint64" "value") + ) +) + +(define-function gst_event_new_discontinuous + (c-name "gst_event_new_discontinuous") + (return-type "GstEvent*") + (parameters + '("gboolean" "new_media") + '("GstFormat" "format1") + ) + (varargs #t) +) + +(define-function gst_event_new_discontinuous_valist + (c-name "gst_event_new_discontinuous_valist") + (return-type "GstEvent*") + (parameters + '("gboolean" "new_media") + '("GstFormat" "format1") + '("va_list" "var_args") + ) +) + +(define-method discont_get_value + (of-object "GstEvent") + (c-name "gst_event_discont_get_value") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + '("gint64*" "value") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstfilter.h + +(define-function gst_filter_run + (c-name "gst_filter_run") + (return-type "GList*") + (parameters + '("const-GList*" "list") + '("GstFilterFunc" "func") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstformat.h + +(define-function _gst_format_initialize + (c-name "_gst_format_initialize") + (return-type "none") +) + +(define-function gst_format_register + (c-name "gst_format_register") + (return-type "GstFormat") + (parameters + '("const-gchar*" "nick") + '("const-gchar*" "description") + ) +) + +(define-function gst_format_get_by_nick + (c-name "gst_format_get_by_nick") + (return-type "GstFormat") + (parameters + '("const-gchar*" "nick") + ) +) + +(define-method s_contains + (of-object "GstFormat") + (c-name "gst_formats_contains") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + ) +) + +(define-method get_details + (of-object "GstFormat") + (c-name "gst_format_get_details") + (return-type "const-GstFormatDefinition*") +) + +(define-function gst_format_get_definitions + (c-name "gst_format_get_definitions") + (return-type "const-GList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gst.h + +(define-function gst_init + (c-name "gst_init") + (return-type "none") + (parameters + '("int*" "argc") + '("char**[]" "argv") + ) +) + +(define-function gst_init_check + (c-name "gst_init_check") + (return-type "gboolean") + (parameters + '("int*" "argc") + '("char**[]" "argv") + ) +) + +(define-function gst_init_with_popt_table + (c-name "gst_init_with_popt_table") + (return-type "none") + (parameters + '("int*" "argc") + '("char**[]" "argv") + '("const-GstPoptOption*" "popt_options") + ) +) + +(define-function gst_init_check_with_popt_table + (c-name "gst_init_check_with_popt_table") + (return-type "gboolean") + (parameters + '("int*" "argc") + '("char**[]" "argv") + '("const-GstPoptOption*" "popt_options") + ) +) + +(define-function gst_init_get_popt_table + (c-name "gst_init_get_popt_table") + (return-type "const-GstPoptOption*") +) + +(define-function gst_use_threads + (c-name "gst_use_threads") + (return-type "none") + (parameters + '("gboolean" "use_threads") + ) +) + +(define-function gst_has_threads + (c-name "gst_has_threads") + (return-type "gboolean") +) + +(define-function gst_main + (c-name "gst_main") + (return-type "none") +) + +(define-function gst_main_quit + (c-name "gst_main_quit") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstindex.h + +(define-function gst_index_get_type + (c-name "gst_index_get_type") + (return-type "GType") +) + +(define-function gst_index_new + (c-name "gst_index_new") + (is-constructor-of "GstIndex") + (return-type "GstIndex*") +) + +(define-method commit + (of-object "GstIndex") + (c-name "gst_index_commit") + (return-type "none") + (parameters + '("gint" "id") + ) +) + +(define-method get_group + (of-object "GstIndex") + (c-name "gst_index_get_group") + (return-type "gint") +) + +(define-method new_group + (of-object "GstIndex") + (c-name "gst_index_new_group") + (return-type "gint") +) + +(define-method set_group + (of-object "GstIndex") + (c-name "gst_index_set_group") + (return-type "gboolean") + (parameters + '("gint" "groupnum") + ) +) + +(define-method set_certainty + (of-object "GstIndex") + (c-name "gst_index_set_certainty") + (return-type "none") + (parameters + '("GstIndexCertainty" "certainty") + ) +) + +(define-method get_certainty + (of-object "GstIndex") + (c-name "gst_index_get_certainty") + (return-type "GstIndexCertainty") +) + +(define-method set_filter + (of-object "GstIndex") + (c-name "gst_index_set_filter") + (return-type "none") + (parameters + '("GstIndexFilter" "filter") + '("gpointer" "user_data") + ) +) + +(define-method set_resolver + (of-object "GstIndex") + (c-name "gst_index_set_resolver") + (return-type "none") + (parameters + '("GstIndexResolver" "resolver") + '("gpointer" "user_data") + ) +) + +(define-method get_writer_id + (of-object "GstIndex") + (c-name "gst_index_get_writer_id") + (return-type "gboolean") + (parameters + '("GstObject*" "writer") + '("gint*" "id") + ) +) + +(define-method add_format + (of-object "GstIndex") + (c-name "gst_index_add_format") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstFormat" "format") + ) +) + +(define-method add_association + (of-object "GstIndex") + (c-name "gst_index_add_association") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + ) + (varargs #t) +) + +(define-method add_object + (of-object "GstIndex") + (c-name "gst_index_add_object") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("gchar*" "key") + '("GType" "type") + '("gpointer" "object") + ) +) + +(define-method add_id + (of-object "GstIndex") + (c-name "gst_index_add_id") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("gchar*" "description") + ) +) + +(define-method get_assoc_entry + (of-object "GstIndex") + (c-name "gst_index_get_assoc_entry") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstIndexLookupMethod" "method") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + ) +) + +(define-method get_assoc_entry_full + (of-object "GstIndex") + (c-name "gst_index_get_assoc_entry_full") + (return-type "GstIndexEntry*") + (parameters + '("gint" "id") + '("GstIndexLookupMethod" "method") + '("GstAssocFlags" "flags") + '("GstFormat" "format") + '("gint64" "value") + '("GCompareDataFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-function gst_index_entry_get_type + (c-name "gst_index_entry_get_type") + (return-type "GType") +) + +(define-method copy + (of-object "GstIndexEntry") + (c-name "gst_index_entry_copy") + (return-type "GstIndexEntry*") +) + +(define-method free + (of-object "GstIndexEntry") + (c-name "gst_index_entry_free") + (return-type "none") +) + +(define-method assoc_map + (of-object "GstIndexEntry") + (c-name "gst_index_entry_assoc_map") + (return-type "gboolean") + (parameters + '("GstFormat" "format") + '("gint64*" "value") + ) +) + +(define-function gst_index_factory_get_type + (c-name "gst_index_factory_get_type") + (return-type "GType") +) + +(define-function gst_index_factory_new + (c-name "gst_index_factory_new") + (is-constructor-of "GstIndexFactory") + (return-type "GstIndexFactory*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "longdesc") + '("GType" "type") + ) +) + +(define-method destroy + (of-object "GstIndexFactory") + (c-name "gst_index_factory_destroy") + (return-type "none") +) + +(define-function gst_index_factory_find + (c-name "gst_index_factory_find") + (return-type "GstIndexFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method create + (of-object "GstIndexFactory") + (c-name "gst_index_factory_create") + (return-type "GstIndex*") +) + +(define-function gst_index_factory_make + (c-name "gst_index_factory_make") + (return-type "GstIndex*") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstinfo.h + +(define-function _gst_debug_init + (c-name "_gst_debug_init") + (return-type "none") +) + +(define-function gst_debug_log + (c-name "gst_debug_log") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function gst_debug_log_valist + (c-name "gst_debug_log_valist") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("const-gchar*" "format") + '("va_list" "args") + ) +) + +(define-method get + (of-object "GstDebugMessage") + (c-name "gst_debug_message_get") + (return-type "const-gchar*") +) + +(define-function gst_debug_log_default + (c-name "gst_debug_log_default") + (return-type "none") + (parameters + '("GstDebugCategory*" "category") + '("GstDebugLevel" "level") + '("const-gchar*" "file") + '("const-gchar*" "function") + '("gint" "line") + '("GObject*" "object") + '("GstDebugMessage*" "message") + '("gpointer" "unused") + ) +) + +(define-method get_name + (of-object "GstDebugLevel") + (c-name "gst_debug_level_get_name") + (return-type "const-gchar*") +) + +(define-function gst_debug_add_log_function + (c-name "gst_debug_add_log_function") + (return-type "none") + (parameters + '("GstLogFunction" "func") + '("gpointer" "data") + ) +) + +(define-function gst_debug_remove_log_function + (c-name "gst_debug_remove_log_function") + (return-type "guint") + (parameters + '("GstLogFunction" "func") + ) +) + +(define-function gst_debug_remove_log_function_by_data + (c-name "gst_debug_remove_log_function_by_data") + (return-type "guint") + (parameters + '("gpointer" "data") + ) +) + +(define-function gst_debug_set_active + (c-name "gst_debug_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-function gst_debug_is_active + (c-name "gst_debug_is_active") + (return-type "gboolean") +) + +(define-function gst_debug_set_colored + (c-name "gst_debug_set_colored") + (return-type "none") + (parameters + '("gboolean" "colored") + ) +) + +(define-function gst_debug_is_colored + (c-name "gst_debug_is_colored") + (return-type "gboolean") +) + +(define-function gst_debug_set_default_threshold + (c-name "gst_debug_set_default_threshold") + (return-type "none") + (parameters + '("GstDebugLevel" "level") + ) +) + +(define-function gst_debug_get_default_threshold + (c-name "gst_debug_get_default_threshold") + (return-type "GstDebugLevel") +) + +(define-function gst_debug_set_threshold_for_name + (c-name "gst_debug_set_threshold_for_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("GstDebugLevel" "level") + ) +) + +(define-function gst_debug_unset_threshold_for_name + (c-name "gst_debug_unset_threshold_for_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function _gst_debug_category_new + (c-name "_gst_debug_category_new") + (is-constructor-of "GstDebugCategory") + (return-type "GstDebugCategory*") + (parameters + '("gchar*" "name") + '("guint" "color") + '("gchar*" "description") + ) +) + +(define-method free + (of-object "GstDebugCategory") + (c-name "gst_debug_category_free") + (return-type "none") +) + +(define-method set_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_set_threshold") + (return-type "none") + (parameters + '("GstDebugLevel" "level") + ) +) + +(define-method reset_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_reset_threshold") + (return-type "none") +) + +(define-method get_threshold + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_threshold") + (return-type "GstDebugLevel") +) + +(define-method get_name + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_name") + (return-type "const-gchar*") +) + +(define-method get_color + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_color") + (return-type "guint") +) + +(define-method get_description + (of-object "GstDebugCategory") + (c-name "gst_debug_category_get_description") + (return-type "const-gchar*") +) + +(define-function gst_debug_get_all_categories + (c-name "gst_debug_get_all_categories") + (return-type "GSList*") +) + +(define-function gst_debug_construct_term_color + (c-name "gst_debug_construct_term_color") + (return-type "gchar*") + (parameters + '("guint" "colorinfo") + ) +) + +(define-function _gst_debug_register_funcptr + (c-name "_gst_debug_register_funcptr") + (return-type "void*") + (parameters + '("void*" "ptr") + '("gchar*" "ptrname") + ) +) + +(define-function _gst_debug_nameof_funcptr + (c-name "_gst_debug_nameof_funcptr") + (return-type "const-gchar*") + (parameters + '("void*" "ptr") + ) +) + +(define-function gst_debug_print_stack_trace + (c-name "gst_debug_print_stack_trace") + (return-type "none") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstinterface.h + +(define-function gst_implements_interface_get_type + (c-name "gst_implements_interface_get_type") + (return-type "GType") +) + +(define-method implements_interface + (of-object "GstElement") + (c-name "gst_element_implements_interface") + (return-type "gboolean") + (parameters + '("GType" "iface_type") + ) +) + +(define-function gst_implements_interface_cast + (c-name "gst_implements_interface_cast") + (return-type "gpointer") + (parameters + '("gpointer" "from") + '("GType" "type") + ) +) + +(define-function gst_implements_interface_check + (c-name "gst_implements_interface_check") + (return-type "gboolean") + (parameters + '("gpointer" "from") + '("GType" "type") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstlog.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmacros.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmarshal.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstmemchunk.h + +(define-function gst_mem_chunk_new + (c-name "gst_mem_chunk_new") + (is-constructor-of "GstMemChunk") + (return-type "GstMemChunk*") + (parameters + '("gchar*" "name") + '("gint" "atom_size") + '("gulong" "area_size") + '("gint" "type") + ) +) + +(define-method destroy + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_destroy") + (return-type "none") +) + +(define-method alloc + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_alloc") + (return-type "gpointer") +) + +(define-method alloc0 + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_alloc0") + (return-type "gpointer") +) + +(define-method free + (of-object "GstMemChunk") + (c-name "gst_mem_chunk_free") + (return-type "none") + (parameters + '("gpointer" "mem") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstobject.h + +(define-function gst_object_get_type + (c-name "gst_object_get_type") + (return-type "GType") +) + +(define-method set_name + (of-object "GstObject") + (c-name "gst_object_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_name + (of-object "GstObject") + (c-name "gst_object_get_name") + (return-type "const-gchar*") +) + +(define-method set_parent + (of-object "GstObject") + (c-name "gst_object_set_parent") + (return-type "none") + (parameters + '("GstObject*" "parent") + ) +) + +(define-method get_parent + (of-object "GstObject") + (c-name "gst_object_get_parent") + (return-type "GstObject*") +) + +(define-method unparent + (of-object "GstObject") + (c-name "gst_object_unparent") + (return-type "none") +) + +(define-function gst_object_default_deep_notify + (c-name "gst_object_default_deep_notify") + (return-type "none") + (parameters + '("GObject*" "object") + '("GstObject*" "orig") + '("GParamSpec*" "pspec") + '("gchar**" "excluded_props") + ) +) + +(define-function gst_object_check_uniqueness + (c-name "gst_object_check_uniqueness") + (return-type "gboolean") + (parameters + '("GList*" "list") + '("const-gchar*" "name") + ) +) + +(define-method save_thyself + (of-object "GstObject") + (c-name "gst_object_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "parent") + ) +) + +(define-method restore_thyself + (of-object "GstObject") + (c-name "gst_object_restore_thyself") + (return-type "none") + (parameters + '("xmlNodePtr" "self") + ) +) + +(define-method ref + (of-object "GstObject") + (c-name "gst_object_ref") + (return-type "GstObject*") +) + +(define-method unref + (of-object "GstObject") + (c-name "gst_object_unref") + (return-type "none") +) + +(define-method sink + (of-object "GstObject") + (c-name "gst_object_sink") + (return-type "none") +) + +(define-function gst_object_replace + (c-name "gst_object_replace") + (return-type "none") + (parameters + '("GstObject**" "oldobj") + '("GstObject*" "newobj") + ) +) + +(define-method get_path_string + (of-object "GstObject") + (c-name "gst_object_get_path_string") + (return-type "gchar*") +) + +(define-function gst_class_signal_connect + (c-name "gst_class_signal_connect") + (return-type "guint") + (parameters + '("GstObjectClass*" "klass") + '("const-gchar*" "name") + '("gpointer" "func") + '("gpointer" "func_data") + ) +) + +(define-function gst_class_signal_emit_by_name + (c-name "gst_class_signal_emit_by_name") + (return-type "none") + (parameters + '("GstObject*" "object") + '("const-gchar*" "name") + '("xmlNodePtr" "self") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpad.h + +(define-function gst_pad_get_type + (c-name "gst_pad_get_type") + (return-type "GType") +) + +(define-function gst_real_pad_get_type + (c-name "gst_real_pad_get_type") + (return-type "GType") +) + +(define-function gst_ghost_pad_get_type + (c-name "gst_ghost_pad_get_type") + (return-type "GType") +) + +(define-function gst_pad_new + (c-name "gst_pad_new") + (is-constructor-of "GstPad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + '("GstPadDirection" "direction") + ) +) + +(define-function gst_pad_new_from_template + (c-name "gst_pad_new_from_template") + (return-type "GstPad*") + (parameters + '("GstPadTemplate*" "templ") + '("const-gchar*" "name") + ) +) + +(define-function gst_pad_custom_new + (c-name "gst_pad_custom_new") + (is-constructor-of "GstPadCustom") + (return-type "GstPad*") + (parameters + '("GType" "type") + '("const-gchar*" "name") + '("GstPadDirection" "direction") + ) +) + +(define-function gst_pad_custom_new_from_template + (c-name "gst_pad_custom_new_from_template") + (return-type "GstPad*") + (parameters + '("GType" "type") + '("GstPadTemplate*" "templ") + '("const-gchar*" "name") + ) +) + +(define-method set_name + (of-object "GstPad") + (c-name "gst_pad_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_name + (of-object "GstPad") + (c-name "gst_pad_get_name") + (return-type "const-gchar*") +) + +(define-method get_direction + (of-object "GstPad") + (c-name "gst_pad_get_direction") + (return-type "GstPadDirection") +) + +(define-method set_active + (of-object "GstPad") + (c-name "gst_pad_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method is_active + (of-object "GstPad") + (c-name "gst_pad_is_active") + (return-type "gboolean") +) + +(define-method set_element_private + (of-object "GstPad") + (c-name "gst_pad_set_element_private") + (return-type "none") + (parameters + '("gpointer" "priv") + ) +) + +(define-method get_element_private + (of-object "GstPad") + (c-name "gst_pad_get_element_private") + (return-type "gpointer") +) + +(define-method set_parent + (of-object "GstPad") + (c-name "gst_pad_set_parent") + (return-type "none") + (parameters + '("GstElement*" "parent") + ) +) + +(define-method get_parent + (of-object "GstPad") + (c-name "gst_pad_get_parent") + (return-type "GstElement*") +) + +(define-method get_real_parent + (of-object "GstPad") + (c-name "gst_pad_get_real_parent") + (return-type "GstElement*") +) + +(define-method get_scheduler + (of-object "GstPad") + (c-name "gst_pad_get_scheduler") + (return-type "GstScheduler*") +) + +(define-method add_ghost_pad + (of-object "GstPad") + (c-name "gst_pad_add_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "ghostpad") + ) +) + +(define-method remove_ghost_pad + (of-object "GstPad") + (c-name "gst_pad_remove_ghost_pad") + (return-type "none") + (parameters + '("GstPad*" "ghostpad") + ) +) + +(define-method get_ghost_pad_list + (of-object "GstPad") + (c-name "gst_pad_get_ghost_pad_list") + (return-type "GList*") +) + +(define-method get_pad_template + (of-object "GstPad") + (c-name "gst_pad_get_pad_template") + (return-type "GstPadTemplate*") +) + +(define-method set_bufferalloc_function + (of-object "GstPad") + (c-name "gst_pad_set_bufferalloc_function") + (return-type "none") + (parameters + '("GstPadBufferAllocFunction" "bufferalloc") + ) +) + +(define-method alloc_buffer + (of-object "GstPad") + (c-name "gst_pad_alloc_buffer") + (return-type "GstBuffer*") + (parameters + '("guint64" "offset") + '("gint" "size") + ) +) + +(define-method set_chain_function + (of-object "GstPad") + (c-name "gst_pad_set_chain_function") + (return-type "none") + (parameters + '("GstPadChainFunction" "chain") + ) +) + +(define-method set_get_function + (of-object "GstPad") + (c-name "gst_pad_set_get_function") + (return-type "none") + (parameters + '("GstPadGetFunction" "get") + ) +) + +(define-method set_event_function + (of-object "GstPad") + (c-name "gst_pad_set_event_function") + (return-type "none") + (parameters + '("GstPadEventFunction" "event") + ) +) + +(define-method set_event_mask_function + (of-object "GstPad") + (c-name "gst_pad_set_event_mask_function") + (return-type "none") + (parameters + '("GstPadEventMaskFunction" "mask_func") + ) +) + +(define-method get_event_masks + (of-object "GstPad") + (c-name "gst_pad_get_event_masks") + (return-type "const-GstEventMask*") +) + +(define-method get_event_masks_default + (of-object "GstPad") + (c-name "gst_pad_get_event_masks_default") + (return-type "const-GstEventMask*") +) + +(define-method set_link_function + (of-object "GstPad") + (c-name "gst_pad_set_link_function") + (return-type "none") + (parameters + '("GstPadLinkFunction" "link") + ) +) + +(define-method can_link + (of-object "GstPad") + (c-name "gst_pad_can_link") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method can_link_filtered + (of-object "GstPad") + (c-name "gst_pad_can_link_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method set_unlink_function + (of-object "GstPad") + (c-name "gst_pad_set_unlink_function") + (return-type "none") + (parameters + '("GstPadUnlinkFunction" "unlink") + ) +) + +(define-method link + (of-object "GstPad") + (c-name "gst_pad_link") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method link_filtered + (of-object "GstPad") + (c-name "gst_pad_link_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method unlink + (of-object "GstPad") + (c-name "gst_pad_unlink") + (return-type "none") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method is_linked + (of-object "GstPad") + (c-name "gst_pad_is_linked") + (return-type "gboolean") +) + +(define-method get_peer + (of-object "GstPad") + (c-name "gst_pad_get_peer") + (return-type "GstPad*") +) + +(define-method get_negotiated_caps + (of-object "GstPad") + (c-name "gst_pad_get_negotiated_caps") + (return-type "const-GstCaps*") +) + +(define-method is_negotiated + (of-object "GstPad") + (c-name "gst_pad_is_negotiated") + (return-type "gboolean") +) + +(define-method get_caps + (of-object "GstPad") + (c-name "gst_pad_get_caps") + (return-type "GstCaps*") +) + +(define-method get_pad_template_caps + (of-object "GstPad") + (c-name "gst_pad_get_pad_template_caps") + (return-type "const-GstCaps*") +) + +(define-method try_set_caps + (of-object "GstPad") + (c-name "gst_pad_try_set_caps") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method try_set_caps_nonfixed + (of-object "GstPad") + (c-name "gst_pad_try_set_caps_nonfixed") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method check_compatibility + (of-object "GstPad") + (c-name "gst_pad_check_compatibility") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method set_getcaps_function + (of-object "GstPad") + (c-name "gst_pad_set_getcaps_function") + (return-type "none") + (parameters + '("GstPadGetCapsFunction" "getcaps") + ) +) + +(define-method set_fixate_function + (of-object "GstPad") + (c-name "gst_pad_set_fixate_function") + (return-type "none") + (parameters + '("GstPadFixateFunction" "fixate") + ) +) + +(define-method proxy_getcaps + (of-object "GstPad") + (c-name "gst_pad_proxy_getcaps") + (return-type "GstCaps*") +) + +(define-method proxy_pad_link + (of-object "GstPad") + (c-name "gst_pad_proxy_pad_link") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method proxy_fixate + (of-object "GstPad") + (c-name "gst_pad_proxy_fixate") + (return-type "GstCaps*") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method proxy_link + (of-object "GstPad") + (c-name "gst_pad_proxy_link") + (return-type "GstPadLinkReturn") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method set_explicit_caps + (of-object "GstPad") + (c-name "gst_pad_set_explicit_caps") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "caps") + ) +) + +(define-method use_explicit_caps + (of-object "GstPad") + (c-name "gst_pad_use_explicit_caps") + (return-type "none") +) + +(define-method relink_filtered + (of-object "GstPad") + (c-name "gst_pad_relink_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method perform_negotiate + (of-object "GstPad") + (c-name "gst_pad_perform_negotiate") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + ) +) + +(define-method renegotiate + (of-object "GstPad") + (c-name "gst_pad_renegotiate") + (return-type "GstPadLinkReturn") +) + +(define-method unnegotiate + (of-object "GstPad") + (c-name "gst_pad_unnegotiate") + (return-type "none") +) + +(define-method try_relink_filtered + (of-object "GstPad") + (c-name "gst_pad_try_relink_filtered") + (return-type "gboolean") + (parameters + '("GstPad*" "sinkpad") + '("const-GstCaps*" "filtercaps") + ) +) + +(define-method get_allowed_caps + (of-object "GstPad") + (c-name "gst_pad_get_allowed_caps") + (return-type "GstCaps*") +) + +(define-method caps_change_notify + (of-object "GstPad") + (c-name "gst_pad_caps_change_notify") + (return-type "none") +) + +(define-method recover_caps_error + (of-object "GstPad") + (c-name "gst_pad_recover_caps_error") + (return-type "gboolean") + (parameters + '("const-GstCaps*" "allowed") + ) +) + +(define-method push + (of-object "GstPad") + (c-name "gst_pad_push") + (return-type "none") + (parameters + '("GstData*" "data") + ) +) + +(define-method pull + (of-object "GstPad") + (c-name "gst_pad_pull") + (return-type "GstData*") +) + +(define-method send_event + (of-object "GstPad") + (c-name "gst_pad_send_event") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-method event_default + (of-object "GstPad") + (c-name "gst_pad_event_default") + (return-type "gboolean") + (parameters + '("GstEvent*" "event") + ) +) + +(define-function gst_pad_selectv + (c-name "gst_pad_selectv") + (return-type "GstPad*") + (parameters + '("GList*" "padlist") + ) +) + +(define-method select + (of-object "GstPad") + (c-name "gst_pad_select") + (return-type "GstPad*") + (parameters + ) + (varargs #t) +) + +(define-method select_valist + (of-object "GstPad") + (c-name "gst_pad_select_valist") + (return-type "GstPad*") + (parameters + '("va_list" "varargs") + ) +) + +(define-method set_formats_function + (of-object "GstPad") + (c-name "gst_pad_set_formats_function") + (return-type "none") + (parameters + '("GstPadFormatsFunction" "formats") + ) +) + +(define-method get_formats + (of-object "GstPad") + (c-name "gst_pad_get_formats") + (return-type "const-GstFormat*") +) + +(define-method get_formats_default + (of-object "GstPad") + (c-name "gst_pad_get_formats_default") + (return-type "const-GstFormat*") +) + +(define-method set_convert_function + (of-object "GstPad") + (c-name "gst_pad_set_convert_function") + (return-type "none") + (parameters + '("GstPadConvertFunction" "convert") + ) +) + +(define-method convert + (of-object "GstPad") + (c-name "gst_pad_convert") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method convert_default + (of-object "GstPad") + (c-name "gst_pad_convert_default") + (return-type "gboolean") + (parameters + '("GstFormat" "src_format") + '("gint64" "src_value") + '("GstFormat*" "dest_format") + '("gint64*" "dest_value") + ) +) + +(define-method set_query_function + (of-object "GstPad") + (c-name "gst_pad_set_query_function") + (return-type "none") + (parameters + '("GstPadQueryFunction" "query") + ) +) + +(define-method set_query_type_function + (of-object "GstPad") + (c-name "gst_pad_set_query_type_function") + (return-type "none") + (parameters + '("GstPadQueryTypeFunction" "type_func") + ) +) + +(define-method get_query_types + (of-object "GstPad") + (c-name "gst_pad_get_query_types") + (return-type "const-GstQueryType*") +) + +(define-method get_query_types_default + (of-object "GstPad") + (c-name "gst_pad_get_query_types_default") + (return-type "const-GstQueryType*") +) + +(define-method query + (of-object "GstPad") + (c-name "gst_pad_query") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method query_default + (of-object "GstPad") + (c-name "gst_pad_query_default") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + '("GstFormat*" "format") + '("gint64*" "value") + ) +) + +(define-method set_internal_link_function + (of-object "GstPad") + (c-name "gst_pad_set_internal_link_function") + (return-type "none") + (parameters + '("GstPadIntLinkFunction" "intlink") + ) +) + +(define-method get_internal_links + (of-object "GstPad") + (c-name "gst_pad_get_internal_links") + (return-type "GList*") +) + +(define-method get_internal_links_default + (of-object "GstPad") + (c-name "gst_pad_get_internal_links_default") + (return-type "GList*") +) + +(define-method dispatcher + (of-object "GstPad") + (c-name "gst_pad_dispatcher") + (return-type "gboolean") + (parameters + '("GstPadDispatcherFunction" "dispatch") + '("gpointer" "data") + ) +) + +(define-function gst_pad_load_and_link + (c-name "gst_pad_load_and_link") + (return-type "none") + (parameters + '("xmlNodePtr" "self") + '("GstObject*" "parent") + ) +) + +(define-function gst_ghost_pad_new + (c-name "gst_ghost_pad_new") + (is-constructor-of "GstGhostPad") + (return-type "GstPad*") + (parameters + '("const-gchar*" "name") + '("GstPad*" "pad") + ) +) + +(define-function gst_pad_template_get_type + (c-name "gst_pad_template_get_type") + (return-type "GType") +) + +(define-function gst_pad_template_new + (c-name "gst_pad_template_new") + (is-constructor-of "GstPadTemplate") + (return-type "GstPadTemplate*") + (parameters + '("const-gchar*" "name_template") + '("GstPadDirection" "direction") + '("GstPadPresence" "presence") + '("GstCaps*" "caps") + ) +) + +(define-method get + (of-object "GstStaticPadTemplate") + (c-name "gst_static_pad_template_get") + (return-type "GstPadTemplate*") +) + +(define-method get_caps + (of-object "GstPadTemplate") + (c-name "gst_pad_template_get_caps") + (return-type "const-GstCaps*") +) + +(define-method get_caps_by_name + (of-object "GstPadTemplate") + (c-name "gst_pad_template_get_caps_by_name") + (return-type "const-GstCaps*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_ghost_pad_save_thyself + (c-name "gst_ghost_pad_save_thyself") + (return-type "xmlNodePtr") + (parameters + '("GstPad*" "pad") + '("xmlNodePtr" "parent") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstparse.h + +(define-function gst_parse_error_quark + (c-name "gst_parse_error_quark") + (return-type "GQuark") +) + +(define-function gst_parse_launch + (c-name "gst_parse_launch") + (return-type "GstElement*") + (parameters + '("const-gchar*" "pipeline_description") + '("GError**" "error") + ) +) + +(define-function gst_parse_launchv + (c-name "gst_parse_launchv") + (return-type "GstElement*") + (parameters + '("const-gchar**" "argv") + '("GError**" "error") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpipeline.h + +(define-function gst_pipeline_get_type + (c-name "gst_pipeline_get_type") + (return-type "GType") +) + +(define-function gst_pipeline_new + (c-name "gst_pipeline_new") + (is-constructor-of "GstPipeline") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstpluginfeature.h + +(define-function gst_plugin_feature_get_type + (c-name "gst_plugin_feature_get_type") + (return-type "GType") +) + +(define-method ensure_loaded + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_ensure_loaded") + (return-type "gboolean") +) + +(define-method unload_thyself + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_unload_thyself") + (return-type "none") +) + +(define-method type_name_filter + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_type_name_filter") + (return-type "gboolean") + (parameters + '("GstTypeNameData*" "data") + ) +) + +(define-method set_rank + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_set_rank") + (return-type "none") + (parameters + '("guint" "rank") + ) +) + +(define-method set_name + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_rank + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_get_rank") + (return-type "guint") +) + +(define-method get_name + (of-object "GstPluginFeature") + (c-name "gst_plugin_feature_get_name") + (return-type "const-gchar*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstplugin.h + +(define-function gst_plugin_error_quark + (c-name "gst_plugin_error_quark") + (return-type "GQuark") +) + +(define-function gst_plugin_get_type + (c-name "gst_plugin_get_type") + (return-type "GType") +) + +(define-function _gst_plugin_initialize + (c-name "_gst_plugin_initialize") + (return-type "none") +) + +(define-function _gst_plugin_register_static + (c-name "_gst_plugin_register_static") + (return-type "none") + (parameters + '("GstPluginDesc*" "desc") + ) +) + +(define-method get_name + (of-object "GstPlugin") + (c-name "gst_plugin_get_name") + (return-type "const-gchar*") +) + +(define-method get_description + (of-object "GstPlugin") + (c-name "gst_plugin_get_description") + (return-type "const-gchar*") +) + +(define-method get_filename + (of-object "GstPlugin") + (c-name "gst_plugin_get_filename") + (return-type "const-gchar*") +) + +(define-method get_license + (of-object "GstPlugin") + (c-name "gst_plugin_get_license") + (return-type "const-gchar*") +) + +(define-method get_package + (of-object "GstPlugin") + (c-name "gst_plugin_get_package") + (return-type "const-gchar*") +) + +(define-method get_origin + (of-object "GstPlugin") + (c-name "gst_plugin_get_origin") + (return-type "const-gchar*") +) + +(define-method get_module + (of-object "GstPlugin") + (c-name "gst_plugin_get_module") + (return-type "GModule*") +) + +(define-method is_loaded + (of-object "GstPlugin") + (c-name "gst_plugin_is_loaded") + (return-type "gboolean") +) + +(define-method feature_filter + (of-object "GstPlugin") + (c-name "gst_plugin_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_plugin_list_feature_filter + (c-name "gst_plugin_list_feature_filter") + (return-type "GList*") + (parameters + '("GList*" "list") + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method name_filter + (of-object "GstPlugin") + (c-name "gst_plugin_name_filter") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_feature_list + (of-object "GstPlugin") + (c-name "gst_plugin_get_feature_list") + (return-type "GList*") +) + +(define-method find_feature + (of-object "GstPlugin") + (c-name "gst_plugin_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-function gst_plugin_load_file + (c-name "gst_plugin_load_file") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "filename") + '("GError**" "error") + ) +) + +(define-method unload_plugin + (of-object "GstPlugin") + (c-name "gst_plugin_unload_plugin") + (return-type "gboolean") +) + +(define-method add_feature + (of-object "GstPlugin") + (c-name "gst_plugin_add_feature") + (return-type "none") + (parameters + '("GstPluginFeature*" "feature") + ) +) + +(define-function gst_plugin_load + (c-name "gst_plugin_load") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_library_load + (c-name "gst_library_load") + (return-type "gboolean") + (parameters + '("const-gchar*" "name") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstprobe.h + +(define-function gst_probe_new + (c-name "gst_probe_new") + (is-constructor-of "GstProbe") + (return-type "GstProbe*") + (parameters + '("gboolean" "single_shot") + '("GstProbeCallback" "callback") + '("gpointer" "user_data") + ) +) + +(define-method destroy + (of-object "GstProbe") + (c-name "gst_probe_destroy") + (return-type "none") +) + +(define-method perform + (of-object "GstProbe") + (c-name "gst_probe_perform") + (return-type "gboolean") + (parameters + '("GstData**" "data") + ) +) + +(define-function gst_probe_dispatcher_new + (c-name "gst_probe_dispatcher_new") + (is-constructor-of "GstProbeDispatcher") + (return-type "GstProbeDispatcher*") +) + +(define-method destroy + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_destroy") + (return-type "none") +) + +(define-method init + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_init") + (return-type "none") +) + +(define-method set_active + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_set_active") + (return-type "none") + (parameters + '("gboolean" "active") + ) +) + +(define-method add_probe + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_add_probe") + (return-type "none") + (parameters + '("GstProbe*" "probe") + ) +) + +(define-method remove_probe + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_remove_probe") + (return-type "none") + (parameters + '("GstProbe*" "probe") + ) +) + +(define-method dispatch + (of-object "GstProbeDispatcher") + (c-name "gst_probe_dispatcher_dispatch") + (return-type "gboolean") + (parameters + '("GstData**" "data") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstquery.h + +(define-function _gst_query_type_initialize + (c-name "_gst_query_type_initialize") + (return-type "none") +) + +(define-function gst_query_type_register + (c-name "gst_query_type_register") + (return-type "GstQueryType") + (parameters + '("const-gchar*" "nick") + '("const-gchar*" "description") + ) +) + +(define-function gst_query_type_get_by_nick + (c-name "gst_query_type_get_by_nick") + (return-type "GstQueryType") + (parameters + '("const-gchar*" "nick") + ) +) + +(define-method s_contains + (of-object "GstQueryType") + (c-name "gst_query_types_contains") + (return-type "gboolean") + (parameters + '("GstQueryType" "type") + ) +) + +(define-method get_details + (of-object "GstQueryType") + (c-name "gst_query_type_get_details") + (return-type "const-GstQueryTypeDefinition*") +) + +(define-function gst_query_type_get_definitions + (c-name "gst_query_type_get_definitions") + (return-type "const-GList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstqueue.h + +(define-function gst_queue_get_type + (c-name "gst_queue_get_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstregistry.h + +(define-function gst_registry_get_type + (c-name "gst_registry_get_type") + (return-type "GType") +) + +(define-method load + (of-object "GstRegistry") + (c-name "gst_registry_load") + (return-type "gboolean") +) + +(define-method is_loaded + (of-object "GstRegistry") + (c-name "gst_registry_is_loaded") + (return-type "gboolean") +) + +(define-method save + (of-object "GstRegistry") + (c-name "gst_registry_save") + (return-type "gboolean") +) + +(define-method rebuild + (of-object "GstRegistry") + (c-name "gst_registry_rebuild") + (return-type "gboolean") +) + +(define-method unload + (of-object "GstRegistry") + (c-name "gst_registry_unload") + (return-type "gboolean") +) + +(define-method add_path + (of-object "GstRegistry") + (c-name "gst_registry_add_path") + (return-type "none") + (parameters + '("const-gchar*" "path") + ) +) + +(define-method get_path_list + (of-object "GstRegistry") + (c-name "gst_registry_get_path_list") + (return-type "GList*") +) + +(define-method clear_paths + (of-object "GstRegistry") + (c-name "gst_registry_clear_paths") + (return-type "none") +) + +(define-method add_plugin + (of-object "GstRegistry") + (c-name "gst_registry_add_plugin") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method remove_plugin + (of-object "GstRegistry") + (c-name "gst_registry_remove_plugin") + (return-type "none") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method plugin_filter + (of-object "GstRegistry") + (c-name "gst_registry_plugin_filter") + (return-type "GList*") + (parameters + '("GstPluginFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method feature_filter + (of-object "GstRegistry") + (c-name "gst_registry_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-method find_plugin + (of-object "GstRegistry") + (c-name "gst_registry_find_plugin") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method find_feature + (of-object "GstRegistry") + (c-name "gst_registry_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-method load_plugin + (of-object "GstRegistry") + (c-name "gst_registry_load_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method unload_plugin + (of-object "GstRegistry") + (c-name "gst_registry_unload_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-method update_plugin + (of-object "GstRegistry") + (c-name "gst_registry_update_plugin") + (return-type "GstRegistryReturn") + (parameters + '("GstPlugin*" "plugin") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstregistrypool.h + +(define-function gst_registry_pool_list + (c-name "gst_registry_pool_list") + (return-type "GList*") +) + +(define-method pool_add + (of-object "GstRegistry") + (c-name "gst_registry_pool_add") + (return-type "none") + (parameters + '("guint" "priority") + ) +) + +(define-method pool_remove + (of-object "GstRegistry") + (c-name "gst_registry_pool_remove") + (return-type "none") +) + +(define-function gst_registry_pool_add_plugin + (c-name "gst_registry_pool_add_plugin") + (return-type "none") + (parameters + '("GstPlugin*" "plugin") + ) +) + +(define-function gst_registry_pool_load_all + (c-name "gst_registry_pool_load_all") + (return-type "none") +) + +(define-function gst_registry_pool_plugin_filter + (c-name "gst_registry_pool_plugin_filter") + (return-type "GList*") + (parameters + '("GstPluginFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_registry_pool_feature_filter + (c-name "gst_registry_pool_feature_filter") + (return-type "GList*") + (parameters + '("GstPluginFeatureFilter" "filter") + '("gboolean" "first") + '("gpointer" "user_data") + ) +) + +(define-function gst_registry_pool_plugin_list + (c-name "gst_registry_pool_plugin_list") + (return-type "GList*") +) + +(define-function gst_registry_pool_feature_list + (c-name "gst_registry_pool_feature_list") + (return-type "GList*") + (parameters + '("GType" "type") + ) +) + +(define-function gst_registry_pool_find_plugin + (c-name "gst_registry_pool_find_plugin") + (return-type "GstPlugin*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_registry_pool_find_feature + (c-name "gst_registry_pool_find_feature") + (return-type "GstPluginFeature*") + (parameters + '("const-gchar*" "name") + '("GType" "type") + ) +) + +(define-function gst_registry_pool_get_prefered + (c-name "gst_registry_pool_get_prefered") + (return-type "GstRegistry*") + (parameters + '("GstRegistryFlags" "flags") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstscheduler.h + +(define-function gst_scheduler_get_type + (c-name "gst_scheduler_get_type") + (return-type "GType") +) + +(define-method setup + (of-object "GstScheduler") + (c-name "gst_scheduler_setup") + (return-type "none") +) + +(define-method reset + (of-object "GstScheduler") + (c-name "gst_scheduler_reset") + (return-type "none") +) + +(define-method add_element + (of-object "GstScheduler") + (c-name "gst_scheduler_add_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method remove_element + (of-object "GstScheduler") + (c-name "gst_scheduler_remove_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method add_scheduler + (of-object "GstScheduler") + (c-name "gst_scheduler_add_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched2") + ) +) + +(define-method remove_scheduler + (of-object "GstScheduler") + (c-name "gst_scheduler_remove_scheduler") + (return-type "none") + (parameters + '("GstScheduler*" "sched2") + ) +) + +(define-method state_transition + (of-object "GstScheduler") + (c-name "gst_scheduler_state_transition") + (return-type "GstElementStateReturn") + (parameters + '("GstElement*" "element") + '("gint" "transition") + ) +) + +(define-method scheduling_change + (of-object "GstScheduler") + (c-name "gst_scheduler_scheduling_change") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method lock_element + (of-object "GstScheduler") + (c-name "gst_scheduler_lock_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method unlock_element + (of-object "GstScheduler") + (c-name "gst_scheduler_unlock_element") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method yield + (of-object "GstScheduler") + (c-name "gst_scheduler_yield") + (return-type "gboolean") + (parameters + '("GstElement*" "element") + ) +) + +(define-method interrupt + (of-object "GstScheduler") + (c-name "gst_scheduler_interrupt") + (return-type "gboolean") + (parameters + '("GstElement*" "element") + ) +) + +(define-method error + (of-object "GstScheduler") + (c-name "gst_scheduler_error") + (return-type "none") + (parameters + '("GstElement*" "element") + ) +) + +(define-method pad_link + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_link") + (return-type "none") + (parameters + '("GstPad*" "srcpad") + '("GstPad*" "sinkpad") + ) +) + +(define-method pad_unlink + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_unlink") + (return-type "none") + (parameters + '("GstPad*" "srcpad") + '("GstPad*" "sinkpad") + ) +) + +(define-method pad_select + (of-object "GstScheduler") + (c-name "gst_scheduler_pad_select") + (return-type "GstPad*") + (parameters + '("GList*" "padlist") + ) +) + +(define-method clock_wait + (of-object "GstScheduler") + (c-name "gst_scheduler_clock_wait") + (return-type "GstClockReturn") + (parameters + '("GstElement*" "element") + '("GstClockID" "id") + '("GstClockTimeDiff*" "jitter") + ) +) + +(define-method iterate + (of-object "GstScheduler") + (c-name "gst_scheduler_iterate") + (return-type "gboolean") +) + +(define-method use_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_use_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method set_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_set_clock") + (return-type "none") + (parameters + '("GstClock*" "clock") + ) +) + +(define-method get_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_get_clock") + (return-type "GstClock*") +) + +(define-method auto_clock + (of-object "GstScheduler") + (c-name "gst_scheduler_auto_clock") + (return-type "none") +) + +(define-method show + (of-object "GstScheduler") + (c-name "gst_scheduler_show") + (return-type "none") +) + +(define-function gst_scheduler_factory_get_type + (c-name "gst_scheduler_factory_get_type") + (return-type "GType") +) + +(define-function gst_scheduler_factory_new + (c-name "gst_scheduler_factory_new") + (is-constructor-of "GstSchedulerFactory") + (return-type "GstSchedulerFactory*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "longdesc") + '("GType" "type") + ) +) + +(define-method destroy + (of-object "GstSchedulerFactory") + (c-name "gst_scheduler_factory_destroy") + (return-type "none") +) + +(define-function gst_scheduler_factory_find + (c-name "gst_scheduler_factory_find") + (return-type "GstSchedulerFactory*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method create + (of-object "GstSchedulerFactory") + (c-name "gst_scheduler_factory_create") + (return-type "GstScheduler*") + (parameters + '("GstElement*" "parent") + ) +) + +(define-function gst_scheduler_factory_make + (c-name "gst_scheduler_factory_make") + (return-type "GstScheduler*") + (parameters + '("const-gchar*" "name") + '("GstElement*" "parent") + ) +) + +(define-function gst_scheduler_factory_set_default_name + (c-name "gst_scheduler_factory_set_default_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_scheduler_factory_get_default_name + (c-name "gst_scheduler_factory_get_default_name") + (return-type "const-gchar*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gststructure.h + +(define-function gst_structure_get_type + (c-name "gst_structure_get_type") + (return-type "GType") +) + +(define-function _gst_structure_initialize + (c-name "_gst_structure_initialize") + (return-type "none") +) + +(define-function gst_structure_empty_new + (c-name "gst_structure_empty_new") + (is-constructor-of "GstStructureEmpty") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_structure_id_empty_new + (c-name "gst_structure_id_empty_new") + (is-constructor-of "GstStructureIdEmpty") + (return-type "GstStructure*") + (parameters + '("GQuark" "quark") + ) +) + +(define-function gst_structure_new + (c-name "gst_structure_new") + (is-constructor-of "GstStructure") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "firstfield") + ) + (varargs #t) +) + +(define-function gst_structure_new_valist + (c-name "gst_structure_new_valist") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "name") + '("const-gchar*" "firstfield") + '("va_list" "varargs") + ) +) + +(define-method copy + (of-object "GstStructure") + (c-name "gst_structure_copy") + (return-type "GstStructure*") +) + +(define-method free + (of-object "GstStructure") + (c-name "gst_structure_free") + (return-type "none") +) + +(define-method get_name + (of-object "GstStructure") + (c-name "gst_structure_get_name") + (return-type "const-gchar*") +) + +(define-method set_name + (of-object "GstStructure") + (c-name "gst_structure_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method id_set_value + (of-object "GstStructure") + (c-name "gst_structure_id_set_value") + (return-type "none") + (parameters + '("GQuark" "field") + '("const-GValue*" "value") + ) +) + +(define-method set_value + (of-object "GstStructure") + (c-name "gst_structure_set_value") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("const-GValue*" "value") + ) +) + +(define-method set + (of-object "GstStructure") + (c-name "gst_structure_set") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) + (varargs #t) +) + +(define-method set_valist + (of-object "GstStructure") + (c-name "gst_structure_set_valist") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("va_list" "varargs") + ) +) + +(define-method id_get_value + (of-object "GstStructure") + (c-name "gst_structure_id_get_value") + (return-type "const-GValue*") + (parameters + '("GQuark" "field") + ) +) + +(define-method get_value + (of-object "GstStructure") + (c-name "gst_structure_get_value") + (return-type "const-GValue*") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method remove_field + (of-object "GstStructure") + (c-name "gst_structure_remove_field") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method remove_fields + (of-object "GstStructure") + (c-name "gst_structure_remove_fields") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + ) + (varargs #t) +) + +(define-method remove_fields_valist + (of-object "GstStructure") + (c-name "gst_structure_remove_fields_valist") + (return-type "none") + (parameters + '("const-gchar*" "fieldname") + '("va_list" "varargs") + ) +) + +(define-method remove_all_fields + (of-object "GstStructure") + (c-name "gst_structure_remove_all_fields") + (return-type "none") +) + +(define-method get_field_type + (of-object "GstStructure") + (c-name "gst_structure_get_field_type") + (return-type "GType") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method foreach + (of-object "GstStructure") + (c-name "gst_structure_foreach") + (return-type "gboolean") + (parameters + '("GstStructureForeachFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method n_fields + (of-object "GstStructure") + (c-name "gst_structure_n_fields") + (return-type "gint") +) + +(define-method has_field + (of-object "GstStructure") + (c-name "gst_structure_has_field") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method has_field_typed + (of-object "GstStructure") + (c-name "gst_structure_has_field_typed") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("GType" "type") + ) +) + +(define-method get_boolean + (of-object "GstStructure") + (c-name "gst_structure_get_boolean") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gboolean*" "value") + ) +) + +(define-method get_int + (of-object "GstStructure") + (c-name "gst_structure_get_int") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gint*" "value") + ) +) + +(define-method get_fourcc + (of-object "GstStructure") + (c-name "gst_structure_get_fourcc") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("guint32*" "value") + ) +) + +(define-method get_double + (of-object "GstStructure") + (c-name "gst_structure_get_double") + (return-type "gboolean") + (parameters + '("const-gchar*" "fieldname") + '("gdouble*" "value") + ) +) + +(define-method get_string + (of-object "GstStructure") + (c-name "gst_structure_get_string") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "fieldname") + ) +) + +(define-method to_string + (of-object "GstStructure") + (c-name "gst_structure_to_string") + (return-type "gchar*") +) + +(define-function gst_structure_from_string + (c-name "gst_structure_from_string") + (return-type "GstStructure*") + (parameters + '("const-gchar*" "string") + '("gchar**" "end") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstsystemclock.h + +(define-function gst_system_clock_get_type + (c-name "gst_system_clock_get_type") + (return-type "GType") +) + +(define-function gst_system_clock_obtain + (c-name "gst_system_clock_obtain") + (return-type "GstClock*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttag.h + +(define-function _gst_tag_initialize + (c-name "_gst_tag_initialize") + (return-type "none") +) + +(define-function gst_tag_list_get_type + (c-name "gst_tag_list_get_type") + (return-type "GType") +) + +(define-function gst_tag_register + (c-name "gst_tag_register") + (return-type "none") + (parameters + '("gchar*" "name") + '("GstTagFlag" "flag") + '("GType" "type") + '("gchar*" "nick") + '("gchar*" "blurb") + '("GstTagMergeFunc" "func") + ) +) + +(define-function gst_tag_merge_use_first + (c-name "gst_tag_merge_use_first") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function gst_tag_merge_strings_with_comma + (c-name "gst_tag_merge_strings_with_comma") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function gst_tag_exists + (c-name "gst_tag_exists") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_type + (c-name "gst_tag_get_type") + (return-type "GType") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_nick + (c-name "gst_tag_get_nick") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_get_description + (c-name "gst_tag_get_description") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_is_fixed + (c-name "gst_tag_is_fixed") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-function gst_tag_list_new + (c-name "gst_tag_list_new") + (is-constructor-of "GstTagList") + (return-type "GstTagList*") +) + +(define-function gst_is_tag_list + (c-name "gst_is_tag_list") + (return-type "gboolean") + (parameters + '("gconstpointer" "p") + ) +) + +(define-method copy + (of-object "GstTagList") + (c-name "gst_tag_list_copy") + (return-type "GstTagList*") +) + +(define-method insert + (of-object "GstTagList") + (c-name "gst_tag_list_insert") + (return-type "none") + (parameters + '("const-GstTagList*" "from") + '("GstTagMergeMode" "mode") + ) +) + +(define-method merge + (of-object "GstTagList") + (c-name "gst_tag_list_merge") + (return-type "GstTagList*") + (parameters + '("const-GstTagList*" "list2") + '("GstTagMergeMode" "mode") + ) +) + +(define-method free + (of-object "GstTagList") + (c-name "gst_tag_list_free") + (return-type "none") +) + +(define-method get_tag_size + (of-object "GstTagList") + (c-name "gst_tag_list_get_tag_size") + (return-type "guint") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-method add + (of-object "GstTagList") + (c-name "gst_tag_list_add") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_values + (of-object "GstTagList") + (c-name "gst_tag_list_add_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_valist + (of-object "GstTagList") + (c-name "gst_tag_list_add_valist") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method add_valist_values + (of-object "GstTagList") + (c-name "gst_tag_list_add_valist_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method remove_tag + (of-object "GstTagList") + (c-name "gst_tag_list_remove_tag") + (return-type "none") + (parameters + '("const-gchar*" "tag") + ) +) + +(define-method foreach + (of-object "GstTagList") + (c-name "gst_tag_list_foreach") + (return-type "none") + (parameters + '("GstTagForeachFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method get_value_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_value_index") + (return-type "const-GValue*") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + ) +) + +(define-function gst_tag_list_copy_value + (c-name "gst_tag_list_copy_value") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GstTagList*" "list") + '("const-gchar*" "tag") + ) +) + +(define-method get_char + (of-object "GstTagList") + (c-name "gst_tag_list_get_char") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gchar*" "value") + ) +) + +(define-method get_char_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_char_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gchar*" "value") + ) +) + +(define-method get_uchar + (of-object "GstTagList") + (c-name "gst_tag_list_get_uchar") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guchar*" "value") + ) +) + +(define-method get_uchar_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uchar_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guchar*" "value") + ) +) + +(define-method get_boolean + (of-object "GstTagList") + (c-name "gst_tag_list_get_boolean") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gboolean*" "value") + ) +) + +(define-method get_boolean_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_boolean_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gboolean*" "value") + ) +) + +(define-method get_int + (of-object "GstTagList") + (c-name "gst_tag_list_get_int") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gint*" "value") + ) +) + +(define-method get_int_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_int_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gint*" "value") + ) +) + +(define-method get_uint + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint*" "value") + ) +) + +(define-method get_uint_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guint*" "value") + ) +) + +(define-method get_long + (of-object "GstTagList") + (c-name "gst_tag_list_get_long") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("glong*" "value") + ) +) + +(define-method get_long_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_long_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("glong*" "value") + ) +) + +(define-method get_ulong + (of-object "GstTagList") + (c-name "gst_tag_list_get_ulong") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gulong*" "value") + ) +) + +(define-method get_ulong_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_ulong_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gulong*" "value") + ) +) + +(define-method get_int64 + (of-object "GstTagList") + (c-name "gst_tag_list_get_int64") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gint64*" "value") + ) +) + +(define-method get_int64_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_int64_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gint64*" "value") + ) +) + +(define-method get_uint64 + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint64") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint64*" "value") + ) +) + +(define-method get_uint64_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_uint64_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("guint64*" "value") + ) +) + +(define-method get_float + (of-object "GstTagList") + (c-name "gst_tag_list_get_float") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gfloat*" "value") + ) +) + +(define-method get_float_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_float_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gfloat*" "value") + ) +) + +(define-method get_double + (of-object "GstTagList") + (c-name "gst_tag_list_get_double") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gdouble*" "value") + ) +) + +(define-method get_double_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_double_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gdouble*" "value") + ) +) + +(define-method get_string + (of-object "GstTagList") + (c-name "gst_tag_list_get_string") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gchar**" "value") + ) +) + +(define-method get_string_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_string_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gchar**" "value") + ) +) + +(define-method get_pointer + (of-object "GstTagList") + (c-name "gst_tag_list_get_pointer") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("gpointer*" "value") + ) +) + +(define-method get_pointer_index + (of-object "GstTagList") + (c-name "gst_tag_list_get_pointer_index") + (return-type "gboolean") + (parameters + '("const-gchar*" "tag") + '("guint" "index") + '("gpointer*" "value") + ) +) + +(define-function gst_event_new_tag + (c-name "gst_event_new_tag") + (return-type "GstEvent*") + (parameters + '("GstTagList*" "list") + ) +) + +(define-method tag_get_list + (of-object "GstEvent") + (c-name "gst_event_tag_get_list") + (return-type "GstTagList*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttaginterface.h + +(define-function gst_tag_setter_get_type + (c-name "gst_tag_setter_get_type") + (return-type "GType") +) + +(define-method merge + (of-object "GstTagSetter") + (c-name "gst_tag_setter_merge") + (return-type "none") + (parameters + '("const-GstTagList*" "list") + '("GstTagMergeMode" "mode") + ) +) + +(define-method add + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_values + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + ) + (varargs #t) +) + +(define-method add_valist + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_valist") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method add_valist_values + (of-object "GstTagSetter") + (c-name "gst_tag_setter_add_valist_values") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + '("const-gchar*" "tag") + '("va_list" "var_args") + ) +) + +(define-method get_list + (of-object "GstTagSetter") + (c-name "gst_tag_setter_get_list") + (return-type "const-GstTagList*") +) + +(define-method set_merge_mode + (of-object "GstTagSetter") + (c-name "gst_tag_setter_set_merge_mode") + (return-type "none") + (parameters + '("GstTagMergeMode" "mode") + ) +) + +(define-method get_merge_mode + (of-object "GstTagSetter") + (c-name "gst_tag_setter_get_merge_mode") + (return-type "GstTagMergeMode") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstthread.h + +(define-function gst_thread_get_type + (c-name "gst_thread_get_type") + (return-type "GType") +) + +(define-function gst_thread_new + (c-name "gst_thread_new") + (is-constructor-of "GstThread") + (return-type "GstElement*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method set_priority + (of-object "GstThread") + (c-name "gst_thread_set_priority") + (return-type "none") + (parameters + '("GThreadPriority" "priority") + ) +) + +(define-function gst_thread_get_current + (c-name "gst_thread_get_current") + (return-type "GstThread*") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttrace.h + +(define-function gst_trace_new + (c-name "gst_trace_new") + (is-constructor-of "GstTrace") + (return-type "GstTrace*") + (parameters + '("gchar*" "filename") + '("gint" "size") + ) +) + +(define-method destroy + (of-object "GstTrace") + (c-name "gst_trace_destroy") + (return-type "none") +) + +(define-method flush + (of-object "GstTrace") + (c-name "gst_trace_flush") + (return-type "none") +) + +(define-method text_flush + (of-object "GstTrace") + (c-name "gst_trace_text_flush") + (return-type "none") +) + +(define-method set_default + (of-object "GstTrace") + (c-name "gst_trace_set_default") + (return-type "none") +) + +(define-method _add_entry + (of-object "GstTrace") + (c-name "_gst_trace_add_entry") + (return-type "none") + (parameters + '("guint32" "seq") + '("guint32" "data") + '("gchar*" "msg") + ) +) + +(define-function gst_trace_read_tsc + (c-name "gst_trace_read_tsc") + (return-type "none") + (parameters + '("gint64*" "dst") + ) +) + +(define-function gst_alloc_trace_available + (c-name "gst_alloc_trace_available") + (return-type "gboolean") +) + +(define-function gst_alloc_trace_list + (c-name "gst_alloc_trace_list") + (return-type "const-GList*") +) + +(define-function _gst_alloc_trace_register + (c-name "_gst_alloc_trace_register") + (return-type "GstAllocTrace*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-function gst_alloc_trace_live_all + (c-name "gst_alloc_trace_live_all") + (return-type "int") +) + +(define-function gst_alloc_trace_print_all + (c-name "gst_alloc_trace_print_all") + (return-type "none") +) + +(define-function gst_alloc_trace_set_flags_all + (c-name "gst_alloc_trace_set_flags_all") + (return-type "none") + (parameters + '("GstAllocTraceFlags" "flags") + ) +) + +(define-function gst_alloc_trace_get + (c-name "gst_alloc_trace_get") + (return-type "GstAllocTrace*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method print + (of-object "GstAllocTrace") + (c-name "gst_alloc_trace_print") + (return-type "none") +) + +(define-method set_flags + (of-object "GstAllocTrace") + (c-name "gst_alloc_trace_set_flags") + (return-type "none") + (parameters + '("GstAllocTraceFlags" "flags") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttrashstack.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttypefind.h + +(define-method peek + (of-object "GstTypeFind") + (c-name "gst_type_find_peek") + (return-type "guint8*") + (parameters + '("gint64" "offset") + '("guint" "size") + ) +) + +(define-method suggest + (of-object "GstTypeFind") + (c-name "gst_type_find_suggest") + (return-type "none") + (parameters + '("guint" "probability") + '("const-GstCaps*" "caps") + ) +) + +(define-method get_length + (of-object "GstTypeFind") + (c-name "gst_type_find_get_length") + (return-type "guint64") +) + +(define-function gst_type_find_register + (c-name "gst_type_find_register") + (return-type "gboolean") + (parameters + '("GstPlugin*" "plugin") + '("const-gchar*" "name") + '("guint" "rank") + '("GstTypeFindFunction" "func") + '("gchar**" "extensions") + '("const-GstCaps*" "possible_caps") + '("gpointer" "data") + ) +) + +(define-function gst_type_find_factory_get_type + (c-name "gst_type_find_factory_get_type") + (return-type "GType") +) + +(define-function gst_type_find_factory_get_list + (c-name "gst_type_find_factory_get_list") + (return-type "GList*") +) + +(define-method get_extensions + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_get_extensions") + (return-type "gchar**") +) + +(define-method get_caps + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_get_caps") + (return-type "const-GstCaps*") +) + +(define-method call_function + (of-object "GstTypeFindFactory") + (c-name "gst_type_find_factory_call_function") + (return-type "none") + (parameters + '("GstTypeFind*" "find") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsttypes.h + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsturi.h + +(define-function gst_uri_protocol_is_valid + (c-name "gst_uri_protocol_is_valid") + (return-type "gboolean") + (parameters + '("const-gchar*" "protocol") + ) +) + +(define-function gst_uri_is_valid + (c-name "gst_uri_is_valid") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_get_protocol + (c-name "gst_uri_get_protocol") + (return-type "gchar*") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_get_location + (c-name "gst_uri_get_location") + (return-type "gchar*") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function gst_uri_construct + (c-name "gst_uri_construct") + (return-type "gchar*") + (parameters + '("const-gchar*" "protocol") + '("const-gchar*" "location") + ) +) + +(define-function gst_element_make_from_uri + (c-name "gst_element_make_from_uri") + (return-type "GstElement*") + (parameters + '("const-GstURIType" "type") + '("const-gchar*" "uri") + '("const-gchar*" "elementname") + ) +) + +(define-function gst_uri_handler_get_type + (c-name "gst_uri_handler_get_type") + (return-type "GType") +) + +(define-method get_uri_type + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_uri_type") + (return-type "guint") +) + +(define-method get_protocols + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_protocols") + (return-type "gchar**") +) + +(define-method get_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_get_uri") + (return-type "const-gchar*") +) + +(define-method set_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_set_uri") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-method new_uri + (of-object "GstURIHandler") + (c-name "gst_uri_handler_new_uri") + (return-type "none") + (parameters + '("const-gchar*" "uri") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gsturitype.h + +(define-function gst_uri_get_uri_type + (c-name "gst_uri_get_uri_type") + (return-type "GType") +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstutils.h + +(define-function gst_util_set_value_from_string + (c-name "gst_util_set_value_from_string") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-gchar*" "value_str") + ) +) + +(define-function gst_util_set_object_arg + (c-name "gst_util_set_object_arg") + (return-type "none") + (parameters + '("GObject*" "object") + '("const-gchar*" "name") + '("const-gchar*" "value") + ) +) + +(define-function gst_util_dump_mem + (c-name "gst_util_dump_mem") + (return-type "none") + (parameters + '("guchar*" "mem") + '("guint" "size") + ) +) + +(define-function gst_print_pad_caps + (c-name "gst_print_pad_caps") + (return-type "none") + (parameters + '("GString*" "buf") + '("gint" "indent") + '("GstPad*" "pad") + ) +) + +(define-function gst_print_element_args + (c-name "gst_print_element_args") + (return-type "none") + (parameters + '("GString*" "buf") + '("gint" "indent") + '("GstElement*" "element") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstvalue.h + +(define-function gst_value_list_prepend_value + (c-name "gst_value_list_prepend_value") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GValue*" "prepend_value") + ) +) + +(define-function gst_value_list_append_value + (c-name "gst_value_list_append_value") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GValue*" "append_value") + ) +) + +(define-function gst_value_list_get_size + (c-name "gst_value_list_get_size") + (return-type "guint") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_list_get_value + (c-name "gst_value_list_get_value") + (return-type "const-GValue*") + (parameters + '("const-GValue*" "value") + '("guint" "index") + ) +) + +(define-function gst_value_list_concat + (c-name "gst_value_list_concat") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_set_fourcc + (c-name "gst_value_set_fourcc") + (return-type "none") + (parameters + '("GValue*" "value") + '("guint32" "fourcc") + ) +) + +(define-function gst_value_get_fourcc + (c-name "gst_value_get_fourcc") + (return-type "guint32") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_int_range + (c-name "gst_value_set_int_range") + (return-type "none") + (parameters + '("GValue*" "value") + '("int" "start") + '("int" "end") + ) +) + +(define-function gst_value_get_int_range_min + (c-name "gst_value_get_int_range_min") + (return-type "int") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_int_range_max + (c-name "gst_value_get_int_range_max") + (return-type "int") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_double_range + (c-name "gst_value_set_double_range") + (return-type "none") + (parameters + '("GValue*" "value") + '("double" "start") + '("double" "end") + ) +) + +(define-function gst_value_get_double_range_min + (c-name "gst_value_get_double_range_min") + (return-type "double") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_double_range_max + (c-name "gst_value_get_double_range_max") + (return-type "double") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_get_caps + (c-name "gst_value_get_caps") + (return-type "const-GstCaps*") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_set_caps + (c-name "gst_value_set_caps") + (return-type "none") + (parameters + '("GValue*" "value") + '("const-GstCaps*" "caps") + ) +) + +(define-function gst_value_can_compare + (c-name "gst_value_can_compare") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_compare + (c-name "gst_value_compare") + (return-type "int") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_can_union + (c-name "gst_value_can_union") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_union + (c-name "gst_value_union") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_register_union_func + (c-name "gst_value_register_union_func") + (return-type "none") + (parameters + '("GType" "type1") + '("GType" "type2") + '("GstValueUnionFunc" "func") + ) +) + +(define-function gst_value_can_intersect + (c-name "gst_value_can_intersect") + (return-type "gboolean") + (parameters + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_intersect + (c-name "gst_value_intersect") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-GValue*" "value1") + '("const-GValue*" "value2") + ) +) + +(define-function gst_value_register_intersect_func + (c-name "gst_value_register_intersect_func") + (return-type "none") + (parameters + '("GType" "type1") + '("GType" "type2") + '("GstValueIntersectFunc" "func") + ) +) + +(define-function gst_value_register + (c-name "gst_value_register") + (return-type "none") + (parameters + '("const-GstValueTable*" "table") + ) +) + +(define-function gst_value_init_and_copy + (c-name "gst_value_init_and_copy") + (return-type "none") + (parameters + '("GValue*" "dest") + '("const-GValue*" "src") + ) +) + +(define-function _gst_value_initialize + (c-name "_gst_value_initialize") + (return-type "none") +) + +(define-function gst_value_serialize + (c-name "gst_value_serialize") + (return-type "gchar*") + (parameters + '("const-GValue*" "value") + ) +) + +(define-function gst_value_deserialize + (c-name "gst_value_deserialize") + (return-type "gboolean") + (parameters + '("GValue*" "dest") + '("const-gchar*" "src") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstversion.h + +(define-function gst_version + (c-name "gst_version") + (return-type "none") + (parameters + '("guint*" "major") + '("guint*" "minor") + '("guint*" "micro") + ) +) + + + +;; From /opt/gnome/include/gstreamer-0.7/gst/gstxml.h + +(define-function gst_xml_get_type + (c-name "gst_xml_get_type") + (return-type "GType") +) + +(define-function gst_xml_write + (c-name "gst_xml_write") + (return-type "xmlDocPtr") + (parameters + '("GstElement*" "element") + ) +) + +(define-function gst_xml_write_file + (c-name "gst_xml_write_file") + (return-type "gint") + (parameters + '("GstElement*" "element") + '("FILE*" "out") + ) +) + +(define-function gst_xml_new + (c-name "gst_xml_new") + (is-constructor-of "GstXml") + (return-type "GstXML*") +) + +(define-method parse_doc + (of-object "GstXML") + (c-name "gst_xml_parse_doc") + (return-type "gboolean") + (parameters + '("xmlDocPtr" "doc") + '("const-guchar*" "root") + ) +) + +(define-method parse_file + (of-object "GstXML") + (c-name "gst_xml_parse_file") + (return-type "gboolean") + (parameters + '("const-guchar*" "fname") + '("const-guchar*" "root") + ) +) + +(define-method parse_memory + (of-object "GstXML") + (c-name "gst_xml_parse_memory") + (return-type "gboolean") + (parameters + '("guchar*" "buffer") + '("guint" "size") + '("const-gchar*" "root") + ) +) + +(define-method get_element + (of-object "GstXML") + (c-name "gst_xml_get_element") + (return-type "GstElement*") + (parameters + '("const-guchar*" "name") + ) +) + +(define-method get_topelements + (of-object "GstXML") + (c-name "gst_xml_get_topelements") + (return-type "GList*") +) + +(define-function gst_xml_make_element + (c-name "gst_xml_make_element") + (return-type "GstElement*") + (parameters + '("xmlNodePtr" "cur") + '("GstObject*" "parent") + ) +) + + +;; -*- scheme -*- +;; +;; Boxed types +;; + +(define-boxed Buffer + (in-module "Gst") + (c-name "GstBuffer") + (gtype-id "GST_TYPE_BUFFER") +) + +(define-boxed Caps + (in-module "Gst") + (c-name "GstCaps") + (gtype-id "GST_TYPE_CAPS") +) + +(define-boxed Event + (in-module "Gst") + (c-name "GstEvent") + (gtype-id "GST_TYPE_EVENT") +) + +;; +;; Accelerate common GstBin iterate loop +;; + +(define-function iterate_bin_all + (c-name "iterate_bin_all") + (return-type "none") + (parameters + '("GstBin*" "bin") + ) +) + +(define-function add_iterate_bin + (c-name "add_iterate_bin") + (return-type "guint") + (parameters + '("GstBin*" "bin") + ) +) + +(define-function remove_iterate_bin + (c-name "remove_iterate_bin") + (return-type "none") + (parameters + '("guint" "id") + ) +) + +;; +;; HACK +;; + +(define-method get_data + (of-object "GstBuffer") + (c-name "gst_buffer_get_data") + (return-type "char*") +) + +(define-method set_data + (of-object "GstBuffer") + (c-name "gst_buffer_set_data") + (return-type "none") + (parameters + '("char*" "data") + ) +) + + +;; +;; 0.7 Boxed types +;; + +(define-boxed Structure + (in-module "Gst") + (c-name "GstStructure") + (gtype-id "GST_TYPE_STRUCTURE") +) + +(define-boxed TagList + (in-module "Gst") + (c-name "GstTagList") + (gtype-id "GST_TYPE_TAG_LIST") +)