mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-01-23 07:38:16 +00:00
Code Issues 1 Projects Releases Wiki Activity

Split out gst.override to a few more files.

Browse source 
Original commit message from CVS:
Split out gst.override to a few more files.
Rename gstpad-handlers.override to gstpad.override
Include more information for some LinkError exceptions
This commit is contained in:
Johan Dahlin 2005-01-01 15:23:42 +00:00
parent f51f43e1d9
commit 6782bfbc7b
8 changed files with 1071 additions and 1232 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
ChangeLog
View file

@ -1,3 +1,17 @@
2005-01-01 Johan Dahlin <johan@gnome.org>
* gst/Makefile.am:
* gst/gst.override:
* gst/gstcaps.override:
* gst/gstelement.override:
* gst/gstpad-handlers.override:
* gst/gstpad.override:
* gst/gststructure.override:
Split out gst.override to a few more files.
Rename gstpad-handlers.override to gstpad.override
Include more information for some LinkError exceptions
2004-12-14 Johan Dahlin <johan@gnome.org>
* gst/gst-types.defs:

13
gst/Makefile.am
View file

@ -37,10 +37,15 @@ _gst_la_LIBADD = $(common_libadd)
_gst_la_LDFLAGS = $(common_ldflags) -export-symbols-regex init_gst
_gst_la_SOURCES = gst-argtypes.c gstmodule.c
nodist__gst_la_SOURCES = gst.c
GST_OVERRIDES = gst.override \
gstbin.override \
gstbuffer.override \
gstpad-handlers.override
GST_OVERRIDES = \
gst.override \
gstbin.override \
gstbuffer.override \
gstcaps.override \
gstelement.override \
gstpad.override \
gststructure.override
GST_DEFS = gst.defs gst-types.defs
CLEANFILES = gst.c
EXTRA_DIST += $(GST_DEFS) $(GST_OVERRIDES)

970
gst/gst.override
View file

File diff suppressed because it is too large Load diff

138
gst/gstcaps.override Normal file
View file

@ -0,0 +1,138 @@
/* -*- Mode: C; c-basic-offset: 4 -*- */
/* 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_caps_new_simple
gst_caps_new_full
gst_caps_set_simple
%%
override gst_caps_new_empty kwargs
static int
_wrap_gst_caps_new_empty(PyGBoxed *self, PyObject *args, PyObject *kwargs)
{
PyObject* item;
int len, i;
/* we wrap caps_new, caps_from_string and caps_new_full */
len = PyTuple_Size(args);
self->gtype = GST_TYPE_CAPS;
self->free_on_dealloc = FALSE;
if (len == 0) {
/* 0 length creates a new empty caps */
self->boxed = gst_caps_new_empty();
goto beach;
} else if (len == 1) {
/* 1 length is either a string or a structure */
item = PyTuple_GetItem(args, 0);
if (PyString_Check(item)) {
self->boxed = gst_caps_from_string(PyString_AsString(item));
goto beach;
} else if (!pyg_boxed_check(item, GST_TYPE_STRUCTURE)) {
PyErr_SetString(PyExc_TypeError, "argument must be a string or a GstStructure");
return -1;
}
}
/* it's either one GstStructure or several whatevers */
self->boxed = gst_caps_new_empty();
for (i = 0; i < len; i++)
{
item = PyTuple_GetItem(args, i);
if (!pyg_boxed_check(item, GST_TYPE_STRUCTURE))
{
PyErr_SetString(PyExc_TypeError, "argument must be a GstStructure");
gst_caps_free(self->boxed);
return -1;
}
gst_caps_append_structure(self->boxed, pyg_boxed_get(item, GstStructure));
}
beach:
if (!self->boxed) {
PyErr_SetString(PyExc_RuntimeError, "could not create GstCaps object");
return -1;
}
return 0;
}
%%
override gst_caps_get_structure kwargs
static PyObject *
_wrap_gst_caps_get_structure(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "index", NULL };
int index;
GstStructure *ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:GstCaps.get_structure", kwlist, &index))
return NULL;
ret = gst_caps_get_structure(pyg_boxed_get(self, GstCaps), index);
/* pyg_boxed_new handles NULL checking */
return pyg_boxed_new(GST_TYPE_STRUCTURE, ret, FALSE, FALSE);
}
%%
override-slot GstCaps.tp_as_sequence
static int
caps_length(PyGObject *self)
{
return gst_caps_get_size((GstCaps*)self->obj);
}
static PyObject *
caps_item(PyGObject *self, int i)
{
GstStructure *structure;
if (i < 0 || i >= gst_caps_get_size((GstCaps*)self->obj)) {
PyErr_SetString(PyExc_IndexError, "list index out of range");
return NULL;
}
structure = gst_caps_get_structure((GstCaps*)self->obj, i);
return pyg_boxed_new(GST_TYPE_STRUCTURE, structure, TRUE, TRUE);
}
static PySequenceMethods _wrap_gst_caps_tp_as_sequence = {
(inquiry)caps_length, /* mp_length */
NULL,
NULL,
(intargfunc)caps_item,
NULL,
NULL,
NULL,
NULL,
};
%%
override-slot GstCaps.tp_str
static PyObject *
_wrap_gst_caps_tp_str(PyGObject *self)
{
gchar *tmp;
PyObject *retval;
tmp = gst_caps_to_string((GstCaps*)self->obj);
retval = PyString_FromString(tmp);
g_free(tmp);
return retval;
}

376
gst/gstelement.override Normal file
View file

@ -0,0 +1,376 @@
/* -*- Mode: C; c-basic-offset: 4 -*- */
/* 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
%%
override gst_element_get_pad_list noargs
static PyObject *
_wrap_gst_element_get_pad_list(PyGObject *self)
{
GList *l, *pads;
PyObject *list;
pads = GST_ELEMENT_PADS(GST_ELEMENT(self->obj));
list = PyList_New(0);
for (l = pads; l; l = l->next) {
GstPad *pad = (GstPad*)l->data;
PyList_Append(list, pygobject_new(G_OBJECT(pad)));
}
return list;
}
%%
override gst_element_get_pad_template_list noargs
static PyObject *
_wrap_gst_element_get_pad_template_list(PyGObject *self)
{
GList *l, *pads;
PyObject *list;
pads = (GList*)gst_element_get_pad_template_list(GST_ELEMENT(self->obj));
list = PyList_New(0);
for (l = pads; l; l = l->next) {
GstPad *pad = (GstPad*)l->data;
PyList_Append(list, pygobject_new(G_OBJECT(pad)));
}
return list;
}
%%
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_begin_allow_threads;
ret = gst_element_set_state(GST_ELEMENT(self->obj), state);
pyg_end_allow_threads;
return PyInt_FromLong(ret);
}
%%
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 = 0;
gboolean ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"ii:GstElement.query", kwlist,
&type, &format))
return NULL;
ret = gst_element_query(GST_ELEMENT(self->obj), type, &format, &value);
return PyLong_FromLongLong(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);
if (!ret) {
PyErr_SetString(PyExc_RuntimeError, "conversion could not be performed");
return NULL;
}
return PyInt_FromLong(dest_value);
}
%%
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)))
{
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", NULL };
PyGObject *dest;
int ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!:GstElement.link",
kwlist, &PyGstElement_Type, &dest))
return NULL;
ret = gst_element_link(GST_ELEMENT(self->obj), GST_ELEMENT(dest->obj));
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)
{
static char *kwlist[] = { "dest", "filtercaps", NULL };
PyGObject *dest;
PyObject *py_filtercaps;
int ret;
GstCaps *filtercaps = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O!O:GstElement.link_filtered",
kwlist, &PyGstElement_Type,
&dest, &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_element_link_filtered(GST_ELEMENT(self->obj),
GST_ELEMENT(dest->obj),
filtercaps);
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_pads kwargs
static PyObject *
_wrap_gst_element_link_pads(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "srcpadname", "dest", "destpadname", NULL };
char *srcpadname, *destpadname;
PyGObject *dest;
int ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"sO!s:GstElement.link_pads", kwlist,
&srcpadname, &PyGstElement_Type, &dest,
&destpadname))
return NULL;
ret = gst_element_link_pads(GST_ELEMENT(self->obj), srcpadname,
GST_ELEMENT(dest->obj), destpadname);
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;
}
ret = gst_element_link_pads_filtered(GST_ELEMENT(self->obj), srcpadname,
GST_ELEMENT(dest->obj), destpadname,
filtercaps);
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) {
gst_element_unlink(GST_ELEMENT(element->obj), GST_ELEMENT(element2->obj));
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 (pyg_boxed_check(py_event, GST_TYPE_EVENT))
event = pyg_boxed_get(py_event, GstEvent);
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);
ret = gst_element_send_event(GST_ELEMENT(self->obj), event);
return PyBool_FromLong(ret);
}

262
gst/gstpad-handlers.override
View file

@ -1,262 +0,0 @@
/* -*- Mode: C; c-basic-offset: 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 <johan@gnome.org
*/
%%
override gst_pad_set_link_function kwargs
static GstPadLinkReturn
call_link_function (GstPad *pad, GstCaps *caps)
{
PyObject *function;
PyObject *retval;
GstPadLinkReturn ret;
PyGILState_STATE state;
function = pad_private(pad)->link_function;
state = pyg_gil_state_ensure();
retval = (PyObject*)PyObject_CallFunction (function,
"OO",
pad_private(pad)->pad,
pyg_boxed_new(GST_TYPE_CAPS, caps, TRUE, TRUE));
if (PyErr_Occurred ()) {
PyErr_Print ();
pyg_gil_state_release(state);
return GST_PAD_LINK_REFUSED;
}
ret = PyInt_AsLong(retval);
pyg_gil_state_release(state);
return ret;
}
static PyObject*
_wrap_gst_pad_set_link_function (PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "link_function", NULL };
PyObject *link_function;
GstPad *pad;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O:GstPad.set_link_funcion",
kwlist,
&link_function)) {
return NULL;
}
if (!PyCallable_Check(link_function)) {
PyErr_SetString(PyExc_TypeError, "link_function not callable");
return NULL;
}
Py_INCREF(link_function);
py_pad_private(self)->link_function = link_function;
pad = (GstPad*)pygobject_get(self);
gst_pad_set_link_function(pad, (GstPadLinkFunction)call_link_function);
Py_INCREF(Py_None);
return Py_None;
}
%%
override gst_pad_set_chain_function kwargs
static void
call_chain_function(GstPad *pad, GstBuffer *buf)
{
PyObject *function;
PyGILState_STATE state;
function = pad_private(pad)->chain_function;
state = pyg_gil_state_ensure();
PyObject_CallFunction (function,
"OO",
pad_private(pad)->pad,
pyg_boxed_new(GST_TYPE_BUFFER, buf, TRUE, TRUE));
if (PyErr_Occurred ()) {
PyErr_Print ();
pyg_gil_state_release(state);
return;
}
pyg_gil_state_release(state);
}
static PyObject*
_wrap_gst_pad_set_chain_function(PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "chain_function", NULL };
PyObject *chain_function;
GstPad *pad;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O:GstPad.set_chain_funcion",
kwlist,
&chain_function)) {
return NULL;
}
if (!PyCallable_Check(chain_function)) {
PyErr_SetString(PyExc_TypeError, "chain_function not callable");
return NULL;
}
Py_INCREF(chain_function);
py_pad_private(self)->chain_function = chain_function;
pad = (GstPad*)pygobject_get(self);
gst_pad_set_chain_function(pad, (GstPadChainFunction)call_chain_function);
Py_INCREF(Py_None);
return Py_None;
}
%%
override gst_pad_set_event_function kwargs
static gboolean
call_event_function (GstPad *pad, GstEvent *event)
{
PyObject *function;
PyObject *retval;
gboolean ret;
PyGILState_STATE state;
function = pad_private(pad)->event_function;
state = pyg_gil_state_ensure();
retval = PyObject_CallFunction (function,
"OO",
pad_private(pad)->pad,
pyg_boxed_new(GST_TYPE_EVENT, event, TRUE, TRUE));
if (PyErr_Occurred ()) {
PyErr_Print ();
pyg_gil_state_release(state);
return FALSE;
}
ret = PyInt_AsLong(retval);
pyg_gil_state_release(state);
return ret;
}
static PyObject*
_wrap_gst_pad_set_event_function (PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "event_function", NULL };
PyObject *event_function;
GstPad *pad;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O:GstPad.set_event_funcion",
kwlist,
&event_function)) {
return NULL;
}
if (!PyCallable_Check(event_function)) {
PyErr_SetString(PyExc_TypeError, "event_function not callable");
return NULL;
}
Py_INCREF(event_function);
py_pad_private(self)->event_function = event_function;
pad = (GstPad*)pygobject_get(self);
gst_pad_set_event_function(pad, (GstPadEventFunction)call_event_function);
Py_INCREF(Py_None);
return Py_None;
}
%%
override gst_pad_set_get_function kwargs
static GstData*
call_get_function (GstPad *pad)
{
PyObject *function;
PyObject *retval;
GstData *data = NULL;
PyGILState_STATE state;
function = pad_private(pad)->get_function;
state = pyg_gil_state_ensure();
retval = PyObject_CallFunction(function, "O", pad_private(pad)->pad);
if (PyErr_Occurred()) {
PyErr_Print();
goto bail;
} else if (retval == Py_None) {
goto bail;
}
pygst_data_from_pyobject(retval, &data);
bail:
pyg_gil_state_release(state);
return data;
}
static PyObject*
_wrap_gst_pad_set_get_function (PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "get_function", NULL };
PyObject *get_function;
GstPad *pad;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O:GstPad.set_get_funcion",
kwlist,
&get_function)) {
return NULL;
}
if (!PyCallable_Check(get_function)) {
PyErr_SetString(PyExc_TypeError, "get_function not callable");
return NULL;
}
Py_INCREF(get_function);
py_pad_private(self)->get_function = get_function;
pad = (GstPad*)pygobject_get(self);
gst_pad_set_get_function(pad, (GstPadGetFunction)call_get_function);
Py_INCREF(Py_None);
return Py_None;
}

197
gst/gstpad.override
View file

@ -19,7 +19,38 @@
*
* Author: Johan Dahlin <johan@gnome.org
*/
%%
headers
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;
}
%%
ignore
gst_pad_select
gst_pad_selectv
gst_pad_load_and_link
%%
override gst_pad_set_link_function kwargs
@ -260,3 +291,169 @@ _wrap_gst_pad_set_get_function (PyGObject *self,
Py_INCREF(Py_None);
return Py_None;
}
%%
override-slot GstPad.tp_repr
static PyObject *
_wrap_gst_pad_tp_repr (PyGObject *self)
{
char *buf;
PyObject *retval;
GstPad *pad;
GstElement *parent;
pad = GST_PAD(self->obj);
parent = gst_pad_get_parent (pad);
buf = g_strdup_printf ("<GstPad (%s:%s) at %lx>",
gst_element_get_name (parent),
gst_pad_get_name (pad), (long) self->obj);
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[] = { "type", "format", NULL };
GstQueryType type;
GstFormat format;
gint64 value = 0;
gboolean ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"ii:GstPad.query", kwlist,
&type, &format))
return NULL;
ret = gst_pad_query(GST_PAD(self->obj), type, &format, &value);
return PyLong_FromLongLong(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 = 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) {
PyErr_SetString(PyGstExc_LinkError, "link failed");
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) {
PyErr_SetString(PyGstExc_LinkError, "link failed");
return NULL;
}
return PyBool_FromLong(ret);
}
%%
override gst_pad_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_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_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);
}

333
gst/gststructure.override Normal file
View file

@ -0,0 +1,333 @@
/* -*- Mode: C; c-basic-offset: 4 -*- */
/* 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>
*/
%%
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", "type_name", NULL };
char *field;
PyObject *py_value = NULL;
char *type_name = NULL;
GType type;
GValue value = { 0 };
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"sO|s:GstStructure.set_value",
kwlist, &field, &py_value,
&type_name)) {
return NULL;
}
if (type_name) {
if (strcmp (type_name, "char") == 0) {
type = G_TYPE_CHAR;
} else if (strcmp (type_name, "uchar") == 0) {
type = G_TYPE_UCHAR;
} else if (strcmp (type_name, "boolean") == 0) {
type = G_TYPE_BOOLEAN;
} else if (strcmp (type_name, "int") == 0) {
type = G_TYPE_INT;
} else if (strcmp (type_name, "uint") == 0) {
type = G_TYPE_UINT;
} else if (strcmp (type_name, "long") == 0) {
type = G_TYPE_LONG;
} else if (strcmp (type_name, "ulong") == 0) {
type = G_TYPE_ULONG;
} else if (strcmp (type_name, "int64") == 0) {
type = G_TYPE_INT64;
} else if (strcmp (type_name, "uint64") == 0) {
type = G_TYPE_UINT64;
} else if (strcmp (type_name, "float") == 0) {
type = G_TYPE_FLOAT;
} else if (strcmp (type_name, "double") == 0) {
type = G_TYPE_DOUBLE;
} else if (strcmp (type_name, "string") == 0) {
type = G_TYPE_STRING;
} else {
PyErr_SetString(PyExc_TypeError,
"invalid type name");
return NULL;
}
} else {
/* Let PyGTK guess a GType for the object. */
type = pyg_type_from_object((PyObject *) py_value->ob_type);
if (type == 0) {
return NULL;
}
}
g_value_init(&value, type);
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_get_int kwargs
static PyObject *
_wrap_gst_structure_get_int(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "fieldname", NULL };
char *fieldname;
int value;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"s:GstStructure.get_int",
kwlist, &fieldname))
return NULL;
if (gst_structure_get_int(pyg_boxed_get(self, GstStructure), fieldname, &value))
return PyInt_FromLong(value);
/* XXX: Raise exception? */
Py_INCREF(Py_None);
return Py_None;
}
%%
define GstStructure.has_key args
static PyObject*
_wrap_gst_structure_has_key(PyGObject *self, PyObject *args)
{
gchar *key;
gboolean has_field;
if (!PyArg_ParseTuple(args, "s:GstStructure.has_key", &key))
return NULL;
has_field = gst_structure_has_field((GstStructure*)self->obj, key);
return PyBool_FromLong(has_field);
}
%%
override-slot GstStructure.tp_as_mapping
static int
_wrap_gst_structure_length(PyGObject *self)
{
return gst_structure_n_fields((GstStructure*)self->obj);
}
static PyObject *
_wrap_gst_structure_subscript(PyGObject *self, PyObject *py_key)
{
PyObject *v = NULL;
const char *field = PyString_AsString(py_key);
if (gst_structure_has_field((GstStructure*)self->obj, field)) {
const GValue *gvalue;
gvalue = gst_structure_get_value((GstStructure*)self->obj, field);
g_assert(gvalue != NULL);
v = pyg_value_as_pyobject(gvalue, TRUE);
} else {
PyErr_SetString(PyExc_KeyError, field);
}
if (v != NULL)
Py_INCREF(v);
return v;
}
static int
_wrap_gst_structure_ass_subscript(PyGObject *self,
PyObject *py_key,
PyObject *py_value)
{
const char *key;
GstStructure* structure;
structure = (GstStructure*)self->obj;
key = PyString_AsString(py_key);
if (py_value != NULL) {
if (PyString_Check(py_value)) {
#if 0
GValue *value = NULL;
gst_structure_field_from_string(PyString_AsString(py_value), value);
g_print ("gvalue: %s %s %s\n",
PyString_AsString(py_value),
gst_value_serialize(value),
G_VALUE_TYPE_NAME(value));
gst_structure_set_value(structure, key, value);
#else
GValue value = { 0, };
g_value_init (&value, G_TYPE_STRING);
gst_value_deserialize(&value, PyString_AsString(py_value));
gst_structure_set_value(structure, key, &value);
g_value_unset(&value);
#endif
// gst_structure_set(structure, key, G_TYPE_STRING, PyString_AsString(py_value), NULL);
} else if (PyInt_Check(py_value))
gst_structure_set(structure, key, G_TYPE_INT, PyInt_AsLong(py_value), NULL);
else if (PyFloat_Check(py_value))
gst_structure_set(structure, key, G_TYPE_DOUBLE, PyFloat_AsDouble(py_value), NULL);
#if 0
g_value_init(&value, g_type_from_name("PyObject"));
if (pyg_value_from_pyobject(&value, py_value)) {
PyErr_SetString(PyExc_TypeError, "can't convert value");
return -1;
}
gst_structure_set_value(structure, key, &value);
g_value_unset(&value);
#endif
} else {
gst_structure_remove_field(structure, key);
}
return 0;
}
static PyMappingMethods _wrap_gst_structure_tp_as_mapping = {
(inquiry)_wrap_gst_structure_length, /* mp_length */
(binaryfunc)_wrap_gst_structure_subscript, /* mp_subscript */
(objobjargproc)_wrap_gst_structure_ass_subscript /* mp_ass_subscript */
};
%%
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;
PyGILState_STATE state;
g_assert(cunote->func);
state = pyg_gil_state_ensure();
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_gil_state_release(state);
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-slot GstStructure.tp_repr
static PyObject *
_wrap_gst_structure_tp_repr (PyGObject *self)
{
char *buf;
PyObject *retval;
buf = g_strdup_printf("<GstStructure (%s) at %lx>",
gst_structure_get_name((GstStructure*)self->obj),
(long)self->obj);
retval = PyString_FromString(buf);
g_free(buf);
return retval;
}
%%
override gst_structure_from_string kwargs
static PyObject *
_wrap_gst_structure_from_string(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "string", NULL };
char *string;
GstStructure *ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:structure_from_string", kwlist, &string))
return NULL;
ret = gst_structure_from_string(string, NULL);
/* pyg_boxed_new handles NULL checking */
return pyg_boxed_new(GST_TYPE_STRUCTURE, ret, TRUE, TRUE);
}