← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gst/gstlibs.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/gstlibs.override
 
1
/* -*- Mode: C; ; c-basic-offset: 4 -*- */
 
2
/* gst-python
 
3
 * Copyright (C) 2005 Edward Hervey
 
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_controller_new
 
25
  gst_controller_*_valist
 
26
  gst_controller_remove_properties_list
 
27
 
 
28
%%
 
29
override gst_controller_set args
 
30
static PyObject *
 
31
_wrap_gst_controller_set (PyGObject *self, PyObject *args)
 
32
{
 
33
  GstController *controller = (GstController *) self->obj;
 
34
  gchar         *param_name;
 
35
  GParamSpec    *pspec = NULL;
 
36
  GstClockTime  timestamp;
 
37
  GValue        value = { 0, };
 
38
  PyObject      *pvalue;
 
39
  gboolean      res;
 
40
 
 
41
  if (!PyArg_ParseTuple(args, "sLO:GstController.set",
 
42
                        &param_name, &timestamp, &pvalue))
 
43
    return NULL;
 
44
 
 
45
  if (!(pspec = g_object_class_find_property(G_OBJECT_GET_CLASS (controller->object),
 
46
                                             (const gchar*) param_name))) {
 
47
      PyErr_SetString (PyExc_TypeError,
 
48
                       "The controlled object doesn't have the given property");
 
49
      return NULL;
 
50
  }
 
51
 
 
52
  g_value_init (&value, pspec->value_type);
 
53
 
 
54
  if (pyg_value_from_pyobject (&value, pvalue)) {
 
55
    PyErr_SetString (PyExc_TypeError,
 
56
                     "Couldn't convert the given value to the good type");
 
57
    return NULL;
 
58
  }
 
59
 
 
60
  res = gst_controller_set (controller, param_name, timestamp, &value);
 
61
  if (res) {
 
62
    Py_INCREF (Py_True);
 
63
    return Py_True;
 
64
  }
 
65
  Py_INCREF (Py_False);
 
66
  return Py_False;
 
67
}
 
68
%%
 
69
override gst_controller_get kwargs
 
70
static PyObject *
 
71
_wrap_gst_controller_get (PyGObject *self, PyObject *args, PyObject *kwargs)
 
72
{
 
73
    GstController       *controller = (GstController *) self->obj;
 
74
    static char         *kwlist[] = { "propertyname", "timestamp", NULL };
 
75
    gchar       *propertyname;
 
76
    GstClockTime        timestamp;
 
77
    GValue      *value = NULL;
 
78
    PyObject    *pyvalue;
 
79
 
 
80
    if (!PyArg_ParseTupleAndKeywords (args, kwargs,
 
81
                                      "sL:GstController.get",
 
82
                                      kwlist, &propertyname, &timestamp))
 
83
        return NULL;
 
84
 
 
85
    value = gst_controller_get (controller, propertyname, timestamp);
 
86
    if (value) {
 
87
        pyvalue = pyg_value_as_pyobject (value, FALSE);
 
88
        return pyvalue;
 
89
    }
 
90
    Py_INCREF (Py_None);
 
91
    return Py_None;
 
92
}
 
93
%%
 
94
override gst_controller_new_list args
 
95
static int
 
96
_wrap_gst_controller_new_list(PyGObject *self, PyObject *args)
 
97
{
 
98
    PyGObject   *target;
 
99
    gint        len;
 
100
    GList       *list = NULL;
 
101
 
 
102
    if ((len = PyTuple_Size(args)) < 1) {
 
103
        PyErr_SetString(PyExc_TypeError, "Controller requires at least a target object");
 
104
        return -1;
 
105
    }
 
106
    target = (PyGObject *) PyTuple_GetItem(args, 0);
 
107
    if (len > 1)
 
108
        while (len-- > 1) {
 
109
            PyObject    *temp;
 
110
            gchar       *str;
 
111
 
 
112
            temp = PyTuple_GetItem(args, len);
 
113
            str = PyString_AsString(temp);
 
114
            GST_INFO("prepending %s [%d]", str, len);
 
115
            list = g_list_prepend(list, PyString_AsString(temp));
 
116
        }
 
117
 
 
118
    self->obj = (GObject *) gst_controller_new_list(target->obj, list);
 
119
 
 
120
    if (!self->obj) {
 
121
        PyErr_SetString(PyExc_RuntimeError, "could not create GstController object");
 
122
        return -1;
 
123
    }
 
124
    
 
125
    pygobject_register_wrapper((PyObject *) self);
 
126
    return 0;
 
127
}
 
128
%%
 
129
override gst_controller_remove_properties args
 
130
static PyObject *
 
131
_wrap_gst_controller_remove_properties (PyGObject *self, PyObject *args)
 
132
{
 
133
    GstController *controller = (GstController *) self->obj;
 
134
    gint        len;
 
135
    GList       *list = NULL;
 
136
    gboolean    res = FALSE;
 
137
    PyObject    *pret;
 
138
 
 
139
    if ((len = PyTuple_Size(args)) < 1) {
 
140
        PyErr_SetString(PyExc_TypeError, "Please give at least one property name to remove");
 
141
        return NULL;
 
142
    }
 
143
 
 
144
    while (len--) {
 
145
        PyObject        *temp;
 
146
        gchar   *str;
 
147
        
 
148
        temp = PyTuple_GetItem(args, len);
 
149
        str = PyString_AsString(temp);
 
150
        GST_INFO("prepending %s [%d]", str, len);
 
151
        list = g_list_prepend(list, PyString_AsString(temp));
 
152
    }
 
153
    
 
154
    res = gst_controller_remove_properties_list(controller, list);
 
155
 
 
156
    if (res)
 
157
        pret = Py_True;
 
158
    else
 
159
        pret = Py_False;
 
160
 
 
161
    Py_INCREF (pret);
 
162
 
 
163
    return pret;
 
164
}
 
165
%%
 
166
override gst_controller_set_from_list args
 
167
static PyObject *
 
168
_wrap_gst_controller_set_from_list (PyGObject *self, PyObject *args)
 
169
{
 
170
    GstController *controller = (GstController *) self->obj;
 
171
    PyObject    *temp;
 
172
    gint        len;
 
173
    gchar       *pname;
 
174
    GSList      *list = NULL;
 
175
    GParamSpec  *pspec = NULL;
 
176
    gboolean    res = FALSE;
 
177
    PyObject    *pret;
 
178
 
 
179
    if ((len = PyTuple_Size(args)) < 2) {
 
180
        PyErr_SetString(PyExc_TypeError, "Please give a property name and a tuple of (time,value)");
 
181
        return NULL;
 
182
    }
 
183
 
 
184
    temp = PyTuple_GetItem(args, 0);
 
185
    if (!PyString_Check (temp)) {
 
186
        PyErr_SetString(PyExc_TypeError, "First argument must be a string");
 
187
        return NULL;
 
188
    }
 
189
    pname = PyString_AsString(temp);
 
190
 
 
191
    if (!(pspec = g_object_class_find_property(G_OBJECT_GET_CLASS (controller->object),
 
192
                                               (const gchar*) pname)))
 
193
        goto error;
 
194
 
 
195
    while (len-- > 1) {
 
196
        PyObject        *temp2;
 
197
        GstTimedValue   *tval;
 
198
        
 
199
        temp2 = PyTuple_GetItem(args, len);
 
200
        if (!PyTuple_Check (temp2)) {
 
201
            PyErr_SetString (PyExc_TypeError, "Tuple doesn't contain tuples !");
 
202
            goto error;
 
203
        }
 
204
        tval = g_new0(GstTimedValue, 1);
 
205
        tval->timestamp = PyLong_AsUnsignedLongLong(PyTuple_GetItem(temp2, 0));
 
206
        g_value_init (&tval->value, pspec->value_type);
 
207
        if ((pyg_value_from_pyobject (&tval->value, PyTuple_GetItem (temp2, 1))) < 0) {
 
208
            PyErr_SetString (PyExc_TypeError, "Couldn't convert value to correct type");
 
209
            goto error;
 
210
        };
 
211
 
 
212
        list = g_slist_prepend(list, tval);
 
213
    }
 
214
    
 
215
    res = gst_controller_set_from_list(controller, pname, list);
 
216
 
 
217
    if (res)
 
218
        pret = Py_True;
 
219
    else
 
220
        pret = Py_False;
 
221
 
 
222
    Py_INCREF (pret);
 
223
 
 
224
    return pret;
 
225
 
 
226
 error:
 
227
    while (list) {
 
228
        g_free(list->data);
 
229
        list = g_slist_next(list);
 
230
    }
 
231
    g_slist_free (list);
 
232
    return NULL;
 
233
}
 
234
%%
 
235
override gst_dp_header_payload_length kwargs
 
236
static PyObject *
 
237
_wrap_gst_dp_header_payload_length(PyObject *self, PyObject *args, PyObject *kwargs)
 
238
{
 
239
    static char *kwlist[] = { "header", NULL };
 
240
    char *header;
 
241
    gulong ret;
 
242
 
 
243
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:dp_header_payload_length", kwlist, &header))
 
244
        return NULL;
 
245
    ret = gst_dp_header_payload_length((guint8*)header);
 
246
    return PyLong_FromUnsignedLong(ret);
 
247
}
 
248
%%
 
249
overrid gst_dp_header_payload_type kwargs
 
250
static PyObject *
 
251
_wrap_gst_dp_header_payload_type(PyObject *self, PyObject *args, PyObject *kwargs)
 
252
{
 
253
    static char *kwlist[] = { "header", NULL };
 
254
    char *header;
 
255
    gint ret;
 
256
 
 
257
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:dp_header_payload_type", kwlist, &header))
 
258
        return NULL;
 
259
    ret = gst_dp_header_payload_type((guint8*)header);
 
260
    return pyg_enum_from_gtype(G_TYPE_NONE, ret);
 
261
}
 
262
%%
 
263
override gst_dp_buffer_from_header kwargs
 
264
static PyObject *
 
265
_wrap_gst_dp_buffer_from_header(PyObject *self, PyObject *args, PyObject *kwargs)
 
266
{
 
267
    static char *kwlist[] = { "header_length", "header", NULL };
 
268
    char *header;
 
269
    GstBuffer *ret;
 
270
    guint header_length;
 
271
 
 
272
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Is:dp_buffer_from_header", kwlist, &header_length, &header))
 
273
        return NULL;
 
274
    ret = gst_dp_buffer_from_header(header_length, (guint8*)header);
 
275
    /* pygobject_new handles NULL checking */
 
276
    return pygstminiobject_new((GstMiniObject *)ret);
 
277
}
 
278
%%
 
279
override gst_dp_caps_from_packet kwargs
 
280
static PyObject *
 
281
_wrap_gst_dp_caps_from_packet(PyObject *self, PyObject *args, PyObject *kwargs)
 
282
{
 
283
    static char *kwlist[] = { "header_length", "header", "payload", NULL };
 
284
    char *header, *payload;
 
285
    GstCaps *ret;
 
286
    guint header_length;
 
287
 
 
288
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Iss:dp_caps_from_packet", kwlist, &header_length, &header, &payload))
 
289
        return NULL;
 
290
    ret = gst_dp_caps_from_packet(header_length, 
 
291
                                  (guint8*) header,
 
292
                                  (guint8*) payload);
 
293
    return pyg_boxed_new (GST_TYPE_CAPS, ret, FALSE, TRUE);
 
294
}
 
295
%%
 
296
override gst_dp_event_from_packet kwargs
 
297
static PyObject *
 
298
_wrap_gst_dp_event_from_packet(PyObject *self, PyObject *args, PyObject *kwargs)
 
299
{
 
300
    static char *kwlist[] = { "header_length", "header", "payload", NULL };
 
301
    char *header, *payload;
 
302
    GstEvent *ret;
 
303
    guint header_length;
 
304
 
 
305
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Iss:dp_event_from_packet", kwlist, &header_length, &header, &payload))
 
306
        return NULL;
 
307
    ret = gst_dp_event_from_packet(header_length, 
 
308
                                   (guint8*) header,
 
309
                                   (guint8*) payload);
 
310
    /* pygobject_new handles NULL checking */
 
311
    return pygstminiobject_new((GstMiniObject *)ret);
 
312
}
 
313
%%
 
314
override gst_dp_validate_header kwargs
 
315
static PyObject *
 
316
_wrap_gst_dp_validate_header(PyObject *self, PyObject *args, PyObject *kwargs)
 
317
{
 
318
    static char *kwlist[] = { "header_length", "header", NULL };
 
319
    char *header;
 
320
    int ret;
 
321
    guint header_length;
 
322
 
 
323
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Is:dp_validate_header", kwlist, &header_length, &header))
 
324
        return NULL;
 
325
    ret = gst_dp_validate_header(header_length, (guint8*) header);
 
326
    return PyBool_FromLong(ret);
 
327
 
 
328
}
 
329
%%
 
330
override gst_dp_validate_payload kwargs
 
331
static PyObject *
 
332
_wrap_gst_dp_validate_payload(PyObject *self, PyObject *args, PyObject *kwargs)
 
333
{
 
334
    static char *kwlist[] = { "header_length", "header", "payload", NULL };
 
335
    char *header, *payload;
 
336
    int ret;
 
337
    guint header_length;
 
338
 
 
339
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Iss:dp_validate_payload", kwlist, &header_length, &header, &payload))
 
340
        return NULL;
 
341
    ret = gst_dp_validate_payload(header_length,
 
342
                                  (guint8*) header,
 
343
                                  (guint8*) payload);
 
344
    return PyBool_FromLong(ret);
 
345
 
 
346
}
 
347
%%
 
348
override gst_dp_validate_packet kwargs
 
349
static PyObject *
 
350
_wrap_gst_dp_validate_packet(PyObject *self, PyObject *args, PyObject *kwargs)
 
351
{
 
352
    static char *kwlist[] = { "header_length", "header", "payload", NULL };
 
353
    char *header, *payload;
 
354
    int ret;
 
355
    guint header_length;
 
356
 
 
357
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Iss:dp_validate_packet", kwlist, &header_length, &header, &payload))
 
358
        return NULL;
 
359
    ret = gst_dp_validate_packet(header_length, 
 
360
                                 (guint8*) header,
 
361
                                 (guint8*) payload);
 
362
    return PyBool_FromLong(ret);
 
363
 
 
364
}
 
365
%%
 
366
override gst_dp_header_payload_type kwargs
 
367
static PyObject *
 
368
_wrap_gst_dp_header_payload_type(PyObject *self, PyObject *args, PyObject *kwargs)
 
369
{
 
370
    static char *kwlist[] = { "header", NULL };
 
371
    char *header;
 
372
    gint ret;
 
373
 
 
374
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:dp_header_payload_type", kwlist, &header))
 
375
        return NULL;
 
376
    ret = gst_dp_header_payload_type((guint8*) header);
 
377
    return pyg_enum_from_gtype(G_TYPE_NONE, ret);
 
378
}
 
379