gstreamer/gst/gstreamer.override
David I. Lehn 166d345b1f add GstPropsEntry and wrappers for most of get_* methods
Original commit message from CVS:
add GstPropsEntry and wrappers for most of get_* methods
2003-01-04 18:43:10 +00:00

436 lines
10 KiB
C

/* -*- Mode: C; c-basic-offset: 4 -*- */
/* gst-python
* Copyright (C) 2002 David I. Lehn
*
* 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>
#include "pygobject.h"
#include <gst/gst.h>
#include "gstreamer-fixes.h"
typedef struct {
PyGObject *pad;
PyObject *connect_function;
PyObject *chain_function;
} PyGstPadPrivate;
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;
}
%%
modulename gstreamer
%%
import gobject.GObject as PyGObject_Type
%%
ignore-glob
_*
gstreamer_*init
*_get_type
%%
override gst_pad_set_connect_function kwargs
static GstPadConnectReturn
call_connect_function (GstPad *pad, GstCaps *caps)
{
PyObject *function;
PyObject *retval;
GstPadConnectReturn ret;
function = pad_private(pad)->connect_function;
pyg_block_threads();
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_unblock_threads();
return GST_PAD_CONNECT_REFUSED;
}
ret = PyInt_AsLong(retval);
pyg_unblock_threads();
return ret;
}
static PyObject*
_wrap_gst_pad_set_connect_function (PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "connect_function", NULL };
PyObject *connect_function;
GstPad *pad;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"O:GstPad.set_connect_funcion",
kwlist,
&connect_function)) {
return NULL;
}
if (!PyCallable_Check(connect_function)) {
PyErr_SetString(PyExc_TypeError, "connect_function not callable");
return NULL;
}
Py_INCREF(connect_function);
py_pad_private(self)->connect_function = connect_function;
pad = (GstPad*)pygobject_get(self);
gst_pad_set_connect_function(pad, call_connect_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;
function = pad_private(pad)->chain_function;
pyg_block_threads();
PyObject_CallFunction (function,
"OO",
pad_private(pad)->pad,
pyg_boxed_new(GST_TYPE_BUFFER, buf, TRUE, TRUE));
if (PyErr_Occurred ()) {
PyErr_Print ();
pyg_unblock_threads();
return;
}
pyg_unblock_threads();
}
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, call_chain_function);
Py_INCREF(Py_None);
return Py_None;
}
%%
override gst_buffer_get_data
static PyObject*
_wrap_gst_buffer_get_data(PyObject *self)
{
GstBuffer *buf;
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_props_entry_get_int
static PyObject *
_wrap_gst_props_entry_get_int(PyObject *self)
{
gboolean ret;
gint val;
val = 0;
ret = gst_props_entry_get_int(pyg_boxed_get(self, GstPropsEntry), &val);
return Py_BuildValue("(bi)", ret, val);
}
%%
override gst_props_entry_get_float
static PyObject *
_wrap_gst_props_entry_get_float(PyObject *self)
{
gboolean ret;
gfloat val;
val = 0.0f;
ret = gst_props_entry_get_float(pyg_boxed_get(self, GstPropsEntry), &val);
return Py_BuildValue("(bf)", ret, val);
}
%%
override gst_props_entry_get_fourcc_int
static PyObject *
_wrap_gst_props_entry_get_fourcc_int(PyObject *self)
{
gboolean ret;
gint32 val;
val = 0;
ret = gst_props_entry_get_fourcc_int(pyg_boxed_get(self, GstPropsEntry), &val);
return Py_BuildValue("(bi)", ret, val);
}
%%
override gst_props_entry_get_boolean
static PyObject *
_wrap_gst_props_entry_get_boolean(PyObject *self)
{
gboolean ret;
gboolean val;
PyObject *py_val;
val = FALSE;
ret = gst_props_entry_get_boolean(pyg_boxed_get(self, GstPropsEntry), &val);
py_val = val ? Py_True : Py_False;
return Py_BuildValue("(bO)", ret, py_val);
}
%%
override gst_props_entry_get_string
static PyObject *
_wrap_gst_props_entry_get_string(PyObject *self)
{
gboolean ret;
const gchar *val;
val = NULL;
ret = gst_props_entry_get_string(pyg_boxed_get(self, GstPropsEntry), &val);
if (ret) {
return Py_BuildValue("(bs)", ret, val);
} else {
return Py_BuildValue("(bO)", ret, Py_None);
}
}
%%
override gst_props_entry_get_int_range
static PyObject *
_wrap_gst_props_entry_get_int_range(PyObject *self)
{
gboolean ret;
gint min, max;
min = max = 0;
ret = gst_props_entry_get_int_range(pyg_boxed_get(self, GstPropsEntry), &min, &max);
return Py_BuildValue("(bii)", ret, min, max);
}
%%
override gst_props_entry_get_float_range
static PyObject *
_wrap_gst_props_entry_get_float_range(PyObject *self)
{
gboolean ret;
gfloat min, max;
min = max = 0.0f;
ret = gst_props_entry_get_float_range(pyg_boxed_get(self, GstPropsEntry), &min, &max);
return Py_BuildValue("(bff)", ret, min, max);
}