← Back to branch summary

~ubuntu-branches/ubuntu/precise/gst0.10-python/precise

« back to all changes in this revision

Viewing changes to gst/gstelement.override

  • Committer: Bazaar Package Importer
  • Author(s): Loic Minier
  • Date: 2006-06-25 19:37:45 UTC
  • Revision ID: james.westby@ubuntu.com-20060625193745-9yeg0wq56r24n57x
Tags: upstream-0.10.4
Import upstream version 0.10.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst/gstelement.override
 
1
/* -*- Mode: C; c-basic-offset: 8 -*- */
 
2
/* gst-python
 
3
 * Copyright (C) 2005 Johan Dahlin
 
4
 *
 
5
 * This library is free software; you can redistribute it and/or
 
6
 * modify it under the terms of the GNU Library General Public
 
7
 * License as published by the Free Software Foundation; either
 
8
 * version 2 of the License, or (at your option) any later version.
 
9
 *
 
10
 * This library is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
13
 * Library General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU Library General Public
 
16
 * License along with this library; if not, write to the
 
17
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
18
 * Boston, MA 02111-1307, USA.
 
19
 * 
 
20
 * Author: Johan Dahlin <johan@gnome.org>
 
21
 */
 
22
%%
 
23
ignore
 
24
  gst_element_get
 
25
  gst_element_set
 
26
  gst_element_get_property
 
27
  gst_element_set_property
 
28
%%
 
29
override gst_element_get_pad_template args
 
30
static PyObject *
 
31
_wrap_gst_element_get_pad_template(PyGObject *self, PyObject *args)
 
32
{
 
33
        PyObject *ret;
 
34
        gchar *name;
 
35
        GstPadTemplate *tmpl;
 
36
    
 
37
        if (!PyArg_ParseTuple(args, "s:GstElement.get_pad_template", &name))
 
38
                return NULL;
 
39
 
 
40
        tmpl = gst_element_class_get_pad_template
 
41
            (GST_ELEMENT_GET_CLASS (self->obj), name);
 
42
 
 
43
        if (tmpl) {
 
44
                ret = pygstobject_new (G_OBJECT (tmpl));
 
45
        } else {
 
46
                ret = Py_None;
 
47
                Py_INCREF (ret);
 
48
        }
 
49
 
 
50
        return ret;
 
51
}
 
52
%%
 
53
override gst_element_set_state kwargs
 
54
static PyObject *
 
55
_wrap_gst_element_set_state(PyGObject *self, PyObject *args, PyObject *kwargs)
 
56
{
 
57
        static char *kwlist[] = { "state", NULL };
 
58
        PyObject *py_state = NULL;
 
59
        GstState state;
 
60
        gint ret;
 
61
 
 
62
        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GstElement.set_state", kwlist, &py_state))
 
63
                return NULL;
 
64
        if (pyg_enum_get_value(GST_TYPE_STATE, py_state, (gint *)&state))
 
65
                return NULL;
 
66
 
 
67
        pyg_begin_allow_threads;
 
68
    
 
69
        ret = gst_element_set_state(GST_ELEMENT(self->obj), state);
 
70
    
 
71
        pyg_end_allow_threads;
 
72
 
 
73
        return pyg_enum_from_gtype(GST_TYPE_STATE_CHANGE_RETURN, ret);
 
74
}
 
75
%%
 
76
override gst_element_get_state kwargs
 
77
static PyObject *
 
78
_wrap_gst_element_get_state(PyGObject *self, PyObject *args, PyObject *kwargs)
 
79
{
 
80
    static char *kwlist[] = { "timeout", NULL };
 
81
    GstState state;
 
82
    GstState pending;
 
83
    GstStateChangeReturn ret;
 
84
    GstClockTime timeout = GST_CLOCK_TIME_NONE;
 
85
    PyObject *tuple;
 
86
 
 
87
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 
88
                                     "|K:GstElement.get_state", kwlist,
 
89
                                     &timeout)) {
 
90
        PyErr_SetString(PyExc_RuntimeError, "Timeout not specified correctly");
 
91
        return NULL;
 
92
    }
 
93
 
 
94
    pyg_begin_allow_threads;
 
95
 
 
96
    ret = gst_element_get_state(GST_ELEMENT (self->obj), &state, &pending,
 
97
        timeout);
 
98
 
 
99
    pyg_end_allow_threads;
 
100
 
 
101
    tuple = Py_BuildValue("OOO",
 
102
        pyg_enum_from_gtype (GST_TYPE_STATE_CHANGE_RETURN, ret),
 
103
        pyg_enum_from_gtype (GST_TYPE_STATE, state),
 
104
        pyg_enum_from_gtype (GST_TYPE_STATE, pending));
 
105
 
 
106
    return tuple;
 
107
}
 
108
%%
 
109
override gst_element_link_many args
 
110
static PyObject *
 
111
_wrap_gst_element_link_many(PyObject *self, PyObject *args)
 
112
{
 
113
        PyGObject *element, *element2;
 
114
        int i, len;
 
115
 
 
116
        len = PyTuple_Size(args);
 
117
        if (len < 2)
 
118
        {
 
119
                PyErr_SetString(PyExc_TypeError, "gst.element_link_many requires at least two argument");
 
120
                return NULL;
 
121
        }
 
122
       
 
123
 
 
124
        for (i = 0; i < len; i++)
 
125
        {
 
126
                element = (PyGObject*)PyTuple_GetItem(args, i);
 
127
                if (!pygobject_check(element, &PyGstElement_Type))
 
128
                {
 
129
                        PyErr_SetString(PyExc_TypeError, "argument must be a GstElement");
 
130
                        return NULL;
 
131
                }
 
132
        }
 
133
 
 
134
        /* Mimic the real gst_element_link_many */
 
135
        element = (PyGObject*)PyTuple_GetItem(args, 0);
 
136
        element2 = (PyGObject*)PyTuple_GetItem(args, 1);
 
137
 
 
138
        i = 2;
 
139
        while (1) {
 
140
 
 
141
                if (!gst_element_link(GST_ELEMENT(element->obj),
 
142
                                      GST_ELEMENT(element2->obj)))
 
143
                {
 
144
                    PyErr_Format(PyGstExc_LinkError,
 
145
                                 "failed to link %s with %s",
 
146
                                 GST_ELEMENT_NAME(element->obj),
 
147
                                 GST_ELEMENT_NAME(element2->obj));
 
148
                    return NULL;
 
149
                }
 
150
 
 
151
                if (i >= len)
 
152
                        break;
 
153
                
 
154
                element = element2;
 
155
                element2 = (PyGObject*)PyTuple_GetItem(args, i);
 
156
        
 
157
                i++;
 
158
        }
 
159
 
 
160
        Py_INCREF(Py_True);
 
161
        return Py_True;
 
162
}
 
163
 
 
164
 
 
165
%%
 
166
override gst_element_link kwargs
 
167
static PyObject *
 
168
_wrap_gst_element_link(PyGObject *self, PyObject *args, PyObject *kwargs)
 
169
{
 
170
    static char *kwlist[] = { "dest", "filtercaps", NULL };
 
171
    PyGObject *dest;
 
172
    PyObject *py_caps = NULL;
 
173
    int ret;
 
174
    GstCaps *caps = NULL;
 
175
    gboolean caps_is_copy;
 
176
 
 
177
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!|O:GstElement.link",
 
178
                                     kwlist, &PyGstElement_Type, &dest, &py_caps))
 
179
        return NULL;
 
180
    if (py_caps == NULL)
 
181
      caps = NULL;
 
182
    else {
 
183
      caps = pygst_caps_from_pyobject (py_caps, &caps_is_copy);
 
184
      if (caps == NULL)
 
185
        /* an error happened, propagate up */
 
186
        return NULL;
 
187
    }
 
188
 
 
189
    ret = gst_element_link_filtered(GST_ELEMENT(self->obj), GST_ELEMENT(dest->obj), caps);
 
190
    if (caps && caps_is_copy)
 
191
        gst_caps_unref (caps);
 
192
    if (!ret) {
 
193
        PyErr_Format(PyGstExc_LinkError,
 
194
                     "failed to link %s with %s",
 
195
                     GST_ELEMENT_NAME(self->obj),
 
196
                     GST_ELEMENT_NAME(dest->obj));
 
197
        return NULL;
 
198
    }
 
199
    return PyBool_FromLong(ret);
 
200
}
 
201
 
 
202
%%
 
203
override gst_element_link_filtered kwargs
 
204
static PyObject *
 
205
_wrap_gst_element_link_filtered(PyGObject *self, PyObject *args,
 
206
                                PyObject *kwargs)
 
207
{
 
208
    if (PyErr_Warn(PyExc_DeprecationWarning, "element.link_filtered is deprecated, use element.link") < 0)
 
209
        return NULL;
 
210
    return _wrap_gst_element_link (self, args, kwargs);
 
211
}
 
212
 
 
213
%%
 
214
override gst_element_link_pads kwargs
 
215
static gboolean
 
216
pad_name_from_object (PyObject *object, const gchar **name)
 
217
{
 
218
  if (object == Py_None) {
 
219
    *name = NULL;
 
220
    return TRUE;
 
221
  } else if (PyString_Check (object)) {
 
222
    *name = PyString_AsString (object);
 
223
    return TRUE;
 
224
  } else if (pygobject_check (object, &PyGstPad_Type)) {
 
225
    *name = gst_object_get_name (GST_OBJECT (pygobject_get (object)));
 
226
    return TRUE;
 
227
  }
 
228
  PyErr_SetString(PyExc_TypeError, "argument could not be converted to a pad");
 
229
  return FALSE;
 
230
}
 
231
 
 
232
static PyObject *
 
233
_wrap_gst_element_link_pads(PyGObject *self, PyObject *args, PyObject *kwargs)
 
234
{
 
235
    static char *kwlist[] = { "srcpadname", "dest", "destpadname", NULL };
 
236
    const char *srcpadname, *destpadname;
 
237
    PyGObject *dest;
 
238
    PyObject *srcpad, *destpad;
 
239
    int ret;
 
240
 
 
241
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 
242
                                     "OO!O:GstElement.link_pads", kwlist,
 
243
                                     &srcpad, &PyGstElement_Type, &dest,
 
244
                                     &destpad))
 
245
        return NULL;
 
246
    if (!pad_name_from_object (srcpad, &srcpadname) ||
 
247
        !pad_name_from_object (destpad, &destpadname))
 
248
        return NULL;
 
249
    ret = gst_element_link_pads(GST_ELEMENT(self->obj), srcpadname,
 
250
                                GST_ELEMENT(dest->obj), destpadname);
 
251
    if (!ret) {
 
252
        PyErr_SetString(PyGstExc_LinkError, "link failed");
 
253
        return NULL;
 
254
    }
 
255
    return PyBool_FromLong(ret);
 
256
 
 
257
}
 
258
 
 
259
%%
 
260
override gst_element_link_pads_filtered kwargs
 
261
static PyObject *
 
262
_wrap_gst_element_link_pads_filtered(PyGObject *self, PyObject *args,
 
263
                                     PyObject *kwargs)
 
264
{
 
265
    static char *kwlist[] = { "srcpadname", "dest", "destpadname",
 
266
                              "filtercaps", NULL };
 
267
    char *srcpadname, *destpadname;
 
268
    PyGObject *dest;
 
269
    int ret;
 
270
    PyObject *py_filtercaps;
 
271
    GstCaps *filtercaps = NULL;
 
272
 
 
273
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 
274
                                     "sO!sO:GstElement.link_pads_filtered",
 
275
                                     kwlist, &srcpadname, &PyGstElement_Type,
 
276
                                     &dest, &destpadname, &py_filtercaps))
 
277
        return NULL;
 
278
    if (pyg_boxed_check(py_filtercaps, GST_TYPE_CAPS))
 
279
        filtercaps = pyg_boxed_get(py_filtercaps, GstCaps);
 
280
    else {
 
281
        PyErr_SetString(PyExc_TypeError, "filtercaps should be a GstCaps");
 
282
        return NULL;
 
283
    }
 
284
    ret = gst_element_link_pads_filtered(GST_ELEMENT(self->obj), srcpadname,
 
285
                                         GST_ELEMENT(dest->obj), destpadname,
 
286
                                         filtercaps);
 
287
    if (!ret) {
 
288
        PyErr_SetString(PyGstExc_LinkError, "link failed");
 
289
        return NULL;
 
290
    }
 
291
    return PyBool_FromLong(ret);
 
292
}
 
293
 
 
294
%%
 
295
override gst_element_unlink_many args
 
296
static PyObject *
 
297
_wrap_gst_element_unlink_many(PyObject *self, PyObject *args)
 
298
{
 
299
        PyGObject *element, *element2;
 
300
        int i, len;
 
301
 
 
302
        len = PyTuple_Size(args);
 
303
        if (len < 2)
 
304
        {
 
305
                PyErr_SetString(PyExc_TypeError, "gst.element_unlink_many requires at least two arguments");
 
306
                return NULL;
 
307
        }
 
308
       
 
309
 
 
310
        for (i = 0; i < len; i++)
 
311
        {
 
312
                element = (PyGObject*)PyTuple_GetItem(args, i);
 
313
                if (!pygobject_check(element, &PyGstElement_Type))
 
314
                {
 
315
                        PyErr_SetString(PyExc_TypeError, "argument must be a GstElement");
 
316
                        return NULL;
 
317
                }
 
318
        }
 
319
 
 
320
        /* Mimic the real gst_element_unlink_many */
 
321
        element = (PyGObject*)PyTuple_GetItem(args, 0);
 
322
        element2 = (PyGObject*)PyTuple_GetItem(args, 1);
 
323
 
 
324
        i = 2;
 
325
        while (1) {
 
326
                gst_element_unlink(GST_ELEMENT(element->obj), GST_ELEMENT(element2->obj));
 
327
 
 
328
                if (i >= len)
 
329
                        break;
 
330
                
 
331
                element = element2;
 
332
                element2 = (PyGObject*)PyTuple_GetItem(args, i);
 
333
        
 
334
                i++;
 
335
        }
 
336
        Py_INCREF(Py_None);
 
337
        return Py_None;
 
338
}
 
339
%%
 
340
override gst_element_send_event kwargs
 
341
static PyObject *
 
342
_wrap_gst_element_send_event(PyGObject *self, PyObject *args, PyObject *kwargs)
 
343
{
 
344
    static char *kwlist[] = { "event", NULL };
 
345
    PyObject *py_event;
 
346
    int ret;
 
347
    GstEvent *event = NULL;
 
348
 
 
349
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GstElement.send_event", kwlist, &py_event))
 
350
        return NULL;
 
351
    if (pygstminiobject_check (py_event, &PyGstEvent_Type)) {
 
352
        event = GST_EVENT (pygstminiobject_get (py_event));
 
353
    } else {
 
354
        PyErr_SetString(PyExc_TypeError, "event should be a GstEvent");
 
355
        return NULL;
 
356
    }
 
357
 
 
358
    /* The pipeline unrefs the event, but we want to keep the ownership */
 
359
    gst_event_ref(event);
 
360
    
 
361
    ret = gst_element_send_event(GST_ELEMENT(self->obj), event);
 
362
    return PyBool_FromLong(ret);
 
363
 
 
364
}
 
365
%%
 
366
override gst_element_query_position args
 
367
static PyObject *
 
368
_wrap_gst_element_query_position (PyGObject *self, PyObject *args)
 
369
{
 
370
    gint64      cur;
 
371
    gint        format;
 
372
    PyObject    *pformat;
 
373
    PyObject    *ret;
 
374
 
 
375
    pformat = (PyObject*)PyTuple_GetItem(args, 0);
 
376
    if (pyg_enum_get_value (GST_TYPE_FORMAT, pformat, &format)) {
 
377
        PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat");
 
378
        return NULL;
 
379
    }
 
380
 
 
381
    if (!(gst_element_query_position(GST_ELEMENT (self->obj), (GstFormat*) &format, &cur))) {
 
382
        PyErr_Format(PyGstExc_QueryError,
 
383
                     "query failed");
 
384
        return NULL;
 
385
    }
 
386
 
 
387
    ret = PyList_New(2);
 
388
    PyList_SetItem(ret, 0, PyLong_FromLongLong(cur));
 
389
    PyList_SetItem(ret, 1, pyg_enum_from_gtype (GST_TYPE_FORMAT, format ));
 
390
 
 
391
    return ret;
 
392
}
 
393
%%
 
394
override gst_element_query_duration args
 
395
static PyObject *
 
396
_wrap_gst_element_query_duration (PyGObject *self, PyObject *args)
 
397
{
 
398
    gint64      cur;
 
399
    gint        format;
 
400
    PyObject    *pformat;
 
401
    PyObject    *ret;
 
402
 
 
403
    pformat = (PyObject*)PyTuple_GetItem(args, 0);
 
404
    if (pyg_enum_get_value (GST_TYPE_FORMAT, pformat, &format)) {
 
405
        PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat");
 
406
        return NULL;
 
407
    }
 
408
 
 
409
    if (!(gst_element_query_duration(GST_ELEMENT (self->obj), (GstFormat*) &format, &cur))) {
 
410
        PyErr_Format(PyGstExc_QueryError,
 
411
                     "query failed");
 
412
        return NULL;
 
413
    }
 
414
 
 
415
    ret = PyList_New(2);
 
416
    PyList_SetItem(ret, 0, PyLong_FromLongLong(cur));
 
417
    PyList_SetItem(ret, 1, pyg_enum_from_gtype (GST_TYPE_FORMAT, format ));
 
418
 
 
419
    return ret;
 
420
}
 
421
%%
 
422
override gst_element_query_convert kwargs
 
423
static PyObject *
 
424
_wrap_gst_element_query_convert (PyGObject *self, PyObject *args, PyObject *kwargs)
 
425
{
 
426
    static char *kwlist[] = { "fromformat", "fromvalue", "destformat", NULL };
 
427
    PyObject    *pfromformat, *pdestformat;
 
428
    GstFormat   srcformat, destformat;
 
429
    gint64      fromval, dstval;
 
430
    PyObject    *ret;
 
431
 
 
432
    /* Input : src_format, src_val, dst_format */
 
433
    /* Returns : dst_format, dst_val OR None */
 
434
 
 
435
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 
436
                                     "OLO:GstElement.query_convert",
 
437
                                     kwlist, &pfromformat, &fromval, &pdestformat))
 
438
        return NULL;
 
439
 
 
440
    if (pyg_enum_get_value(GST_TYPE_FORMAT, pfromformat, (gint *) &srcformat)) {
 
441
        PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat");
 
442
        return NULL;
 
443
    }
 
444
    if (pyg_enum_get_value(GST_TYPE_FORMAT, pdestformat, (gint *) &destformat)) {
 
445
        PyErr_SetString(PyExc_TypeError, "argument should be a GstFormat");
 
446
        return NULL;
 
447
    }
 
448
 
 
449
    if (!(gst_element_query_convert (GST_ELEMENT(self->obj),
 
450
                                     srcformat, fromval,
 
451
                                     &destformat, &dstval))) {
 
452
        Py_INCREF(Py_None);
 
453
        return Py_None;
 
454
    }
 
455
    
 
456
    ret = PyList_New(2);
 
457
    PyList_SetItem(ret, 0, pyg_enum_from_gtype (GST_TYPE_FORMAT, destformat));
 
458
    PyList_SetItem(ret, 1, PyLong_FromLongLong(dstval));
 
459
 
 
460
    return ret;
 
461
}
 
462
%%
 
463
override gst_element_get_query_types noargs
 
464
static PyObject *
 
465
_wrap_gst_element_get_query_types (PyGObject *self)
 
466
{
 
467
    PyObject    *ret;
 
468
    PyObject    *item;
 
469
    int         i;
 
470
    GstQueryType        *tab;
 
471
 
 
472
    tab = (GstQueryType*) gst_element_get_query_types(GST_ELEMENT(self->obj));
 
473
    if (tab == NULL) {
 
474
        Py_INCREF(Py_None);
 
475
        return Py_None;
 
476
    }
 
477
 
 
478
    ret = PyList_New(0);
 
479
    for (i = 0; tab[i] != 0; i++) {
 
480
        item = pyg_enum_from_gtype (GST_TYPE_QUERY_TYPE, tab[i]);
 
481
        PyList_Append(ret, item);
 
482
    }
 
483
    
 
484
    return ret;
 
485
}
 
486
%%
 
487
override-slot GstElement.tp_iter
 
488
static PyObject *
 
489
_wrap_gst_element_tp_iter(PyGObject *self)
 
490
{
 
491
    return _wrap_gst_element_iterate_pads(self);
 
492
}