gstreamer/gst/gstelement.override

/* -*- Mode: C; c-basic-offset: 8 -*- */
/* gst-python
 * Copyright (C) 2005 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 <johan@gnome.org>
 */
%%
ignore
  gst_element_get
  gst_element_set
  gst_element_get_property
  gst_element_set_property
%%
define _install_element_meta
static PyObject *
_wrap__install_element_meta(PyObject *self, PyObject *args)
{
    PyObject *metaclass;

    if (!PyArg_ParseTuple(args, "O", &metaclass))
	return NULL;

    Py_INCREF(metaclass);
    PyGstElement_Type.ob_type = (PyTypeObject*)metaclass;

    Py_INCREF(Py_None);
    return Py_None;
}
%%
override gst_element_get_pad_template args
static PyObject *
_wrap_gst_element_get_pad_template(PyGObject *self, PyObject *args)
{
        PyObject *ret;
	gchar *name;
        GstPadTemplate *tmpl;
    
	if (!PyArg_ParseTuple(args, "s:GstElement.get_pad_template", &name))
		return NULL;

        pyg_begin_allow_threads;
        tmpl = gst_element_class_get_pad_template
            (GST_ELEMENT_GET_CLASS (self->obj), name);
        pyg_end_allow_threads;

        if (tmpl) {
                ret = pygobject_new (G_OBJECT (tmpl));
        } else {
                ret = Py_None;
                Py_INCREF (ret);
        }

        return 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;
	GstState state;
	gint ret;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GstElement.set_state", kwlist, &py_state))
		return NULL;
	if (pyg_enum_get_value(GST_TYPE_STATE, py_state, (gint *)&state))
		return NULL;

	pyg_begin_allow_threads;
    
	ret = gst_element_set_state(GST_ELEMENT(self->obj), state);
    
	pyg_end_allow_threads;

	return pyg_enum_from_gtype(GST_TYPE_STATE_CHANGE_RETURN, ret);
}
%%
override gst_element_get_state kwargs
static PyObject *
_wrap_gst_element_get_state(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "timeout", NULL };
    GstState state;
    GstState pending;
    GstStateChangeReturn ret;
    GstClockTime timeout = GST_CLOCK_TIME_NONE;
    PyObject *tuple;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "|K:GstElement.get_state", kwlist,
                                     &timeout)) {
	PyErr_SetString(PyExc_RuntimeError, "Timeout not specified correctly");
        return NULL;
    }

    pyg_begin_allow_threads;

    ret = gst_element_get_state(GST_ELEMENT (self->obj), &state, &pending,
        timeout);

    pyg_end_allow_threads;

    tuple = Py_BuildValue("(OOO)",
        pyg_enum_from_gtype (GST_TYPE_STATE_CHANGE_RETURN, ret),
        pyg_enum_from_gtype (GST_TYPE_STATE, state),
        pyg_enum_from_gtype (GST_TYPE_STATE, pending));

    return tuple;
}
%%
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) {
                gboolean res;

                pyg_begin_allow_threads;
		res = gst_element_link(GST_ELEMENT(element->obj),
                                      GST_ELEMENT(element2->obj));
                pyg_end_allow_threads;

                if (!res) 
                {
                    PyErr_Format(PyGstExc_LinkError,
				 "failed to link %s with %s",
				 GST_ELEMENT_NAME(element->obj),
				 GST_ELEMENT_NAME(element2->obj));
                    return NULL;
                }

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

	Py_INCREF(Py_True);
	return Py_True;
}


%%
override gst_element_link kwargs
static PyObject *
_wrap_gst_element_link(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "dest", "filtercaps", NULL };
    PyGObject *dest;
    PyObject *py_caps = NULL;
    int ret;
    GstCaps *caps = NULL;
    gboolean caps_is_copy;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!|O:GstElement.link",
                                     kwlist, &PyGstElement_Type, &dest, &py_caps))
        return NULL;
    if (py_caps == NULL)
      caps = NULL;
    else {
      caps = pygst_caps_from_pyobject (py_caps, &caps_is_copy);
      if (caps == NULL)
        /* an error happened, propagate up */
        return NULL;
    }

    pyg_begin_allow_threads;
    ret = gst_element_link_filtered(GST_ELEMENT(self->obj), GST_ELEMENT(dest->obj), caps);
    pyg_end_allow_threads;

    if (caps && caps_is_copy)
        gst_caps_unref (caps);
    if (!ret) {
	PyErr_Format(PyGstExc_LinkError,
		     "failed to link %s with %s",
		     GST_ELEMENT_NAME(self->obj),
		     GST_ELEMENT_NAME(dest->obj));
        return NULL;
    }
    return PyBool_FromLong(ret);
}

%%
override gst_element_link_filtered kwargs
static PyObject *
_wrap_gst_element_link_filtered(PyGObject *self, PyObject *args,
                                PyObject *kwargs)
{
    if (PyErr_Warn(PyExc_DeprecationWarning, "element.link_filtered is deprecated, use element.link") < 0)
	return NULL;
    return _wrap_gst_element_link (self, args, kwargs);
}

%%
override gst_element_link_pads kwargs
static gboolean
pad_name_from_object (PyObject *object, const gchar **name)
{
  if (object == Py_None) {
    *name = NULL;
    return TRUE;
  } else if (PyString_Check (object)) {
    *name = PyString_AsString (object);
    return TRUE;
  } else if (pygobject_check (object, &PyGstPad_Type)) {
    *name = gst_object_get_name (GST_OBJECT (pygobject_get (object)));
    return TRUE;
  }
  PyErr_SetString(PyExc_TypeError, "argument could not be converted to a pad");
  return FALSE;
}

static PyObject *
_wrap_gst_element_link_pads(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "srcpadname", "dest", "destpadname", NULL };
    const char *srcpadname, *destpadname;
    PyGObject *dest;
    PyObject *srcpad, *destpad;
    int ret;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "OO!O:GstElement.link_pads", kwlist,
                                     &srcpad, &PyGstElement_Type, &dest,
                                     &destpad))
        return NULL;
    if (!pad_name_from_object (srcpad, &srcpadname) ||
        !pad_name_from_object (destpad, &destpadname))
	return NULL;

    pyg_begin_allow_threads;
    ret = gst_element_link_pads(GST_ELEMENT(self->obj), srcpadname,
                                GST_ELEMENT(dest->obj), destpadname);
    pyg_end_allow_threads;
    if (!ret) {
        PyErr_SetString(PyGstExc_LinkError, "link failed");
        return NULL;
    }
    return PyBool_FromLong(ret);

}

%%
override gst_element_link_pads_filtered kwargs
static PyObject *
_wrap_gst_element_link_pads_filtered(PyGObject *self, PyObject *args,
                                     PyObject *kwargs)
{
    static char *kwlist[] = { "srcpadname", "dest", "destpadname",
                              "filtercaps", NULL };
    char *srcpadname, *destpadname;
    PyGObject *dest;
    int ret;
    PyObject *py_filtercaps;
    GstCaps *filtercaps = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
                                     "sO!sO:GstElement.link_pads_filtered",
                                     kwlist, &srcpadname, &PyGstElement_Type,
                                     &dest, &destpadname, &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;
    }
    pyg_begin_allow_threads;
    ret = gst_element_link_pads_filtered(GST_ELEMENT(self->obj), srcpadname,
                                         GST_ELEMENT(dest->obj), destpadname,
                                         filtercaps);
    pyg_end_allow_threads;
    if (!ret) {
        PyErr_SetString(PyGstExc_LinkError, "link failed");
        return NULL;
    }
    return PyBool_FromLong(ret);
}

%%
override gst_element_unlink_many args
static PyObject *
_wrap_gst_element_unlink_many(PyObject *self, PyObject *args)
{
	PyGObject *element, *element2;
	int i, len;

	len = PyTuple_Size(args);
	if (len < 2)
	{
		PyErr_SetString(PyExc_TypeError, "gst.element_unlink_many requires at least two arguments");
		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_unlink_many */
	element = (PyGObject*)PyTuple_GetItem(args, 0);
	element2 = (PyGObject*)PyTuple_GetItem(args, 1);

	i = 2;
	while (1) {
                pyg_begin_allow_threads;
		gst_element_unlink(GST_ELEMENT(element->obj), GST_ELEMENT(element2->obj));
                pyg_end_allow_threads;

		if (i >= len)
			break;
		
		element = element2;
		element2 = (PyGObject*)PyTuple_GetItem(args, i);
	
		i++;
	}
	Py_INCREF(Py_None);
	return Py_None;
}
%%
override gst_element_send_event kwargs
static PyObject *
_wrap_gst_element_send_event(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "event", NULL };
    PyObject *py_event;
    int ret;
    GstEvent *event = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GstElement.send_event", kwlist, &py_event))
        return NULL;
    if (pygstminiobject_check (py_event, &PyGstEvent_Type)) {
        event = GST_EVENT (pygstminiobject_get (py_event));
    } else {
        PyErr_SetString(PyExc_TypeError, "event should be a GstEvent");
        return NULL;
    }

    /* The pipeline unrefs the event, but we want to keep the ownership */
    gst_event_ref(event);
    
    pyg_begin_allow_threads;
    ret = gst_element_send_event(GST_ELEMENT(self->obj), event);
    pyg_end_allow_threads;

    return PyBool_FromLong(ret);
}
%%
override gst_element_query_position args
static PyObject *
_wrap_gst_element_query_position (PyGObject *self, PyObject *args)
{
    gint64	cur;
    gint	format;
    PyObject	*pformat;
    gboolean    res;

    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;
    }

    pyg_begin_allow_threads;
    res = gst_element_query_position(GST_ELEMENT (self->obj), (GstFormat*) &format, &cur);
    pyg_end_allow_threads;

    if (!res) {
	PyErr_Format(PyGstExc_QueryError,
		     "query failed");
        return NULL;
    }

    return Py_BuildValue("(LO)", cur,
			 pyg_enum_from_gtype(GST_TYPE_FORMAT, format));
}
%%
override gst_element_query_duration args
static PyObject *
_wrap_gst_element_query_duration (PyGObject *self, PyObject *args)
{
    gint64	cur;
    gint	format;
    PyObject	*pformat;
    gboolean    res;

    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;
    }

    pyg_begin_allow_threads;
    res = gst_element_query_duration(GST_ELEMENT (self->obj), (GstFormat*) &format, &cur);
    pyg_end_allow_threads;

    if (!res) {
	PyErr_Format(PyGstExc_QueryError,
		     "query failed");
        return NULL;
    }

    return Py_BuildValue("(LO)", cur,
			 pyg_enum_from_gtype(GST_TYPE_FORMAT, format));
}
%%
override gst_element_query_convert kwargs
static PyObject *
_wrap_gst_element_query_convert (PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "fromformat", "fromvalue", "destformat", NULL };
    PyObject	*pfromformat, *pdestformat;
    GstFormat	srcformat, destformat;
    gint64	fromval, dstval;
    gboolean    res;

    /* Input : src_format, src_val, dst_format */
    /* Returns : dst_format, dst_val OR None */

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
				     "OLO:GstElement.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;
    }

    pyg_begin_allow_threads;
    res = gst_element_query_convert (GST_ELEMENT(self->obj),
				     srcformat, fromval,
				     &destformat, &dstval);
    pyg_end_allow_threads;

    if (!res) {
	Py_INCREF(Py_None);
	return Py_None;
    }

    return Py_BuildValue("(OL)", 
			 pyg_enum_from_gtype(GST_TYPE_FORMAT, destformat),
			 dstval);					     
}
%%
override gst_element_get_query_types noargs
static PyObject *
_wrap_gst_element_get_query_types (PyGObject *self)
{
    PyObject	*ret;
    PyObject	*item;
    int		i;
    GstQueryType	*tab;

    pyg_begin_allow_threads;
    tab = (GstQueryType*) gst_element_get_query_types(GST_ELEMENT(self->obj));
    pyg_end_allow_threads;
    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);
    }
    
    return ret;
}
%%
override-slot GstElement.tp_iter
static PyObject *
_wrap_gst_element_tp_iter(PyGObject *self)
{
    return _wrap_gst_element_iterate_pads(self);
}
%%
override gst_element_get_pad_template_list noargs
static PyObject *
_wrap_gst_element_get_pad_template_list(PyGObject *self)
{
        PyObject *ret;
	GList *res = NULL;
	guint i;
    
        pyg_begin_allow_threads;
        res = gst_element_class_get_pad_template_list
            (GST_ELEMENT_GET_CLASS (self->obj));
        pyg_end_allow_threads;

        if (res) {
		i = g_list_length (res);
		ret = PyList_New (i);
		for (i = 0 ; res ; res = g_list_next (res), i++) {
			GstPadTemplate * tmpl = (GstPadTemplate *) res->data;
			PyList_SetItem (ret, i, pygobject_new (G_OBJECT (tmpl)));
		}
        } else {
                ret = Py_None;
                Py_INCREF (ret);
        }

        return ret;
}
%%
override GstElement__proxy_do_request_new_pad
static GstPad*
_wrap_GstElement__proxy_do_request_new_pad(GstElement *self, GstPadTemplate*templ, const gchar*name)
{
    PyGILState_STATE __py_state;
    PyObject *py_self;
    PyObject *py_templ = NULL;
    PyObject *py_name;
    GstPad* retval;
    PyObject *py_retval;
    PyObject *py_args;
    PyObject *py_method;
    
    __py_state = pyg_gil_state_ensure();
    py_self = pygobject_new((GObject *) self);
    if (!py_self) {
        if (PyErr_Occurred())
            PyErr_Print();
        pyg_gil_state_release(__py_state);
        return NULL;
    }
    if (templ)
        py_templ = pygobject_new((GObject *) templ);
    else {
        Py_INCREF(Py_None);
        py_templ = Py_None;
    }

    if (name == NULL) {
	    Py_INCREF(Py_None);
	    py_name = Py_None;
    } else {
	    py_name = PyString_FromString(name);
	    if (!py_name) {
		    if (PyErr_Occurred())
			    PyErr_Print();
		    Py_DECREF(py_templ);
		    Py_DECREF(py_self);
		    pyg_gil_state_release(__py_state);
		    return NULL;
	    }
    }
    
    py_args = PyTuple_New(2);
    PyTuple_SET_ITEM(py_args, 0, py_templ);
    PyTuple_SET_ITEM(py_args, 1, py_name);
    
    py_method = PyObject_GetAttrString(py_self, "do_request_new_pad");
    if (!py_method) {
        if (PyErr_Occurred())
            PyErr_Print();
        Py_DECREF(py_args);
        Py_DECREF(py_self);
        pyg_gil_state_release(__py_state);
        return NULL;
    }
    py_retval = PyObject_CallObject(py_method, py_args);
    if (!py_retval) {
        if (PyErr_Occurred())
            PyErr_Print();
        Py_DECREF(py_method);
        Py_DECREF(py_args);
        Py_DECREF(py_self);
        pyg_gil_state_release(__py_state);
        return NULL;
    }
    if (!PyObject_TypeCheck(py_retval, &PyGObject_Type)) {
        PyErr_SetString(PyExc_TypeError, "retval should be a GObject");
        PyErr_Print();
        Py_DECREF(py_retval);
        Py_DECREF(py_method);
        Py_DECREF(py_args);
        Py_DECREF(py_self);
        pyg_gil_state_release(__py_state);
        return NULL;
    }
    retval = (GstPad*) pygobject_get(py_retval);
    g_object_ref((GObject *) retval);
    
    
    Py_DECREF(py_retval);
    Py_DECREF(py_method);
    Py_DECREF(py_args);
    Py_DECREF(py_self);
    pyg_gil_state_release(__py_state);
    
    return retval;
}