/* -*- Mode: C; c-basic-offset: 4 -*- */ * vi:si:et:sw=4:sts=4:ts=4 * * gst-python * Copyright (C) 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 * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * * Author: Johan Dahlin name) { \ g_closure_invalidate (priv->name); \ g_closure_unref (priv->name); \ } \ priv->name = closure; \ pad = (GstPad*)pygobject_get(self); \ gst_pad_set_ ## name (pad, call_ ## name); \ \ Py_INCREF(Py_None); \ return Py_None; static void free_pad_private (gpointer data) { PyGstPadPrivate *private = data; #define INVALIDATE_CLOSURE(closure) \ if (closure) { \ g_closure_invalidate (closure); \ g_closure_unref (closure); \ closure = NULL; \ } INVALIDATE_CLOSURE (private->link_function) INVALIDATE_CLOSURE (private->event_function) INVALIDATE_CLOSURE (private->chain_function) INVALIDATE_CLOSURE (private->get_function) INVALIDATE_CLOSURE (private->getcaps_function) INVALIDATE_CLOSURE (private->setcaps_function) INVALIDATE_CLOSURE (private->activate_function) INVALIDATE_CLOSURE (private->activatepull_function) INVALIDATE_CLOSURE (private->activatepush_function) #undef INVALIDATE_CLOSURE if (private->query_function) { Py_DECREF (private->query_function); private->query_function = NULL; } } static PyGstPadPrivate* pad_private(GstPad *pad) { PyGstPadPrivate *private; static GQuark padprivate = 0; if (!padprivate) padprivate = g_quark_from_static_string ("PyGst::PadPrivate"); private = g_object_get_qdata (G_OBJECT (pad), padprivate); if (private == NULL) { private = g_new0(PyGstPadPrivate, 1); private->pad = (PyGObject *) pygobject_new (G_OBJECT (pad)); Py_DECREF (private->pad); g_object_set_qdata_full (G_OBJECT (pad), padprivate, private, free_pad_private); } return private; } static PyGstPadPrivate* py_pad_private(PyGObject *pad) { return pad_private ((GstPad *)pygobject_get(pad)); } %% ignore gst_pad_select gst_pad_selectv gst_pad_new_from_template gst_pad_load_and_link %% override gst_pad_set_getcaps_function kwargs static void EXCEPTION_HANDLER handle_getcaps_function_exception (GValue *ret, guint n, const GValue *params) { g_value_set_boxed (ret, gst_pad_get_pad_template_caps ( GST_PAD (g_value_get_object (¶ms[0])))); PyErr_Clear (); } static GstCaps * call_getcaps_function (GstPad *pad) { GClosure *closure; GValue ret = { 0, }; GValue args = { 0, }; GstCaps *caps; g_value_init (&ret, GST_TYPE_CAPS); g_value_init (&args, GST_TYPE_PAD); g_value_set_object (&args, pad); closure = pad_private(pad)->getcaps_function; g_closure_invoke (closure, &ret, 1, &args, NULL); caps = g_value_dup_boxed (&ret); g_value_unset (&ret); g_value_unset (&args); return caps; } static PyObject* _wrap_gst_pad_set_getcaps_function (PyGObject *self, PyObject *args, PyObject *kwargs) { SET_PAD_CLOSURE (self, args, kwargs, getcaps_function) } %% override gst_pad_set_link_function kwargs static void EXCEPTION_HANDLER handle_link_function_exception (GValue *ret, guint n, const GValue *params) { g_value_set_enum (ret, GST_PAD_LINK_REFUSED); PyErr_Clear (); } static GstPadLinkReturn call_link_function (GstPad *pad, GstPad *peer) { GClosure *closure; GValue ret = { 0, }; GValue args[2] = { { 0, }, {0, } }; GstPadLinkReturn i; g_value_init (&ret, GST_TYPE_PAD_LINK_RETURN); g_value_init (&args[0], GST_TYPE_PAD); g_value_init (&args[1], GST_TYPE_PAD); g_value_set_object (&args[0], pad); g_value_set_object (&args[1], peer); closure = pad_private(pad)->link_function; g_closure_invoke (closure, &ret, 2, args, NULL); i = g_value_get_enum (&ret); g_value_unset (&ret); g_value_unset (&args[0]); g_value_unset (&args[1]); return i; } static PyObject* _wrap_gst_pad_set_link_function (PyGObject *self, PyObject *args, PyObject *kwargs) { SET_PAD_CLOSURE (self, args, kwargs, link_function) } %% override gst_pad_set_chain_function kwargs static void EXCEPTION_HANDLER handle_chain_function_exception (GValue *ret, guint n, const GValue *params) { GstElement *element = GST_ELEMENT (gst_object_get_parent (g_value_get_object (¶ms[0]))); if (!_pygst_element_check_error (element)) { g_assert_not_reached (); /* only returns FALSE when there's no error */ } } static GstFlowReturn call_chain_function(GstPad *pad, GstBuffer *buffer) { GClosure *closure; GValue ret = { 0, }; GValue args[2] = { { 0, }, { 0, } }; GstFlowReturn flow; g_value_init (&ret, GST_TYPE_FLOW_RETURN); g_value_set_enum (&ret, GST_FLOW_ERROR); g_value_init (&args[0], GST_TYPE_PAD); g_value_init (&args[1], GST_TYPE_BUFFER); g_value_set_object (&args[0], pad); gst_value_set_mini_object (&args[1], GST_MINI_OBJECT (buffer)); closure = pad_private(pad)->chain_function; g_closure_invoke (closure, &ret, 2, args, NULL); flow = g_value_get_enum (&ret); g_value_unset (&ret); g_value_unset (&args[0]); g_value_unset (&args[1]); /* a chain function takes over the ref of the buffer handed to it; * so we should unref after calling the pythonic chain func */ gst_buffer_unref (buffer); return flow; } static PyObject* _wrap_gst_pad_set_chain_function(PyGObject *self, PyObject *args, PyObject *kwargs) { SET_PAD_CLOSURE (self, args, kwargs, chain_function) } %% override gst_pad_set_event_function kwargs static void EXCEPTION_HANDLER handle_event_function_exception (GValue *ret, guint n, const GValue *params) { GstElement *element = GST_ELEMENT (gst_pad_get_parent (g_value_get_object (¶ms[0]))); if (!_pygst_element_check_error (element)) { g_assert_not_reached (); /* only returns FALSE when there's no error */ } } static gboolean call_event_function (GstPad *pad, GstEvent *event) { GClosure *closure; GValue ret = { 0, }; GValue args[2] = { { 0, }, { 0, } }; gboolean bool; g_value_init (&ret, G_TYPE_BOOLEAN); g_value_set_boolean (&ret, FALSE); g_value_init (&args[0], GST_TYPE_PAD); g_value_init (&args[1], GST_TYPE_EVENT); g_value_set_object (&args[0], pad); gst_value_set_mini_object (&args[1], GST_MINI_OBJECT (event)); closure = pad_private(pad)->event_function; g_closure_invoke (closure, &ret, 2, args, NULL); bool = g_value_get_boolean (&ret); g_value_unset (&ret); g_value_unset (&args[0]); g_value_unset (&args[1]); return bool; } static PyObject* _wrap_gst_pad_set_event_function (PyGObject *self, PyObject *args, PyObject *kwargs) { SET_PAD_CLOSURE (self, args, kwargs, event_function) } %% override gst_pad_set_query_function kwargs static gboolean pypad_copy_struct_members (GQuark field_id, const GValue * value, GstStructure* to_structure) { gst_structure_id_set_value (to_structure, field_id, value); return TRUE; } static gboolean call_query_function (GstPad *pad, GstQuery *query) { PyGILState_STATE __py_state; PyGObject *py_pad; PyGstPadPrivate *priv; PyObject *py_ret; PyObject *py_args; gboolean ret = FALSE; GstQuery *query_copy; PyObject *py_query; /* Push our GIL state */ __py_state = pyg_gil_state_ensure(); /* Get the python version of the pad */ py_pad = (PyGObject *) pygobject_new((GObject*) (pad)); if (!py_pad) { if (PyErr_Occurred()) PyErr_Print(); goto beach; } /* Private data, where our callback should be stored */ priv = py_pad_private(py_pad); if (priv->query_function == NULL) { /* FIXME: Generate an error message somewhere? */ Py_DECREF(py_pad); goto beach; } /* Create our arguments tuple and populate */ py_args = PyTuple_New(2); /* We copy the query into a new one so that it can have a refcount * of exactly 1 and be owned by python */ pyg_begin_allow_threads; query_copy = gst_query_copy (query); pyg_end_allow_threads; py_query = pygstminiobject_new((GstMiniObject *)query_copy); gst_query_unref (query_copy); PyTuple_SetItem(py_args, 0, (PyObject *) (py_pad)); PyTuple_SetItem(py_args, 1, py_query); /* Perform the callback into python, then parse the result */ py_ret = PyObject_CallObject(priv->query_function, py_args); if (!py_ret) { if (PyErr_Occurred()) PyErr_Print(); Py_DECREF(py_args); goto beach; } ret = (py_ret == Py_True ? TRUE : FALSE); /* If the query succeeded, copy the result back into the original query. * We still have a refcount to it, because we didn't unref the py_query * wrapper yet. */ if (ret) { /* I feel ill violating the poor query like this, but it's the only * way to transfer data from our copy back to the original query */ GstStructure *from, *to; pyg_begin_allow_threads; from = GST_QUERY (query_copy)->structure; to = query->structure; gst_structure_foreach (from, (GstStructureForeachFunc) pypad_copy_struct_members, to); pyg_end_allow_threads; } Py_DECREF(py_args); Py_DECREF(py_ret); beach: pyg_gil_state_release(__py_state); return ret; } static PyObject* _wrap_gst_pad_set_query_function (PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "query_function", NULL }; PyObject *function; GstPad *pad; PyGstPadPrivate *priv; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GstPad.set_query_function", kwlist, &function)) { return NULL; } pad = (GstPad*)pygobject_get(self); priv = py_pad_private(self); /* Allow setting query_function to None to clear it to NULL */ if (function == Py_None) { if (priv->query_function) { Py_DECREF (priv->query_function); priv->query_function = NULL; } gst_pad_set_query_function (pad, NULL); goto out; } if (!PyCallable_Check(function)) { PyErr_SetString(PyExc_TypeError, "Passed query_function not callable"); return NULL; } if (priv->query_function) { Py_DECREF (priv->query_function); } Py_INCREF(function); priv->query_function = function; gst_pad_set_query_function (pad, call_query_function); out: Py_INCREF(Py_None); return Py_None; } %% override gst_pad_set_setcaps_function kwargs static void EXCEPTION_HANDLER handle_setcaps_function_exception (GValue *ret, guint n, const GValue *params) { GstElement *element = GST_ELEMENT (gst_pad_get_parent (g_value_get_object (¶ms[0]))); if (!_pygst_element_check_error (element)) { g_assert_not_reached (); /* only returns FALSE when there's no error */ } } static gboolean call_setcaps_function (GstPad *pad, GstCaps *caps) { GClosure *closure; GValue ret = { 0, }; GValue args[2] = { { 0, }, { 0, } }; gboolean bool; g_value_init (&ret, G_TYPE_BOOLEAN); g_value_set_boolean (&ret, FALSE); g_value_init (&args[0], GST_TYPE_PAD); g_value_init (&args[1], GST_TYPE_CAPS); g_value_set_object (&args[0], pad); gst_value_set_caps (&args[1], (const GstCaps*) caps); closure = pad_private(pad)->setcaps_function; g_closure_invoke (closure, &ret, 2, args, NULL); bool = g_value_get_boolean (&ret); g_value_unset (&ret); g_value_unset (&args[0]); g_value_unset (&args[1]); return bool; } static PyObject* _wrap_gst_pad_set_setcaps_function (PyGObject *self, PyObject *args, PyObject *kwargs) { SET_PAD_CLOSURE (self, args, kwargs, setcaps_function) } %% override gst_pad_set_activate_function kwargs static void EXCEPTION_HANDLER handle_activate_function_exception (GValue * ret, guint n, const GValue * params) { GstElement *element = GST_ELEMENT (gst_pad_get_parent (g_value_get_object (¶ms[0]))); if (!_pygst_element_check_error (element)) { g_assert_not_reached (); /* only returns FALSE when there's no error */ } } static gboolean call_activate_function (GstPad * pad) { GClosure * closure; GValue ret = { 0, }; GValue args[1] = { {0, }}; gboolean bool; g_value_init (&ret, G_TYPE_BOOLEAN); g_value_set_boolean (&ret, FALSE); g_value_init(&args[0], GST_TYPE_PAD); g_value_set_object (&args[0], pad); closure = pad_private(pad)->activate_function; g_closure_invoke (closure, &ret, 1, args, NULL); bool = g_value_get_boolean (&ret); g_value_unset (&ret); g_value_unset (&args[0]); return bool; } static PyObject * _wrap_gst_pad_set_activate_function (PyGObject *self, PyObject *args, PyObject *kwargs) { SET_PAD_CLOSURE (self, args, kwargs, activate_function) } %% override gst_pad_set_activatepull_function kwargs static void EXCEPTION_HANDLER handle_activatepull_function_exception (GValue * ret, guint n, const GValue * params) { GstElement *element = GST_ELEMENT (gst_pad_get_parent (g_value_get_object (¶ms[0]))); if (!_pygst_element_check_error (element)) { g_assert_not_reached (); /* only returns FALSE when there's no error */ } } static gboolean call_activatepull_function (GstPad * pad, gboolean active) { GClosure * closure; GValue ret = { 0, }; GValue args[2] = { {0, }, {0, } }; gboolean bool; g_value_init (&ret, G_TYPE_BOOLEAN); g_value_set_boolean (&ret, FALSE); g_value_init (&args[0], GST_TYPE_PAD); g_value_set_object (&args[0], pad); g_value_init (&args[1], G_TYPE_BOOLEAN); g_value_set_boolean (&args[1], active); closure = pad_private(pad)->activatepull_function; g_closure_invoke (closure, &ret, 2, args, NULL); bool = g_value_get_boolean (&ret); g_value_unset (&ret); g_value_unset (&args[0]); g_value_unset (&args[1]); return bool; } static PyObject * _wrap_gst_pad_set_activatepull_function (PyGObject *self, PyObject *args, PyObject *kwargs) { SET_PAD_CLOSURE (self, args, kwargs, activatepull_function); } %% override gst_pad_set_activatepush_function kwargs static void EXCEPTION_HANDLER handle_activatepush_function_exception (GValue * ret, guint n, const GValue * params) { GstElement *element = GST_ELEMENT (gst_pad_get_parent (g_value_get_object (¶ms[0]))); if (!_pygst_element_check_error (element)) { g_assert_not_reached (); /* only returns FALSE when there's no error */ } } static gboolean call_activatepush_function (GstPad * pad, gboolean active) { GClosure * closure; GValue ret = { 0, }; GValue args[2] = { {0, }, {0, }}; gboolean bool; g_value_init (&ret, G_TYPE_BOOLEAN); g_value_set_boolean (&ret, FALSE); g_value_init (&args[0], GST_TYPE_PAD); g_value_set_object (&args[0], pad); g_value_init (&args[1], G_TYPE_BOOLEAN); g_value_set_boolean (&args[1], active); closure = pad_private(pad)->activatepush_function; g_closure_invoke (closure, &ret, 2, args, NULL); bool = g_value_get_boolean (&ret); g_value_unset (&ret); g_value_unset (&args[0]); g_value_unset (&args[1]); return bool; } static PyObject * _wrap_gst_pad_set_activatepush_function (PyGObject *self, PyObject *args, PyObject *kwargs) { SET_PAD_CLOSURE (self, args, kwargs, activatepush_function); } %% override-slot GstPad.tp_repr static PyObject * _wrap_gst_pad_tp_repr (PyGObject *self) { char *buf; PyObject *retval; GstPad *pad; GstElement *parent; gchar *padname = NULL; gchar *elementname = NULL; pad = GST_PAD(self->obj); parent = GST_ELEMENT (gst_pad_get_parent (pad)); padname = gst_pad_get_name (pad); if (parent) elementname = gst_element_get_name (parent); buf = g_strdup_printf ("", parent ? elementname : "---", padname, (long) self->obj); if (parent) { gst_object_unref (parent); g_free(elementname); } g_free(padname); retval = PyString_FromString(buf); g_free(buf); return retval; } %% override gst_pad_query kwargs static PyObject * _wrap_gst_pad_query(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "query", NULL }; int ret; PyGstMiniObject *query; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!:GstPad.query", kwlist, &PyGstQuery_Type, &query)) return NULL; pyg_begin_allow_threads; ret = gst_pad_query(GST_PAD(self->obj), GST_QUERY (query->obj)); pyg_end_allow_threads; return PyBool_FromLong(ret); } %% override gst_pad_convert kwargs static PyObject * _wrap_gst_pad_convert(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "src_format", "src_value", "dest_format", NULL }; GstFormat src_format, dest_format; PyObject *src_value_obj; gint64 src_value, dest_value = 0; gboolean ret; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iOi:GstPad.convert", kwlist, &src_format, &src_value_obj, &dest_format)) return NULL; src_value = PyLong_AsLongLong(src_value_obj); ret = gst_pad_convert(GST_PAD(self->obj), src_format, src_value, &dest_format, &dest_value); return PyLong_FromLongLong(dest_value); } %% override gst_pad_link kwargs static PyObject * _wrap_gst_pad_link(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "sinkpad", NULL }; PyGObject *sinkpad; int ret; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!:GstPad.link", kwlist, &PyGstPad_Type, &sinkpad)) return NULL; ret = gst_pad_link(GST_PAD(self->obj), GST_PAD(sinkpad->obj)); if (ret) { PyObject *exc_val = pyg_enum_from_gtype(GST_TYPE_PAD_LINK_RETURN, ret); PyErr_SetObject(PyGstExc_LinkError, exc_val); Py_DECREF(exc_val); return NULL; } return PyBool_FromLong(ret); } %% override gst_pad_link_filtered kwargs static PyObject * _wrap_gst_pad_link_filtered(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "sinkpad", "filtercaps", NULL }; PyGObject *sinkpad; PyObject *py_filtercaps; int ret; GstCaps *filtercaps = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O:GstPad.link_filtered", kwlist, &PyGstPad_Type, &sinkpad, &py_filtercaps)) return NULL; if (pyg_boxed_check(py_filtercaps, GST_TYPE_CAPS)) filtercaps = pyg_boxed_get(py_filtercaps, GstCaps); else { PyErr_SetString(PyExc_TypeError, "filtercaps should be a GstCaps"); return NULL; } ret = gst_pad_link_filtered(GST_PAD(self->obj), GST_PAD(sinkpad->obj), filtercaps); if (ret) { PyObject *exc_val = pyg_enum_from_gtype(GST_TYPE_PAD_LINK_RETURN, ret); PyErr_SetObject(PyGstExc_LinkError, exc_val); Py_DECREF(exc_val); return NULL; } return PyBool_FromLong(ret); } %% override gst_pad_get_pad_template_caps noargs static PyObject * _wrap_gst_pad_get_pad_template_caps(PyGObject *self) { GstCaps *ret = (GstCaps*)gst_pad_get_pad_template_caps(GST_PAD(self->obj)); return pyg_boxed_new(GST_TYPE_CAPS, ret, TRUE, TRUE); } %% override gst_pad_template_get_caps noargs static PyObject * _wrap_gst_pad_template_get_caps(PyGObject *self) { GstCaps *ret = (GstCaps*)gst_pad_template_get_caps(GST_PAD_TEMPLATE(self->obj)); return pyg_boxed_new(GST_TYPE_CAPS, ret, TRUE, TRUE); } %% override gst_pad_template_get_caps_by_name kwargs static PyObject * _wrap_gst_pad_template_get_caps_by_name(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "name", NULL }; char *name; GstCaps *ret; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:GstPadTemplate.get_caps_by_name", kwlist, &name)) return NULL; ret = (GstCaps*)gst_pad_template_get_caps_by_name(GST_PAD_TEMPLATE(self->obj), name); /* pyg_boxed_new handles NULL checking */ return pyg_boxed_new(GST_TYPE_CAPS, ret, TRUE, TRUE); } %% new-constructor GST_TYPE_PAD %% override gst_pad_new kwargs static int _wrap_gst_pad_new(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "name", "direction", NULL }; static char *kwlist2[] = { "template", "name", NULL }; PyGObject *templ; char *name = NULL; PyObject *py_direction = NULL; GstPadDirection direction; if (PyArg_ParseTupleAndKeywords (args, kwargs, "zO:GstPad.__init__", kwlist, &name, &py_direction)) { GST_LOG ("gst.Pad.__init__: using gst_pad_new"); if (pyg_enum_get_value (GST_TYPE_PAD_DIRECTION, py_direction, (gint *) &direction)) { GST_LOG ("gst.Pad.__init__: direction is not valid"); return -1; } self->obj = (GObject *) gst_pad_new (name, direction); } else { PyErr_Clear (); GST_LOG ("gst.Pad.__init__: using gst_pad_new_from_template"); if (PyArg_ParseTupleAndKeywords (args, kwargs, "O!|s:GstPad.__init__", kwlist2, &PyGstPadTemplate_Type, &templ, &name)) { if (name == NULL) name = GST_PAD_TEMPLATE_NAME_TEMPLATE (GST_PAD_TEMPLATE ( templ->obj)); self->obj = (GObject *) gst_pad_new_from_template ( GST_PAD_TEMPLATE (templ->obj), name); } } if (!self->obj) { PyErr_SetString (PyExc_RuntimeError, "could not create GstPad object"); return -1; } pygobject_register_wrapper ((PyObject *)self); return 0; } %% override gst_pad_add_data_probe args static PyObject * _wrap_gst_pad_add_data_probe(PyGObject *self, PyObject *args) { GstPad *pad = GST_PAD(self->obj); PyObject *method = NULL; PyObject *rv = NULL; PyObject *mylist = PyList_New(1); PyObject *mynewlist = NULL; PyObject *myargs = NULL; PyObject *signalname = NULL; signalname = PyString_FromString("have-data"); if (PyList_SetItem(mylist, 0, signalname)) { Py_DECREF(mylist); return NULL; } mynewlist = PySequence_InPlaceConcat(mylist, args); Py_DECREF(mylist); if (!mynewlist) return NULL; myargs = PyList_AsTuple(mynewlist); Py_DECREF(mynewlist); if (!myargs) return NULL; method = PyObject_GetAttrString((PyObject*)self, "connect"); if (!method) { Py_DECREF(mylist); return NULL; } GST_OBJECT_LOCK (pad); rv = PyObject_CallObject(method, myargs); if (rv) { GST_PAD_DO_BUFFER_SIGNALS (pad)++; GST_PAD_DO_EVENT_SIGNALS (pad)++; } GST_OBJECT_UNLOCK (pad); Py_DECREF(myargs); Py_DECREF(method); return rv; } %% override gst_pad_add_event_probe args static PyObject * _wrap_gst_pad_add_event_probe(PyGObject *self, PyObject *args) { GstPad *pad = GST_PAD(self->obj); PyObject *method = NULL; PyObject *rv = NULL; PyObject *mylist = PyList_New(1); PyObject *mynewlist = NULL; PyObject *myargs = NULL; PyObject *signalname = NULL; signalname = PyString_FromString("have-data::event"); if (PyList_SetItem(mylist, 0, signalname)) { Py_DECREF(mylist); return NULL; } mynewlist = PySequence_InPlaceConcat(mylist, args); Py_DECREF(mylist); if (!mynewlist) return NULL; myargs = PyList_AsTuple(mynewlist); Py_DECREF(mynewlist); if (!myargs) return NULL; method = PyObject_GetAttrString((PyObject*)self, "connect"); if (!method) { Py_DECREF(mylist); return NULL; } GST_OBJECT_LOCK (pad); rv = PyObject_CallObject(method, myargs); if (rv) GST_PAD_DO_EVENT_SIGNALS (pad)++; GST_OBJECT_UNLOCK (pad); Py_DECREF(myargs); Py_DECREF(method); return rv; } %% override gst_pad_add_buffer_probe args static PyObject * _wrap_gst_pad_add_buffer_probe(PyGObject *self, PyObject *args) { GstPad *pad = GST_PAD(self->obj); PyObject *method = NULL; PyObject *rv = NULL; PyObject *mylist = PyList_New(1); PyObject *mynewlist = NULL; PyObject *myargs = NULL; PyObject *signalname = NULL; signalname = PyString_FromString("have-data::buffer"); if (PyList_SetItem(mylist, 0, signalname)) { Py_DECREF(mylist); return NULL; } mynewlist = PySequence_InPlaceConcat(mylist, args); Py_DECREF(mylist); if (!mynewlist) return NULL; myargs = PyList_AsTuple(mynewlist); Py_DECREF(mynewlist); if (!myargs) return NULL; method = PyObject_GetAttrString((PyObject*)self, "connect"); if (!method) { Py_DECREF(mylist); return NULL; } GST_OBJECT_LOCK (pad); rv = PyObject_CallObject(method, myargs); if (rv) GST_PAD_DO_BUFFER_SIGNALS (pad)++; GST_OBJECT_UNLOCK (pad); Py_DECREF(myargs); Py_DECREF(method); return rv; } %% override-slot GstPadTemplate.tp_getattr #define IS_ATTR(name) (strcmp (name, attr) == 0) PyObject * _wrap_gst_pad_template_tp_getattr(PyObject *self, char *attr) { GstPadTemplate *templ = GST_PAD_TEMPLATE (pygobject_get (self)); if (IS_ATTR ("__members__")) { return Py_BuildValue("[ssss]", "name_template", "direction", "presence", "caps" ); } else if (IS_ATTR ("name_template")) { return PyString_FromString (GST_PAD_TEMPLATE_NAME_TEMPLATE(templ)); } else if (IS_ATTR ("direction")) { return pyg_enum_from_gtype(GST_TYPE_PAD_DIRECTION, GST_PAD_TEMPLATE_DIRECTION(templ)); } else if (IS_ATTR ("presence")) { return pyg_enum_from_gtype(GST_TYPE_PAD_PRESENCE, GST_PAD_TEMPLATE_PRESENCE(templ)); } else if (IS_ATTR ("caps")) { return pyg_boxed_new (GST_TYPE_CAPS, GST_PAD_TEMPLATE_CAPS(templ), TRUE, TRUE); } return Py_FindMethod((PyMethodDef*) _PyGstPadTemplate_methods, self, attr); } %% override gst_pad_query_position args static PyObject * _wrap_gst_pad_query_position (PyGObject *self, PyObject *args) { gint64 cur; gint format; PyObject *pformat; PyObject *ret; pformat = (PyObject*)PyTuple_GetItem(args, 0); if (pyg_enum_get_value (GST_TYPE_FORMAT, pformat, &format)) { PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat"); return NULL; } if ((gst_pad_query_position(GST_PAD (self->obj), (GstFormat*) &format, &cur))) { ret = Py_BuildValue("(LO)", cur, pyg_enum_from_gtype (GST_TYPE_FORMAT, format)); } else { Py_INCREF(Py_None); ret = Py_None; } return ret; } %% override gst_pad_query_duration args static PyObject * _wrap_gst_pad_query_duration (PyGObject *self, PyObject *args) { gint64 cur; gint format; PyObject *pformat; PyObject *ret; pformat = (PyObject*)PyTuple_GetItem(args, 0); if (pyg_enum_get_value (GST_TYPE_FORMAT, pformat, &format)) { PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat"); return NULL; } if ((gst_pad_query_duration(GST_PAD (self->obj), (GstFormat*) &format, &cur))) { ret = Py_BuildValue("(LO)", cur, pyg_enum_from_gtype (GST_TYPE_FORMAT, format)); } else { Py_INCREF(Py_None); ret = Py_None; } return ret; } %% override gst_pad_query_convert kwargs static PyObject * _wrap_gst_pad_query_convert (PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "fromformat", "fromvalue", "destformat", NULL }; PyObject *pfromformat, *pdestformat; GstFormat srcformat, destformat; gint64 fromval, dstval; /* Input : src_format, src_val, dst_format */ /* Returns : dst_format, dst_val OR None */ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "0L0:GstPad.query_convert", kwlist, &pfromformat, &fromval, &pdestformat)) return NULL; if (pyg_enum_get_value(GST_TYPE_FORMAT, pfromformat, (gint *) &srcformat)) { PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat"); return NULL; } if (pyg_enum_get_value(GST_TYPE_FORMAT, pdestformat, (gint *) &destformat)) { PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat"); return NULL; } if (!(gst_pad_query_convert (GST_PAD(self->obj), srcformat, fromval, &destformat, &dstval))) { Py_INCREF(Py_None); return Py_None; } return Py_BuildValue("(OL)", pyg_enum_from_gtype (GST_TYPE_FORMAT, destformat), dstval); } %% override gst_pad_alloc_buffer kwargs static PyObject * _wrap_gst_pad_alloc_buffer (PyGObject *self, PyObject * args, PyObject *kwargs) { static char *kwlist[] = {"offset", "size", "caps", NULL}; guint64 offset; gint size; PyObject *pcaps; GstCaps *caps; PyObject *ret; GstBuffer *buf; GstFlowReturn res; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "KiO:GstPad.alloc_buffer", kwlist, &offset, &size, &pcaps)) return NULL; caps = pyg_boxed_get(pcaps, GstCaps); res = gst_pad_alloc_buffer (GST_PAD(pygobject_get(self)), offset, size, caps, &buf); ret = PyList_New(2); PyList_SetItem(ret, 0, pyg_enum_from_gtype(GST_TYPE_FLOW_RETURN, res)); if (res != GST_FLOW_OK) { PyList_SetItem(ret, 1, Py_None); } else { PyList_SetItem(ret, 1, pygstminiobject_new(GST_MINI_OBJECT(buf))); } return ret; } %% override gst_pad_alloc_buffer_and_set_caps kwargs static PyObject * _wrap_gst_pad_alloc_buffer_and_set_caps (PyGObject *self, PyObject * args, PyObject *kwargs) { static char *kwlist[] = {"offset", "size", "caps", NULL}; guint64 offset; gint size; PyObject *pcaps; GstCaps *caps; PyObject *ret; GstBuffer *buf; GstFlowReturn res; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "KiO:GstPad.alloc_buffer_and_set_caps", kwlist, &offset, &size, &pcaps)) return NULL; caps = pyg_boxed_get(pcaps, GstCaps); res = gst_pad_alloc_buffer_and_set_caps (GST_PAD(pygobject_get(self)), offset, size, caps, &buf); ret = PyList_New(2); PyList_SetItem(ret, 0, pyg_enum_from_gtype(GST_TYPE_FLOW_RETURN, res)); if (res != GST_FLOW_OK) { PyList_SetItem(ret, 1, Py_None); } else { PyList_SetItem(ret, 1, pygstminiobject_new(GST_MINI_OBJECT(buf))); } return ret; } %% override gst_pad_pull_range kwargs static PyObject * _wrap_gst_pad_pull_range (PyGObject *self, PyObject * args, PyObject *kwargs) { static char *kwlist[] = {"offset", "size", NULL}; guint64 offset; gint size; PyObject *ret; GstBuffer *buf; GstFlowReturn res; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Ki:GstPad.pull_range", kwlist, &offset, &size)) return NULL; res = gst_pad_pull_range (GST_PAD(pygobject_get(self)), offset, size, &buf); ret = PyList_New(2); PyList_SetItem(ret, 0, pyg_enum_from_gtype(GST_TYPE_FLOW_RETURN, res)); if (res != GST_FLOW_OK) { PyList_SetItem(ret, 1, Py_None); } else { PyList_SetItem(ret, 1, pygstminiobject_new(GST_MINI_OBJECT(buf))); } return ret; } %% override gst_pad_get_range kwargs static PyObject * _wrap_gst_pad_get_range (PyGObject *self, PyObject * args, PyObject *kwargs) { static char *kwlist[] = {"offset", "size", NULL}; guint64 offset; gint size; PyObject *ret; GstBuffer *buf; GstFlowReturn res; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Ki:GstPad.get_range", kwlist, &offset, &size)) return NULL; res = gst_pad_get_range (GST_PAD(pygobject_get(self)), offset, size, &buf); ret = PyList_New(2); PyList_SetItem(ret, 0, pyg_enum_from_gtype(GST_TYPE_FLOW_RETURN, res)); if (res != GST_FLOW_OK) { PyList_SetItem(ret, 1, Py_None); } else { PyList_SetItem(ret, 1, pygstminiobject_new(GST_MINI_OBJECT(buf))); } return ret; } %% override gst_pad_get_internal_links noargs static PyObject * _wrap_gst_pad_get_internal_links (PyGObject * self) { PyObject *ret; GList *lst, *tmp; gint i; lst = gst_pad_get_internal_links (GST_PAD (pygobject_get(self))); ret = PyList_New(g_list_length(lst)); for (tmp = lst, i = 0 ; tmp; tmp = g_list_next(tmp), ++i) { PyList_SetItem(ret, i, pygobject_new(G_OBJECT(tmp->data))); } g_list_free(lst); return ret; } %% override gst_pad_get_internal_links_default noargs static PyObject * _wrap_gst_pad_get_internal_links_default (PyGObject * self) { PyObject *ret; GList *lst, *tmp; gint i; lst = gst_pad_get_internal_links_default (GST_PAD (pygobject_get(self))); ret = PyList_New(g_list_length(lst)); for (tmp = lst, i = 0 ; tmp; tmp = g_list_next(tmp), ++i) { PyList_SetItem(ret, i, pygobject_new(G_OBJECT(tmp->data))); } g_list_free(lst); return ret; } %% override gst_pad_get_query_types noargs static PyObject * _wrap_gst_pad_get_query_types (PyGObject *self) { PyObject *ret; PyObject *item; int i; GstQueryType *tab; tab = (GstQueryType*) gst_pad_get_query_types(GST_PAD(self->obj)); if (tab == NULL) { Py_INCREF(Py_None); return Py_None; } ret = PyList_New(0); for (i = 0; tab[i] != 0; i++) { item = pyg_enum_from_gtype (GST_TYPE_QUERY_TYPE, tab[i]); PyList_Append(ret, item); Py_XDECREF(item); } return ret; } %% override gst_pad_get_query_types_default noargs static PyObject * _wrap_gst_pad_get_query_types_default (PyGObject *self) { PyObject *ret; PyObject *item; int i; GstQueryType *tab; tab = (GstQueryType*) gst_pad_get_query_types_default(GST_PAD(self->obj)); if (tab == NULL) { Py_INCREF(Py_None); return Py_None; } ret = PyList_New(0); for (i = 0; tab[i] != 0; i++) { item = pyg_enum_from_gtype (GST_TYPE_QUERY_TYPE, tab[i]); PyList_Append(ret, item); Py_XDECREF(item); } return ret; } %% override gst_pad_set_blocked_async args static void pad_block_callback_marshal(GstPad *pad, gboolean blocked, gpointer user_data) { PyGILState_STATE state; PyObject *callback, *args; PyObject *ret; PyObject *py_user_data; g_return_if_fail(user_data != NULL); state = pyg_gil_state_ensure(); py_user_data = (PyObject *) user_data; callback = PyTuple_GetItem(py_user_data, 0); args = Py_BuildValue("(NO)", pygobject_new(G_OBJECT(pad)), blocked ? Py_True : Py_False); { PyObject *tmp = args; args = PySequence_Concat(tmp, PyTuple_GetItem(py_user_data, 1)); Py_DECREF (tmp); } ret = PyObject_CallObject(callback, args); Py_DECREF(args); Py_DECREF(py_user_data); if (!ret) PyErr_Print(); else Py_DECREF(ret); pyg_gil_state_release(state); } static PyObject * _wrap_gst_pad_set_blocked_async (PyGObject *self, PyObject *args) { PyObject *callback, *cbargs = NULL, *data; PyObject *pblocked, *pret; gboolean blocked; gboolean ret; gint len; len = PyTuple_Size(args); if (len < 2) { PyErr_SetString(PyExc_TypeError, "Requires at least 2 arg"); return NULL; } pblocked = PyTuple_GetItem(args, 0); blocked = PyObject_IsTrue(pblocked); callback = PyTuple_GetItem(args, 1); if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "callback is not callable"); return NULL; } cbargs = PySequence_GetSlice(args, 2, len); if (cbargs == NULL) return NULL; data = Py_BuildValue("(ON)", callback, cbargs); if (data == NULL) return NULL; pyg_begin_allow_threads; ret = gst_pad_set_blocked_async (GST_PAD (self->obj), blocked, (GstPadBlockCallback) pad_block_callback_marshal, data); pyg_end_allow_threads; if (ret) pret = Py_True; else pret = Py_False; Py_INCREF(pret); return pret; } %% override gst_pad_set_caps kwargs static PyObject * _wrap_gst_pad_set_caps(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "caps", NULL }; PyObject *py_caps; int ret; GstCaps *caps; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GstPad.set_caps", kwlist, &py_caps)) return NULL; if (py_caps == Py_None) { caps = NULL; } else { caps = pygst_caps_from_pyobject (py_caps, NULL); if (PyErr_Occurred()) return NULL; } pyg_begin_allow_threads; ret = gst_pad_set_caps(GST_PAD(self->obj), caps); if (ret && caps) gst_caps_unref (caps); pyg_end_allow_threads; return PyBool_FromLong(ret); } %% override gst_pad_query_peer_position args static PyObject * _wrap_gst_pad_query_peer_position (PyGObject *self, PyObject *args) { gint64 cur; gint format; PyObject *pformat; PyObject *ret; pformat = (PyObject*)PyTuple_GetItem(args, 0); if (pyg_enum_get_value (GST_TYPE_FORMAT, pformat, &format)) { PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat"); return NULL; } if ((gst_pad_query_peer_position(GST_PAD (self->obj), (GstFormat*) &format, &cur))) { ret = PyList_New(2); PyList_SetItem(ret, 0, PyLong_FromLongLong(cur)); PyList_SetItem(ret, 1, pyg_enum_from_gtype (GST_TYPE_FORMAT, format )); } else { Py_INCREF(Py_None); ret = Py_None; } return ret; } %% override gst_pad_query_peer_duration args static PyObject * _wrap_gst_pad_query_peer_duration (PyGObject *self, PyObject *args) { gint64 cur; gint format; PyObject *pformat; PyObject *ret; pformat = (PyObject*)PyTuple_GetItem(args, 0); if (pyg_enum_get_value (GST_TYPE_FORMAT, pformat, &format)) { PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat"); return NULL; } if ((gst_pad_query_peer_duration(GST_PAD (self->obj), (GstFormat*) &format, &cur))) { ret = PyList_New(2); PyList_SetItem(ret, 0, PyLong_FromLongLong(cur)); PyList_SetItem(ret, 1, pyg_enum_from_gtype (GST_TYPE_FORMAT, format )); } else { Py_INCREF(Py_None); ret = Py_None; } return ret; } %% override gst_pad_query_peer_convert kwargs static PyObject * _wrap_gst_pad_query_peer_convert (PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "fromformat", "fromvalue", "destformat", NULL }; PyObject *pfromformat, *pdestformat; GstFormat srcformat, destformat; gint64 fromval, dstval; PyObject *ret; /* Input : src_format, src_val, dst_format */ /* Returns : dst_format, dst_val OR None */ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "0L0:GstPad.query_peer_convert", kwlist, &pfromformat, &fromval, &pdestformat)) return NULL; if (pyg_enum_get_value(GST_TYPE_FORMAT, pfromformat, (gint *) &srcformat)) { PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat"); return NULL; } if (pyg_enum_get_value(GST_TYPE_FORMAT, pdestformat, (gint *) &destformat)) { PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat"); return NULL; } if (!(gst_pad_query_peer_convert (GST_PAD(self->obj), srcformat, fromval, &destformat, &dstval))) { Py_INCREF(Py_None); return Py_None; } ret = PyList_New(2); PyList_SetItem(ret, 0, pyg_enum_from_gtype (GST_TYPE_FORMAT, destformat)); PyList_SetItem(ret, 1, PyLong_FromLongLong(dstval)); return ret; } %% override-attr GstStaticPadTemplate.static_caps static PyObject * _wrap_gst_static_pad_template__get_static_caps(PyObject *self, void *closure) { GstStaticPadTemplate *templ; templ = pyg_pointer_get(self, GstStaticPadTemplate); return pyg_pointer_new(GST_TYPE_STATIC_CAPS, &(templ->static_caps)); } %% override gst_pad_start_task args static void pad_task_handler(void *data) { PyGILState_STATE state; PyObject *callback, *args = NULL; PyObject *py_user_data; if (data == NULL) return; state = pyg_gil_state_ensure(); py_user_data = (PyObject*) data; callback = PyTuple_GetItem(py_user_data, 0); if (!(PyCallable_Check(callback))) { PyErr_Print(); goto beach; } if (!(args = PyTuple_GetSlice(py_user_data, 1, PyTuple_Size(py_user_data)))) { PyErr_Print(); goto beach; } if (!(PyTuple_Check(args))) { PyErr_Print(); goto beach; } PyObject_CallObject(callback, args); if(PyErr_Occurred()) PyErr_Print(); Py_DECREF(args); beach: pyg_gil_state_release(state); } static PyObject * _wrap_gst_pad_start_task(PyGObject *self, PyObject *args) { PyObject *callback, *data, *cbargs, *py_ret; gboolean ret; /* 1st argument must be a callable */ if (PyTuple_Size(args) < 1) { PyErr_SetString(PyExc_TypeError, "gst.Pad.start_task() requires at least 1 argument"); return NULL; } callback = PySequence_GetItem(args, 0); if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "callback must be a function or method"); Py_DECREF(callback); return NULL; } if (!(cbargs = PySequence_GetSlice(args, 1, PyTuple_Size(args)))) { Py_DECREF(callback); return NULL; } if (!(data = Py_BuildValue("(ON)", callback, cbargs))) { Py_DECREF(callback); Py_DECREF(cbargs); return NULL; } pyg_begin_allow_threads; ret = gst_pad_start_task(GST_PAD(self->obj), (GstTaskFunction) pad_task_handler, data); pyg_end_allow_threads; if (ret == TRUE) py_ret = Py_True; else py_ret = Py_False; Py_INCREF(py_ret); return py_ret; }