gstreamer/gst/gstquery.override

/* -*- Mode: C; ; c-file-style: "python" -*- */
/* gst-python
 * Copyright (C) 2005 Edward Hervey
 *
 * 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_query_set_formatsv
%%
override gst_query_parse_position noargs
static PyObject *
_wrap_gst_query_parse_position (PyGstMiniObject *self)
{
	GstFormat	format;
	gint64		cur;

	if (GST_QUERY_TYPE(self->obj) != GST_QUERY_POSITION) {
		PyErr_SetString(PyExc_TypeError, "Query is not a 'Position' query");
		return NULL;
	}
	
	gst_query_parse_position (GST_QUERY(self->obj), &format, &cur);
	
	return Py_BuildValue("(OL)",
			     pyg_enum_from_gtype (GST_TYPE_FORMAT, format),
			     cur);
}
%%
override gst_query_parse_duration noargs
static PyObject *
_wrap_gst_query_parse_duration (PyGstMiniObject *self)
{
	GstFormat	format;
	gint64		cur;

	if (GST_QUERY_TYPE(self->obj) != GST_QUERY_DURATION) {
		PyErr_SetString(PyExc_TypeError, "Query is not a 'Duration' query");
		return NULL;
	}
	
	gst_query_parse_duration (GST_QUERY(self->obj), &format, &cur);
	
	return Py_BuildValue("(OL)",
			     pyg_enum_from_gtype (GST_TYPE_FORMAT, format),
			     cur);
}
%%
override gst_query_parse_convert noargs
static PyObject *
_wrap_gst_query_parse_convert (PyGstMiniObject *self)
{
	GstFormat	srcformat, destformat;
	gint64		srcvalue, destvalue;

	if (GST_QUERY_TYPE(self->obj) != GST_QUERY_CONVERT) {
		PyErr_SetString(PyExc_TypeError, "Query is not a 'Convert' query");
		return NULL;
	}

	gst_query_parse_convert (GST_QUERY(self->obj), 
				 &srcformat, &srcvalue,
				 &destformat, &destvalue);
	
	return Py_BuildValue("(OLOL)",
			     pyg_enum_from_gtype(GST_TYPE_FORMAT, srcformat),
			     srcvalue,
			     pyg_enum_from_gtype(GST_TYPE_FORMAT, destformat),
			     destvalue);
}
%%
override gst_query_parse_segment noargs
static PyObject *
_wrap_gst_query_parse_segment (PyGstMiniObject *self)
{
	gdouble		rate;
	GstFormat	format;
	gint64		start_value;
	gint64		stop_value;

	if (GST_QUERY_TYPE(self->obj) != GST_QUERY_SEGMENT) {
		PyErr_SetString(PyExc_TypeError, "Query is not a 'Segment' query");
		return NULL;
	}

	gst_query_parse_segment (GST_QUERY(self->obj),
				 &rate, &format,
				 &start_value, &stop_value);
	
	return Py_BuildValue("(dOLL)",
			     rate,
			     pyg_enum_from_gtype (GST_TYPE_FORMAT, format),
			     start_value, stop_value);
}
%%
override gst_query_parse_seeking noargs
static PyObject *
_wrap_gst_query_parse_seeking (PyGstMiniObject *self)
{
	GstFormat	format;
	gboolean	seekable;
	gint64		segment_start, segment_end;

	if (GST_QUERY_TYPE(self->obj) != GST_QUERY_SEEKING) {
		PyErr_SetString(PyExc_TypeError, "Query is not a 'Seeking' query");
		return NULL;
	}

	gst_query_parse_seeking (GST_QUERY(self->obj),
				 &format, &seekable,
				 &segment_start, &segment_end);
	
	return Py_BuildValue("(OOLL)",
			     pyg_enum_from_gtype (GST_TYPE_FORMAT, format),
			     PyBool_FromLong(seekable),
			     segment_start,
			     segment_end);
}
%%
override gst_query_parse_formats_length noargs
static PyObject *
_wrap_gst_query_parse_formats_length (PyGstMiniObject *self)
{
	PyObject	*ret;
	guint		n_formats;
	
	if (GST_QUERY_TYPE(self->obj) != GST_QUERY_FORMATS) {
		PyErr_SetString(PyExc_TypeError, "Query is not a 'Formats' query");
		return NULL;
	}

	gst_query_parse_formats_length (GST_QUERY (self->obj),
					&n_formats);

	ret = PyInt_FromLong(n_formats);
	
	return ret;
}
%%
override gst_query_parse_formats_nth kwargs
static PyObject *
_wrap_gst_query_parse_formats_nth (PyGstMiniObject *self, PyObject *args, PyObject *kwargs)
{
	static char *kwlist[] = {"nth", NULL};
	guint		nth;
	GstFormat	format;

	if (GST_QUERY_TYPE (self->obj) != GST_QUERY_FORMATS) {
		PyErr_SetString(PyExc_TypeError, "Query is not a 'Formats' query");
		return NULL;
	}

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "I:GstQuery.parse_formats_nth", kwlist, &nth))
		return NULL;

	gst_query_parse_formats_nth (GST_QUERY (self->obj),
				     nth, &format);

	return pyg_enum_from_gtype (GST_TYPE_FORMAT, format);
}
%%
override gst_query_set_formats args
static PyObject *
_wrap_gst_query_set_formats (PyGstMiniObject *self, PyObject *args)
{
	PyObject	*ret = NULL;
	gint	len, i;
	GstFormat *formats;

	if (GST_QUERY_TYPE (self->obj) != GST_QUERY_FORMATS) {
		PyErr_SetString(PyExc_TypeError, "Query is not a 'Formats' query");
		return NULL;
	}

	if ((len = PyTuple_Size(args)) < 1) {
		PyErr_SetString(PyExc_TypeError, "You need to supply at least one gst.Format");
		return NULL;
	}

	formats = g_new0(GstFormat, len);

	for (i = 0; i < len; i++) {
		if (pyg_enum_get_value(GST_TYPE_FORMAT, 
				       PyTuple_GetItem(args, i), 
				       (gint *) &formats[i]))
			goto beach;
	}

	gst_query_set_formatsv (GST_QUERY(self->obj), len, formats);

	Py_INCREF(Py_None);
	ret = Py_None;

  beach:
	g_free(formats);
	return ret;
}
%%
override gst_query_get_structure noargs
static PyObject *
_wrap_gst_query_get_structure(PyGstMiniObject *self)
{
    GstStructure *ret;

    pyg_begin_allow_threads;
    ret = gst_query_get_structure(GST_QUERY(self->obj));
    pyg_end_allow_threads;
    /* pyg_boxed_new handles NULL checking */
    return pyg_boxed_new(GST_TYPE_STRUCTURE, ret, FALSE, FALSE);
}
%%
override gst_query_parse_latency noargs
static PyObject *
_wrap_gst_query_parse_latency (PyGstMiniObject * self)
{
	gboolean islive;
	GstClockTime	minlat, maxlat;

     if (GST_QUERY_TYPE (self->obj) != GST_QUERY_LATENCY) {
	  PyErr_SetString(PyExc_TypeError, "Query is not a 'latency' query");
	  return NULL;
     }
     
     gst_query_parse_latency (GST_QUERY (self->obj), &islive, &minlat, &maxlat);
     
     return Py_BuildValue("(OKK)",
			  PyBool_FromLong(islive),
			  minlat, maxlat);
}
%%
override gst_query_parse_buffering_percent noargs
static PyObject *
_wrap_gst_query_parse_buffering_percent (PyGstMiniObject * self)
{
	gboolean busy;
	gint percent;

     if (GST_QUERY_TYPE (self->obj) != GST_QUERY_BUFFERING) {
	  PyErr_SetString(PyExc_TypeError, "Query is not a 'buffering' query");
	  return NULL;
     }
     
     gst_query_parse_buffering_percent (GST_QUERY (self->obj), &busy, &percent);
     
     return Py_BuildValue("(Od)", PyBool_FromLong(busy), percent);
}
%%
override gst_query_parse_buffering_stats noargs
static PyObject *
_wrap_gst_query_parse_buffering_stats (PyGstMiniObject * self)
{
	GstBufferingMode mode;
	gint avg_in, avg_out;
	gint64 buffering_left;
	
     if (GST_QUERY_TYPE (self->obj) != GST_QUERY_BUFFERING) {
	  PyErr_SetString(PyExc_TypeError, "Query is not a 'buffering' query");
	  return NULL;
     }
     
     gst_query_parse_buffering_stats (GST_QUERY (self->obj), &mode,
				      &avg_in, &avg_out,
				      &buffering_left);
     return Py_BuildValue("OiiL",
			  pyg_enum_from_gtype (GST_TYPE_BUFFERING_MODE, mode),
			  avg_in, avg_out, buffering_left);
}
%%
override gst_query_parse_buffering_range noargs
static PyObject *
_wrap_gst_query_parse_buffering_range (PyGstMiniObject * self)
{
	GstFormat format;
	gint64 start, stop, estimated_total;
	
     if (GST_QUERY_TYPE (self->obj) != GST_QUERY_BUFFERING) {
	  PyErr_SetString(PyExc_TypeError, "Query is not a 'buffering' query");
	  return NULL;
     }
     
     gst_query_parse_buffering_range (GST_QUERY (self->obj), &format,
				      &start, &stop, &estimated_total);
     return Py_BuildValue("OLLL",
			  pyg_enum_from_gtype (GST_TYPE_FORMAT, format),
			  start, stop, estimated_total);
}
%%
override gst_query_parse_uri noargs
static PyObject *
_wrap_gst_query_parse_uri (PyGstMiniObject * self)
{
	gchar *uri = NULL;
	PyObject *ret;
	
     if (GST_QUERY_TYPE (self->obj) != GST_QUERY_URI) {
	  PyErr_SetString(PyExc_TypeError, "Query is not a 'uri' query");
	  return NULL;
     }
     
     gst_query_parse_uri (GST_QUERY (self->obj), &uri);
     if (uri) {
	     ret = PyString_FromStringAndSize(uri, strlen (uri));
	     g_free(uri);
     } else {
	     Py_INCREF(Py_None);
	     ret = Py_None;
     }
     return ret;
}