gstreamer/gst/gst.override

/* -*- Mode: C; ; c-file-style: "python" -*- */
/* gst-python
 * Copyright (C) 2002 David I. Lehn
 * 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: David I. Lehn <dlehn@users.sourceforge.net>
 */
%%
headers
#include <Python.h>

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include "pygobject.h"
#include <gst/gst.h>
#include <gst/gsterror.h>
#include <gst/gstqueue.h>
#include <gst/gsttypefind.h>

typedef struct {
     PyGObject *pad;
     PyObject *link_function;
     PyObject *event_function;
     PyObject *chain_function;
     PyObject *get_function; 
} PyGstPadPrivate;

typedef struct {
     PyObject *func, *data;
} PyGstCustomNotify;

void            iterate_bin_all          (GstBin *bin);
guint           add_iterate_bin          (GstBin *bin);
void            remove_iterate_bin       (guint id);
extern gboolean pygst_data_from_pyobject (PyObject *object, GstData **data);

%%
include
  gstpad-handlers.override
%%
modulename gst
%%
import gobject.GObject as PyGObject_Type
%%
ignore-glob
  _*
  gstreamer_*init
  *_get_type
  *_copy
  *_free
  *_valist
  *_private
  gst_registry_*
  gst_value_*
  gst_tag_list_get_*
%%
override gst_buffer_get_data
static PyObject*
_wrap_gst_buffer_get_data(PyObject *self)
{
	GstBuffer *buf = pyg_boxed_get(self, GstBuffer);
	return PyString_FromStringAndSize(GST_BUFFER_DATA(buf),
					  GST_BUFFER_SIZE(buf));
}
%%
override gst_buffer_set_data kwargs
static PyObject*
_wrap_gst_buffer_set_data(PyObject *self, PyObject *args, PyObject *kwargs)
{
	static char *kwlist[] = {"data", NULL};
	PyObject *data;
	GstBuffer *buf;
	
	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GstBuffer:set_data", kwlist, &data))
	{
		return NULL;
	}
	if (!PyString_Check(data)) {
		PyErr_SetString(PyExc_TypeError, "data should be a string");
		return NULL;
	}
	buf = pyg_boxed_get(self, GstBuffer);
	if (GST_BUFFER_FLAGS(buf) & GST_BUFFER_READONLY) {
		PyErr_SetString(PyExc_TypeError, "set_data can't use a READONLY buffer");
		return NULL;
	}
	GST_BUFFER_SIZE(buf) = PyString_Size(data);
	GST_BUFFER_DATA(buf) = g_new0(char, GST_BUFFER_SIZE(buf));

	memcpy(GST_BUFFER_DATA(buf),
	       PyString_AsString(data),
	       PyString_Size(data));

	Py_INCREF(Py_None);
	return Py_None;
}
%%
override gst_bin_iterate
static PyObject *
_wrap_gst_bin_iterate(PyGObject *self)
{
	int ret;

	pyg_unblock_threads();
	ret = gst_bin_iterate(GST_BIN(self->obj));
	pyg_block_threads();
	return PyInt_FromLong(ret);
}
%%
override gst_element_set_state kwargs
static PyObject *
_wrap_gst_element_set_state(PyGObject *self, PyObject *args, PyObject *kwargs)
{
	static char *kwlist[] = { "state", NULL };
	PyObject *py_state = NULL;
	GstElementState state;
	gint ret;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GstElement.set_state", kwlist, &py_state))
		return NULL;
	if (pyg_flags_get_value(GST_TYPE_ELEMENT_STATE, py_state, (gint *)&state))
		return NULL;
	pyg_unblock_threads();
	ret = gst_element_set_state(GST_ELEMENT(self->obj), state);
	pyg_block_threads();
	return PyInt_FromLong(ret);
}
%%
override gst_pad_query kwargs
static PyObject *
_wrap_gst_pad_query(PyGObject *self, PyObject *args, PyObject *kwargs)
{
	static char *kwlist[] = { "type", "format", NULL };
	GstQueryType type;
	GstFormat format;
	gint64 value;
	gboolean ret;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:GstPad.query", kwlist, &type, &format))
		return NULL;
	value = 0;
	ret = gst_pad_query(GST_PAD(self->obj), type, &format, &value);
	return Py_BuildValue("(bL)", ret, value);
}
%%
override gst_element_query kwargs
static PyObject *
_wrap_gst_element_query(PyGObject *self, PyObject *args, PyObject *kwargs)
{
	static char *kwlist[] = { "type", "format", NULL };
	GstQueryType type;
	GstFormat format;
	gint64 value;
	gboolean ret;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:GstElement.query", kwlist, &type, &format))
		return NULL;
	value = 0;
	ret = gst_element_query(GST_ELEMENT(self->obj), type, &format, &value);
	return Py_BuildValue("(bL)", ret, value);
}
%%
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;
	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);
	dest_value = 0;
	ret = gst_pad_convert(GST_PAD(self->obj), src_format, src_value, &dest_format, &dest_value);
	return Py_BuildValue("(bL)", ret, dest_value);
}
%%
override gst_element_convert kwargs
static PyObject *
_wrap_gst_element_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;
	gboolean ret;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iOi:GstElement.convert", kwlist, &src_format, &src_value_obj, &dest_format))
		return NULL;
	src_value = PyLong_AsLongLong(src_value_obj);
	dest_value = 0;
	ret = gst_element_convert(GST_ELEMENT(self->obj), src_format, src_value, &dest_format, &dest_value);
	return Py_BuildValue("(bL)", ret, dest_value);
}
%%
override gst_bin_add_many args
static PyObject *
_wrap_gst_bin_add_many(PyGObject *self, PyObject *args)
{
	PyGObject *element;
	int i, len;

	len = PyTuple_Size(args);
	if (len == 0) {
		PyErr_SetString(PyExc_TypeError, "GstBin.add_many requires at least one argument");
		return NULL;
	}
       
    
	for (i = 0; i < len; i++) {
		element = (PyGObject*)PyTuple_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*)PyTuple_GetItem(args, i);
		gst_bin_add(GST_BIN(self->obj), GST_ELEMENT(element->obj));
	}

	Py_INCREF(Py_None);
	return Py_None;
}
%%
override gst_element_link_many args
static PyObject *
_wrap_gst_element_link_many(PyObject *self, PyObject *args)
{
	PyGObject *element, *element2;
	int i, len;

	len = PyTuple_Size(args);
	if (len < 2)
	{
		PyErr_SetString(PyExc_TypeError, "gst.element_link_many requires at least two argument");
		return NULL;
	}
       

	for (i = 0; i < len; i++)
	{
		element = (PyGObject*)PyTuple_GetItem(args, i);
		if (!pygobject_check(element, &PyGstElement_Type))
		{
			PyErr_SetString(PyExc_TypeError, "argument must be a GstElement");
			return NULL;
		}
	}

	/* Mimic the real gst_element_link_many */
	element = (PyGObject*)PyTuple_GetItem(args, 0);
	element2 = (PyGObject*)PyTuple_GetItem(args, 1);

	i = 2;
	while (1) {

		if (!gst_element_link(GST_ELEMENT(element->obj), GST_ELEMENT(element2->obj)))
			return PyInt_FromLong(0);

		if (i >= len)
			break;
		
		element = element2;
		element2 = (PyGObject*)PyTuple_GetItem(args, i);
	
		i++;
	}

	return PyInt_FromLong(1);
}
%%
override-slot GstBuffer.tp_getattr
PyObject *
_wrap_gst_buffer_tp_getattr(PyGObject *self, char *attr)
{
	if (!strcmp(attr, "type"))
		return pyg_type_wrapper_new(GST_DATA_TYPE(self->obj));
	else if (!strcmp(attr, "flags"))
		return PyInt_FromLong(GST_DATA_FLAGS(self->obj));

	return Py_FindMethod(_PyGstBuffer_methods, (PyObject*)self, attr);
}
%%
override GstPad.get_negotiated_caps
static PyObject *
_wrap_gst_pad_get_negotiated_caps(PyGObject *self)
{
	const GstCaps *ret;

	ret = gst_pad_get_negotiated_caps(GST_PAD(self->obj));
	/* pyg_boxed_new handles NULL checking */
	return pyg_boxed_new(GST_TYPE_CAPS, ret, TRUE, TRUE);
}
%%
override gst_buffer_new kwargs
static int
_wrap_gst_buffer_new(PyGBoxed *self, PyObject *args, PyObject *kwargs)
{
	static char *kwlist[] = { "data", "buffer_size", NULL };
	char *data = NULL;
	int size;
	int buf_size = 4096;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|z#s:GstBuffer.__init__", kwlist,
					 &data, &size, &buf_size))
		return -1;
	self->gtype = GST_TYPE_BUFFER;
	self->free_on_dealloc = FALSE;
	self->boxed = gst_buffer_new(); //_and_alloc(buf_size);
	
	if (!self->boxed) {
		PyErr_SetString(PyExc_RuntimeError, "could not create GstBuffer object");
		return -1;
	}
	
	GST_BUFFER_SIZE (self->boxed) = size;
	GST_BUFFER_DATA (self->boxed) = data;
	
//	if (data)
//		memcpy(GST_BUFFER_DATA (self->boxed), data, size);
	
//	gst_buffer_set_data (self->boxed, data, size);

//	gst_buffer_ref (GST_BUFFER (self->boxed));

	return 0;
}
%%
define GstTagList.keys noargs
void
tag_foreach_func_dict (const GstTagList *list,
		       const gchar      *tag,
		       PyObject         *dict)
{
	int count;
	guint i;
	const GValue *gvalue;
	PyObject *value;
	gchar *key;
    
	count = gst_tag_list_get_tag_size(GST_TAG_LIST(list), tag);

	for (i = 0; i < count; i++) {
		gvalue = gst_tag_list_get_value_index(GST_TAG_LIST(list), tag, i);
		value = pyg_value_as_pyobject(gvalue, TRUE);
		key = g_strdup (tag);
		PyDict_SetItemString(dict, key, value);
		g_free (key);
		Py_DECREF(value);
	}
}
void
tag_foreach_func_list (const GstTagList *list,
		       const gchar      *tag,
		       PyObject         *py_list)
{
	int count;
    
	count = gst_tag_list_get_tag_size(GST_TAG_LIST(list), tag);
	if (count == 0)
		PyErr_SetString(PyExc_KeyError, tag);
	else if (count == 1)
		PyList_Append(py_list, PyString_FromString(tag));
	else if (count > 1)
		PyErr_SetString(PyExc_TypeError, "lists are currently unspported");
}

static PyObject*
_wrap_gst_tag_list_keys(PyGObject *self)
{
	PyObject *dict;

	dict = PyList_New(0);
    
	gst_tag_list_foreach(GST_TAG_LIST(self->obj),
			     (GstTagForeachFunc)tag_foreach_func_list,
			     (gpointer)dict);
    
	return dict;
}
%%
override-slot GstTagList.tp_as_mapping
static int
_wrap_gst_tag_list_length(PyGObject *self)
{
	return gst_structure_n_fields((GstStructure*)self->obj);
}

static PyObject *
_wrap_gst_tag_list_subscript(PyGObject *self, PyObject *py_key)
{
	PyObject *v = NULL;
	char *key = PyString_AsString(py_key);
	
	int count = gst_tag_list_get_tag_size(GST_TAG_LIST(self->obj), key);
	if (count == 0) {
		PyErr_SetObject(PyExc_KeyError, py_key);
	} else if (count == 1) {
		const GValue *gvalue;
		gvalue = gst_tag_list_get_value_index(GST_TAG_LIST(self->obj), key, 0);
		v = pyg_value_as_pyobject(gvalue, TRUE);
	} else {
		PyErr_SetString(PyExc_TypeError, "lists are currently unspported");
	}
		
	if (v != NULL)
		Py_INCREF(v);
	return v;
}

static PySequenceMethods _wrap_gst_tag_list_tp_as_mapping = {
	(inquiry)_wrap_gst_tag_list_length,         /* mp_length */
	(binaryfunc)_wrap_gst_tag_list_subscript,   /* mp_subscript */
	NULL,
};

%%
define GstTagList.has_key args
static PyObject*
_wrap_gst_tag_list_has_key(PyGObject *self, PyObject *args)
{
	gchar *key;
	const GValue *gvalue;
    
	if (!PyArg_ParseTuple(args, "s:GstTagList.keys", &key))
		return NULL;

	gvalue = gst_tag_list_get_value_index(GST_TAG_LIST(self->obj), key, 0);

	return PyInt_FromLong(gvalue != NULL);
}    
%%
define GstTagList.get
static PyObject *
_wrap_gst_tag_list_get(PyGObject *self, PyObject *args)
{
	char *key;
	PyObject *failobj = Py_None;
	PyObject *val = NULL;
	const GValue *gvalue;
	
	if (!PyArg_ParseTuple(args, "s|O:GstTagList.get", &key, &failobj))
		return NULL;

	gvalue = gst_tag_list_get_value_index(GST_TAG_LIST(self->obj), key, 0);
	if (gvalue != NULL) {
		int count = gst_tag_list_get_tag_size(GST_TAG_LIST(self->obj), key);
		if (count == 0) {
			PyErr_SetString(PyExc_KeyError, key);
		} else if (count == 1) {
			gvalue = gst_tag_list_get_value_index(GST_TAG_LIST(self->obj), key, 0);
			val = pyg_value_as_pyobject(gvalue, TRUE);
		} else {
			PyErr_SetString(PyExc_TypeError, "lists are currently unspported");
		}
	}

	if (val == NULL)
		val = failobj;
	Py_INCREF(val);
	return val;
}

static PyGstPadPrivate*
pad_private(GstPad *pad)
{
	return (PyGstPadPrivate*)gst_pad_get_element_private(pad);
}
	
static PyGstPadPrivate*
py_pad_private(PyGObject *pad)
{
	PyGstPadPrivate *private;
	GstPad *gpad;

	gpad = (GstPad*)pygobject_get(pad);
	private = (PyGstPadPrivate*)gst_pad_get_element_private(gpad);
	if (private == NULL) {
		/* FIXME need to free this somewhere */
		private = g_new0(PyGstPadPrivate, 1);
		Py_INCREF(pad);
		private->pad = pad;
		gst_pad_set_element_private(gpad, private);
	}
	return private;
}
%%
override gst_structure_new kwargs
static int
_wrap_gst_structure_new(PyGBoxed *self, PyObject *args, PyObject *kwargs)
{
	static char *kwlist[] = { "name", NULL };
	char *name;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:GstStructure.__init__", kwlist, &name))
		return -1;
	self->gtype = GST_TYPE_STRUCTURE;
	self->free_on_dealloc = FALSE;
	self->boxed = gst_structure_new(name, NULL);

	if (!self->boxed) {
		PyErr_SetString(PyExc_RuntimeError, "could not create GstStructure object");
		return -1;
	}
	self->free_on_dealloc = TRUE;
	return 0;
}
%%
override gst_structure_set_value kwargs
static PyObject *
_wrap_gst_structure_set_value(PyObject *self, PyObject *args, PyObject *kwargs)
{
	static char *kwlist[] = { "field", "value", NULL };
	char *field;
	PyObject *py_value = NULL;
	GValue value = { 0 };

	if (!PyArg_ParseTupleAndKeywords(args, kwargs,
					 "sO:GstStructure.set_value",
					 kwlist, &field, &py_value))
		return NULL;
	
	g_value_init(&value, G_TYPE_STRING);
	if (pyg_value_from_pyobject(&value, py_value) != 0) {
		return NULL;
	}
	gst_structure_set_value(pyg_boxed_get(self, GstStructure), field, &value);

	Py_INCREF(Py_None);
	return Py_None;
}
%%
override gst_structure_foreach kwargs
static gboolean
pygst_structure_foreach_marshal(GQuark field_id,
				GValue *value,
				gpointer user_data)
{
	PyGstCustomNotify *cunote = user_data;
	PyObject *py_field, *py_value, *retobj;
	gboolean retval = TRUE;

	g_assert(cunote->func);

	pyg_block_threads();

	//py_model = pygobject_new((GObject *)model);
	//py_path = pygtk_tree_path_to_pyobject(path);
	//py_iter = pyg_boxed_new(GTK_TYPE_TREE_ITER, iter, TRUE, TRUE);
	py_field = Py_BuildValue("s", g_quark_to_string(field_id));
	py_value = pyg_value_as_pyobject(value, FALSE);
	if (cunote->data)
		retobj = PyEval_CallFunction(cunote->func, "(NNO)",
					     py_field, py_value,
					     cunote->data);
	else
		retobj = PyEval_CallFunction(cunote->func, "(NN)",
					     py_field, py_value);

	if (PyErr_Occurred () || (retobj == NULL) || (retobj == Py_None)) {
		PyErr_Print ();
		retval = FALSE;
	} else if (retobj != Py_None) {
		retval = PyInt_AsLong(retobj);
	}

	Py_XDECREF(retobj);

	pyg_unblock_threads();

	return retval;
}

static PyObject *
_wrap_gst_structure_foreach (PyGObject *self,
			     PyObject *args,
			     PyObject *kwargs)
{
	static char *kwlist[] = { "foreach_function", "args", NULL };
	PyObject *pyfunc, *pyarg = NULL;
	PyGstCustomNotify cunote;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs,
					 "O|O:GstStructure.foreach",
					 kwlist,
					 &pyfunc, &pyarg)) {
		return NULL;
	}

	if (!PyCallable_Check(pyfunc)) {
		PyErr_SetString(PyExc_TypeError, "foreach_function not callable");
		return NULL;
	}

	cunote.func = pyfunc;
	cunote.data = pyarg;
	gst_structure_foreach(pyg_boxed_get(self, GstStructure),
			      pygst_structure_foreach_marshal,
			      &cunote);

	Py_INCREF(Py_None);
	return Py_None;
}
%%
override gst_tag_list_foreach kwargs

static gboolean
pygst_tag_list_foreach_marshal(GstTagList *list,
			       const gchar *tag,
			       gpointer user_data)
{
	PyGstCustomNotify *cunote = user_data;
	PyObject *py_list;
	PyObject *py_key, *retobj;
	gboolean retval = TRUE;

	g_assert(cunote->func);

	pyg_block_threads();

	py_list = pyg_boxed_new(GST_TYPE_TAG_LIST, list, TRUE, TRUE);
	py_key = Py_BuildValue("s", tag);
	if (cunote->data)
		retobj = PyEval_CallFunction(cunote->func, "(NNO)",
					     py_list,
					     py_key,
					     cunote->data);
	else
		retobj = PyEval_CallFunction(cunote->func, "(NN)",
					     py_list,
					     py_key);

	if (PyErr_Occurred () || (retobj == NULL) || (retobj == Py_None)) {
		PyErr_Print ();
		retval = FALSE;
	} else if (retobj != Py_None) {
		retval = PyInt_AsLong(retobj);
	}

	Py_XDECREF(retobj);

	pyg_unblock_threads();

	return retval;
}

static PyObject *
_wrap_gst_tag_list_foreach (PyGObject *self,
			    PyObject *args,
			    PyObject *kwargs)
{
	static char *kwlist[] = { "foreach_function", "args", NULL };
	PyObject *pyfunc, *pyarg = NULL;
	PyGstCustomNotify cunote;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs,
					 "O|O:GstTagList.foreach",
					 kwlist, &pyfunc, &pyarg))
		return NULL;

	if (!PyCallable_Check(pyfunc)) {
		PyErr_SetString(PyExc_TypeError, "foreach_function not callable");
		return NULL;
	}

	cunote.func = pyfunc;
	cunote.data = pyarg;
	gst_tag_list_foreach(pyg_boxed_get(self, GstTagList),
			     (GstTagForeachFunc)pygst_tag_list_foreach_marshal,
			     &cunote);

	Py_INCREF(Py_None);
	return Py_None;
}
%%
override gst_tag_list_get_value_index kwargs
static PyObject *
_wrap_gst_tag_list_get_value_index (PyGObject *self,
				    PyObject *args,
				    PyObject *kwargs)
{
	static char *kwlist[] = { "tag", "index", NULL };
	char *tag;
	int index;
	const GValue *gvalue;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs,
					 "si:GstTagList.get_value_index",
					 kwlist, &tag, &index))
		return NULL;

	gvalue = gst_tag_list_get_value_index(pyg_boxed_get(self, GstTagList),
					      tag,
					      index);

	return pyg_value_as_pyobject(gvalue, FALSE);
}
%%
override gst_pad_get_negotiated_caps noargs
static PyObject *
_wrap_gst_pad_get_negotiated_caps(PyGObject *self)
{
	GstCaps *ret = (GstCaps*)gst_pad_get_negotiated_caps(GST_PAD(self->obj));
	return pyg_boxed_new(GST_TYPE_CAPS, ret, TRUE, TRUE);
}
%%
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_type_fidn_factory_get_caps noargs
static PyObject *
_wrap_gst_type_find_factory_get_caps(PyGObject *self)
{
	GstCaps *ret = (GstCaps*)gst_type_find_factory_get_caps(GST_TYPE_FIND_FACTORY(self->obj));
	return pyg_boxed_new(GST_TYPE_CAPS, ret, TRUE, TRUE);
}
%%
override gst_pad_template_get_caps_ny_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);
	return pyg_boxed_new(GST_TYPE_CAPS, ret, TRUE, TRUE);
}
%%
override gst_type_find_factory_get_caps noargs
static PyObject *
_wrap_gst_type_find_factory_get_caps(PyGObject *self)
{
	GstCaps *ret = (GstCaps*)gst_type_find_factory_get_caps(GST_TYPE_FIND_FACTORY(self->obj));
	return pyg_boxed_new(GST_TYPE_CAPS, ret, TRUE, TRUE);
}
%%
override-attr GError.domain
static PyObject *
_wrap_gst_g_error__get_domain(PyGObject *self, void *closure)
{
    return PyString_FromString(g_quark_to_string(((GError*)self->obj)->domain));
}
%%
override-slot GError.tp_str
static PyObject *
_wrap_gst_g_error_tp_str(PyGObject *self)
{
    GError *error = (GError*)self->obj;
    return PyString_FromString(gst_error_get_message (error->domain,
						      error->code));
}