« back to all changes in this revision
Viewing changes to src/objects/midimodule.c
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: Package Import Robot
- Author(s): Tiago Bortoletto Vaz
- Date: 2012-07-03 23:45:41 UTC
- mfrom: (1.1.1)
- Revision ID: package-import@ubuntu.com-20120703234541-jh5jg00lvljnwq8m
Tags: 0.6.2-1
New upstream release.
- files added:
- .pc
- files modified:
- ChangeLog
added
removed
src/objects/midimodule.c
86
86
static void
87
87
CtlScan_dealloc(CtlScan* self)
88
88
{
89
free(self->data);
89
pyo_DEALLOC
90
90
CtlScan_clear(self);
91
91
self->ob_type->tp_free((PyObject*)self);
92
92
}
93
93
94
static PyObject * CtlScan_deleteStream(CtlScan *self) { DELETE_STREAM };
95
96
94
static PyObject *
97
95
CtlScan_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
98
96
{
99
97
int i;
100
98
PyObject *calltmp=NULL;
101
99
CtlScan *self;
102
100
self = (CtlScan *)type->tp_alloc(type, 0);
103
101
107
105
INIT_OBJECT_COMMON
108
106
Stream_setFunctionPtr(self->stream, CtlScan_compute_next_data_frame);
109
107
self->mode_func_ptr = CtlScan_setProcMode;
110
111
return (PyObject *)self;
112
}
113
114
static int
115
CtlScan_init(CtlScan *self, PyObject *args, PyObject *kwds)
116
{
117
PyObject *calltmp=NULL;
118
108
119
109
static char *kwlist[] = {"callable", "toprint", NULL};
120
110
121
111
if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|i", kwlist, &calltmp, &self->toprint))
122
return -1;
112
Py_RETURN_NONE;
123
113
124
114
if (calltmp) {
125
115
PyObject_CallMethod((PyObject *)self, "setFunction", "O", calltmp);
126
116
}
127
117
128
Py_INCREF(self->stream);
129
118
PyObject_CallMethod(self->server, "addStream", "O", self->stream);
130
131
Py_INCREF(self);
132
return 0;
119
120
return (PyObject *)self;
133
121
}
134
122
135
123
static PyObject * CtlScan_getServer(CtlScan* self) { GET_SERVER };
178
166
static PyMethodDef CtlScan_methods[] = {
179
167
{"getServer", (PyCFunction)CtlScan_getServer, METH_NOARGS, "Returns server object."},
180
168
{"_getStream", (PyCFunction)CtlScan_getStream, METH_NOARGS, "Returns stream object."},
181
{"deleteStream", (PyCFunction)CtlScan_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
182
169
{"play", (PyCFunction)CtlScan_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
183
170
{"stop", (PyCFunction)CtlScan_stop, METH_NOARGS, "Stops computing."},
184
171
{"setFunction", (PyCFunction)CtlScan_setFunction, METH_O, "Sets the function to be called."},
223
210
0, /* tp_descr_get */
224
211
0, /* tp_descr_set */
225
212
0, /* tp_dictoffset */
226
(initproc)CtlScan_init, /* tp_init */
213
0, /* tp_init */
227
214
0, /* tp_alloc */
228
215
CtlScan_new, /* tp_new */
229
216
};
230
217
218
typedef struct {
219
pyo_audio_HEAD
220
PyObject *callable;
221
int ctlnumber;
222
int midichnl;
223
int toprint;
224
} CtlScan2;
225
226
static void
227
CtlScan2_setProcMode(CtlScan2 *self) {}
228
229
static void
230
CtlScan2_compute_next_data_frame(CtlScan2 *self)
231
{
232
PmEvent *buffer;
233
int i, count, midichnl;
234
235
buffer = Server_getMidiEventBuffer((Server *)self->server);
236
count = Server_getMidiEventCount((Server *)self->server);
237
238
if (count > 0) {
239
PyObject *tup;
240
for (i=count-1; i>=0; i--) {
241
int status = Pm_MessageStatus(buffer[i].message); // Temp note event holders
242
int number = Pm_MessageData1(buffer[i].message);
243
int value = Pm_MessageData2(buffer[i].message);
244
245
if ((status & 0xF0) == 0xB0) {
246
midichnl = status - 0xB0 + 1;
247
if (number != self->ctlnumber || midichnl != self->midichnl) {
248
self->ctlnumber = number;
249
self->midichnl = midichnl;
250
tup = PyTuple_New(2);
251
PyTuple_SetItem(tup, 0, PyInt_FromLong(self->ctlnumber));
252
PyTuple_SetItem(tup, 1, PyInt_FromLong(self->midichnl));
253
PyObject_Call((PyObject *)self->callable, tup, NULL);
254
}
255
if (self->toprint == 1)
256
printf("ctl number : %i, ctl value : %i, midi channel : %i\n", self->ctlnumber, value, midichnl);
257
}
258
}
259
}
260
}
261
262
static int
263
CtlScan2_traverse(CtlScan2 *self, visitproc visit, void *arg)
264
{
265
pyo_VISIT
266
Py_VISIT(self->callable);
267
return 0;
268
}
269
270
static int
271
CtlScan2_clear(CtlScan2 *self)
272
{
273
pyo_CLEAR
274
Py_CLEAR(self->callable);
275
return 0;
276
}
277
278
static void
279
CtlScan2_dealloc(CtlScan2* self)
280
{
281
pyo_DEALLOC
282
CtlScan2_clear(self);
283
self->ob_type->tp_free((PyObject*)self);
284
}
285
286
static PyObject *
287
CtlScan2_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
288
{
289
int i;
290
PyObject *calltmp=NULL;
291
CtlScan2 *self;
292
self = (CtlScan2 *)type->tp_alloc(type, 0);
293
294
self->ctlnumber = self->midichnl = -1;
295
self->toprint = 1;
296
297
INIT_OBJECT_COMMON
298
Stream_setFunctionPtr(self->stream, CtlScan2_compute_next_data_frame);
299
self->mode_func_ptr = CtlScan2_setProcMode;
300
301
static char *kwlist[] = {"callable", "toprint", NULL};
302
303
if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|i", kwlist, &calltmp, &self->toprint))
304
Py_RETURN_NONE;
305
306
if (calltmp) {
307
PyObject_CallMethod((PyObject *)self, "setFunction", "O", calltmp);
308
}
309
310
PyObject_CallMethod(self->server, "addStream", "O", self->stream);
311
312
return (PyObject *)self;
313
}
314
315
static PyObject * CtlScan2_getServer(CtlScan2* self) { GET_SERVER };
316
static PyObject * CtlScan2_getStream(CtlScan2* self) { GET_STREAM };
317
318
static PyObject * CtlScan2_play(CtlScan2 *self, PyObject *args, PyObject *kwds) { PLAY };
319
static PyObject * CtlScan2_stop(CtlScan2 *self) { STOP };
320
321
static PyObject *
322
CtlScan2_setFunction(CtlScan2 *self, PyObject *arg)
323
{
324
PyObject *tmp;
325
326
if (! PyCallable_Check(arg)) {
327
PyErr_SetString(PyExc_TypeError, "The callable attribute must be a valid Python function.");
328
Py_INCREF(Py_None);
329
return Py_None;
330
}
331
332
tmp = arg;
333
Py_XDECREF(self->callable);
334
Py_INCREF(tmp);
335
self->callable = tmp;
336
337
Py_INCREF(Py_None);
338
return Py_None;
339
}
340
341
static PyObject *
342
CtlScan2_setToprint(CtlScan2 *self, PyObject *arg)
343
{
344
345
if (PyInt_Check(arg)) {
346
self->toprint = PyInt_AsLong(arg);
347
}
348
349
Py_INCREF(Py_None);
350
return Py_None;
351
}
352
static PyMemberDef CtlScan2_members[] = {
353
{"server", T_OBJECT_EX, offsetof(CtlScan2, server), 0, "Pyo server."},
354
{"stream", T_OBJECT_EX, offsetof(CtlScan2, stream), 0, "Stream object."},
355
{NULL} /* Sentinel */
356
};
357
358
static PyMethodDef CtlScan2_methods[] = {
359
{"getServer", (PyCFunction)CtlScan2_getServer, METH_NOARGS, "Returns server object."},
360
{"_getStream", (PyCFunction)CtlScan2_getStream, METH_NOARGS, "Returns stream object."},
361
{"play", (PyCFunction)CtlScan2_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
362
{"stop", (PyCFunction)CtlScan2_stop, METH_NOARGS, "Stops computing."},
363
{"setFunction", (PyCFunction)CtlScan2_setFunction, METH_O, "Sets the function to be called."},
364
{"setToprint", (PyCFunction)CtlScan2_setToprint, METH_O, "If True, print values to the console."},
365
{NULL} /* Sentinel */
366
};
367
368
PyTypeObject CtlScan2Type = {
369
PyObject_HEAD_INIT(NULL)
370
0, /*ob_size*/
371
"_pyo.CtlScan2_base", /*tp_name*/
372
sizeof(CtlScan2), /*tp_basicsize*/
373
0, /*tp_itemsize*/
374
(destructor)CtlScan2_dealloc, /*tp_dealloc*/
375
0, /*tp_print*/
376
0, /*tp_getattr*/
377
0, /*tp_setattr*/
378
0, /*tp_compare*/
379
0, /*tp_repr*/
380
0, /*tp_as_number*/
381
0, /*tp_as_sequence*/
382
0, /*tp_as_mapping*/
383
0, /*tp_hash */
384
0, /*tp_call*/
385
0, /*tp_str*/
386
0, /*tp_getattro*/
387
0, /*tp_setattro*/
388
0, /*tp_as_buffer*/
389
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_CHECKTYPES, /*tp_flags*/
390
"CtlScan2 objects. Retreive midi channel and controller numbers from a midi input.", /* tp_doc */
391
(traverseproc)CtlScan2_traverse, /* tp_traverse */
392
(inquiry)CtlScan2_clear, /* tp_clear */
393
0, /* tp_richcompare */
394
0, /* tp_weaklistoffset */
395
0, /* tp_iter */
396
0, /* tp_iternext */
397
CtlScan2_methods, /* tp_methods */
398
CtlScan2_members, /* tp_members */
399
0, /* tp_getset */
400
0, /* tp_base */
401
0, /* tp_dict */
402
0, /* tp_descr_get */
403
0, /* tp_descr_set */
404
0, /* tp_dictoffset */
405
0, /* tp_init */
406
0, /* tp_alloc */
407
CtlScan2_new, /* tp_new */
408
};
409
231
410
232
411
typedef struct {
233
412
pyo_audio_HEAD
363
542
static void
364
543
Midictl_dealloc(Midictl* self)
365
544
{
366
free(self->data);
545
pyo_DEALLOC
367
546
Midictl_clear(self);
368
547
self->ob_type->tp_free((PyObject*)self);
369
548
}
370
549
371
static PyObject * Midictl_deleteStream(Midictl *self) { DELETE_STREAM };
372
373
550
static PyObject *
374
551
Midictl_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
375
552
{
376
int i;
377
553
int i;
554
PyObject *multmp=NULL, *addtmp=NULL;
378
555
Midictl *self;
379
556
self = (Midictl *)type->tp_alloc(type, 0);
380
557
390
567
INIT_OBJECT_COMMON
391
568
Stream_setFunctionPtr(self->stream, Midictl_compute_next_data_frame);
392
569
self->mode_func_ptr = Midictl_setProcMode;
393
394
return (PyObject *)self;
395
}
396
397
static int
398
Midictl_init(Midictl *self, PyObject *args, PyObject *kwds)
399
{
400
PyObject *multmp=NULL, *addtmp=NULL;
401
570
402
571
static char *kwlist[] = {"ctlnumber", "minscale", "maxscale", "init", "channel", "mul", "add", NULL};
403
572
404
573
if (! PyArg_ParseTupleAndKeywords(args, kwds, TYPE_I_FFFIOO, kwlist, &self->ctlnumber, &self->minscale, &self->maxscale, &self->oldValue, &self->channel, &multmp, &addtmp))
405
return -1;
574
Py_RETURN_NONE;
406
575
407
576
if (multmp) {
408
577
PyObject_CallMethod((PyObject *)self, "setMul", "O", multmp);
412
581
PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
413
582
}
414
583
415
Py_INCREF(self->stream);
416
584
PyObject_CallMethod(self->server, "addStream", "O", self->stream);
417
585
418
586
self->value = self->oldValue;
419
587
420
588
(*self->mode_func_ptr)(self);
421
422
Py_INCREF(self);
423
return 0;
589
590
return (PyObject *)self;
424
591
}
425
592
426
593
static PyObject * Midictl_getServer(Midictl* self) { GET_SERVER };
453
620
}
454
621
455
622
int isNum = PyInt_Check(arg);
456
printf("isNum : %i\n", isNum);
457
623
458
624
if (isNum == 1) {
459
625
tmp = PyInt_AsLong(arg);
462
628
else
463
629
self->interp = 1;
464
630
}
465
printf("self->interp : %i\n", self->interp);
466
631
467
632
Py_INCREF(Py_None);
468
633
return Py_None;
586
751
static PyMethodDef Midictl_methods[] = {
587
752
{"getServer", (PyCFunction)Midictl_getServer, METH_NOARGS, "Returns server object."},
588
753
{"_getStream", (PyCFunction)Midictl_getStream, METH_NOARGS, "Returns stream object."},
589
{"deleteStream", (PyCFunction)Midictl_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
590
754
{"play", (PyCFunction)Midictl_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
591
755
{"stop", (PyCFunction)Midictl_stop, METH_NOARGS, "Stops computing."},
592
756
{"setInterpolation", (PyCFunction)Midictl_setInterpolation, METH_O, "Activate/Deactivate interpolation."},
681
845
0, /* tp_descr_get */
682
846
0, /* tp_descr_set */
683
847
0, /* tp_dictoffset */
684
(initproc)Midictl_init, /* tp_init */
848
0, /* tp_init */
685
849
0, /* tp_alloc */
686
850
Midictl_new, /* tp_new */
687
851
};
816
980
static void
817
981
Bendin_dealloc(Bendin* self)
818
982
{
819
free(self->data);
983
pyo_DEALLOC
820
984
Bendin_clear(self);
821
985
self->ob_type->tp_free((PyObject*)self);
822
986
}
823
987
824
static PyObject * Bendin_deleteStream(Bendin *self) { DELETE_STREAM };
825
826
988
static PyObject *
827
989
Bendin_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
828
990
{
829
991
int i;
830
992
PyObject *multmp=NULL, *addtmp=NULL;
831
993
Bendin *self;
832
994
self = (Bendin *)type->tp_alloc(type, 0);
833
995
842
1004
INIT_OBJECT_COMMON
843
1005
Stream_setFunctionPtr(self->stream, Bendin_compute_next_data_frame);
844
1006
self->mode_func_ptr = Bendin_setProcMode;
845
846
return (PyObject *)self;
847
}
848
1007
849
static int
850
Bendin_init(Bendin *self, PyObject *args, PyObject *kwds)
851
{
852
PyObject *multmp=NULL, *addtmp=NULL;
853
854
1008
static char *kwlist[] = {"brange", "scale", "channel", "mul", "add", NULL};
855
1009
856
1010
if (! PyArg_ParseTupleAndKeywords(args, kwds, TYPE__FIIOO, kwlist, &self->range, &self->scale, &self->channel, &multmp, &addtmp))
857
return -1;
1011
Py_RETURN_NONE;
858
1012
859
1013
if (multmp) {
860
1014
PyObject_CallMethod((PyObject *)self, "setMul", "O", multmp);
864
1018
PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
865
1019
}
866
1020
867
Py_INCREF(self->stream);
868
1021
PyObject_CallMethod(self->server, "addStream", "O", self->stream);
869
1022
870
1023
if (self->scale == 0)
874
1027
875
1028
(*self->mode_func_ptr)(self);
876
1029
877
Py_INCREF(self);
878
return 0;
1030
return (PyObject *)self;
879
1031
}
880
1032
881
1033
static PyObject * Bendin_getServer(Bendin* self) { GET_SERVER };
977
1129
static PyMethodDef Bendin_methods[] = {
978
1130
{"getServer", (PyCFunction)Bendin_getServer, METH_NOARGS, "Returns server object."},
979
1131
{"_getStream", (PyCFunction)Bendin_getStream, METH_NOARGS, "Returns stream object."},
980
{"deleteStream", (PyCFunction)Bendin_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
981
1132
{"play", (PyCFunction)Bendin_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
982
1133
{"stop", (PyCFunction)Bendin_stop, METH_NOARGS, "Stops computing."},
983
1134
{"setBrange", (PyCFunction)Bendin_setBrange, METH_O, "Sets the bending bipolar range."},
1069
1220
0, /* tp_descr_get */
1070
1221
0, /* tp_descr_set */
1071
1222
0, /* tp_dictoffset */
1072
(initproc)Bendin_init, /* tp_init */
1223
0, /* tp_init */
1073
1224
0, /* tp_alloc */
1074
1225
Bendin_new, /* tp_new */
1075
1226
};
1199
1350
static void
1200
1351
Touchin_dealloc(Touchin* self)
1201
1352
{
1202
free(self->data);
1353
pyo_DEALLOC
1203
1354
Touchin_clear(self);
1204
1355
self->ob_type->tp_free((PyObject*)self);
1205
1356
}
1206
1357
1207
static PyObject * Touchin_deleteStream(Touchin *self) { DELETE_STREAM };
1208
1209
1358
static PyObject *
1210
1359
Touchin_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1211
1360
{
1212
1361
int i;
1213
1362
PyObject *multmp=NULL, *addtmp=NULL;
1214
1363
Touchin *self;
1215
1364
self = (Touchin *)type->tp_alloc(type, 0);
1216
1365
1225
1374
INIT_OBJECT_COMMON
1226
1375
Stream_setFunctionPtr(self->stream, Touchin_compute_next_data_frame);
1227
1376
self->mode_func_ptr = Touchin_setProcMode;
1228
1229
return (PyObject *)self;
1230
}
1231
1377
1232
static int
1233
Touchin_init(Touchin *self, PyObject *args, PyObject *kwds)
1234
{
1235
PyObject *multmp=NULL, *addtmp=NULL;
1236
1237
1378
static char *kwlist[] = {"minscale", "maxscale", "init", "channel", "mul", "add", NULL};
1238
1379
1239
1380
if (! PyArg_ParseTupleAndKeywords(args, kwds, TYPE__FFFIOO, kwlist, &self->minscale, &self->maxscale, &self->oldValue, &self->channel, &multmp, &addtmp))
1240
return -1;
1381
Py_RETURN_NONE;
1241
1382
1242
1383
if (multmp) {
1243
1384
PyObject_CallMethod((PyObject *)self, "setMul", "O", multmp);
1247
1388
PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
1248
1389
}
1249
1390
1250
Py_INCREF(self->stream);
1251
1391
PyObject_CallMethod(self->server, "addStream", "O", self->stream);
1252
1392
1253
1393
self->value = self->oldValue;
1254
1394
1255
1395
(*self->mode_func_ptr)(self);
1256
1396
1257
Py_INCREF(self);
1258
return 0;
1397
return (PyObject *)self;
1259
1398
}
1260
1399
1261
1400
static PyObject * Touchin_getServer(Touchin* self) { GET_SERVER };
1352
1491
static PyMethodDef Touchin_methods[] = {
1353
1492
{"getServer", (PyCFunction)Touchin_getServer, METH_NOARGS, "Returns server object."},
1354
1493
{"_getStream", (PyCFunction)Touchin_getStream, METH_NOARGS, "Returns stream object."},
1355
{"deleteStream", (PyCFunction)Touchin_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
1356
1494
{"play", (PyCFunction)Touchin_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
1357
1495
{"stop", (PyCFunction)Touchin_stop, METH_NOARGS, "Stops computing."},
1358
1496
{"setMinScale", (PyCFunction)Touchin_setMinScale, METH_O, "Sets the minimum value of scaling."},
1444
1582
0, /* tp_descr_get */
1445
1583
0, /* tp_descr_set */
1446
1584
0, /* tp_dictoffset */
1447
(initproc)Touchin_init, /* tp_init */
1585
0, /* tp_init */
1448
1586
0, /* tp_alloc */
1449
1587
Touchin_new, /* tp_new */
1450
1588
};
1568
1706
static void
1569
1707
Programin_dealloc(Programin* self)
1570
1708
{
1571
free(self->data);
1709
pyo_DEALLOC
1572
1710
Programin_clear(self);
1573
1711
self->ob_type->tp_free((PyObject*)self);
1574
1712
}
1575
1713
1576
static PyObject * Programin_deleteStream(Programin *self) { DELETE_STREAM };
1577
1578
1714
static PyObject *
1579
1715
Programin_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1580
1716
{
1581
1717
int i;
1582
1718
PyObject *multmp=NULL, *addtmp=NULL;
1583
1719
Programin *self;
1584
1720
self = (Programin *)type->tp_alloc(type, 0);
1585
1721
1591
1727
INIT_OBJECT_COMMON
1592
1728
Stream_setFunctionPtr(self->stream, Programin_compute_next_data_frame);
1593
1729
self->mode_func_ptr = Programin_setProcMode;
1594
1595
return (PyObject *)self;
1596
}
1597
1730
1598
static int
1599
Programin_init(Programin *self, PyObject *args, PyObject *kwds)
1600
{
1601
PyObject *multmp=NULL, *addtmp=NULL;
1602
1603
1731
static char *kwlist[] = {"channel", "mul", "add", NULL};
1604
1732
1605
1733
if (! PyArg_ParseTupleAndKeywords(args, kwds, "iOO", kwlist, &self->channel, &multmp, &addtmp))
1606
return -1;
1734
Py_RETURN_NONE;
1607
1735
1608
1736
if (multmp) {
1609
1737
PyObject_CallMethod((PyObject *)self, "setMul", "O", multmp);
1613
1741
PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
1614
1742
}
1615
1743
1616
Py_INCREF(self->stream);
1617
1744
PyObject_CallMethod(self->server, "addStream", "O", self->stream);
1618
1745
1619
1746
(*self->mode_func_ptr)(self);
1620
1747
1621
Py_INCREF(self);
1622
return 0;
1748
return (PyObject *)self;
1623
1749
}
1624
1750
1625
1751
static PyObject * Programin_getServer(Programin* self) { GET_SERVER };
1674
1800
static PyMethodDef Programin_methods[] = {
1675
1801
{"getServer", (PyCFunction)Programin_getServer, METH_NOARGS, "Returns server object."},
1676
1802
{"_getStream", (PyCFunction)Programin_getStream, METH_NOARGS, "Returns stream object."},
1677
{"deleteStream", (PyCFunction)Programin_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
1678
1803
{"play", (PyCFunction)Programin_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
1679
1804
{"stop", (PyCFunction)Programin_stop, METH_NOARGS, "Stops computing."},
1680
1805
{"setChannel", (PyCFunction)Programin_setChannel, METH_O, "Sets the midi channel."},
1764
1889
0, /* tp_descr_get */
1765
1890
0, /* tp_descr_set */
1766
1891
0, /* tp_dictoffset */
1767
(initproc)Programin_init, /* tp_init */
1892
0, /* tp_init */
1768
1893
0, /* tp_alloc */
1769
1894
Programin_new, /* tp_new */
1770
1895
};
1913
2038
static void
1914
2039
MidiNote_dealloc(MidiNote* self)
1915
2040
{
1916
free(self->data);
2041
pyo_DEALLOC
1917
2042
free(self->notebuf);
1918
2043
MidiNote_clear(self);
1919
2044
self->ob_type->tp_free((PyObject*)self);
1920
2045
}
1921
2046
1922
static PyObject * MidiNote_deleteStream(MidiNote *self) { DELETE_STREAM };
1923
1924
2047
static PyObject *
1925
2048
MidiNote_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1926
2049
{
1939
2062
INIT_OBJECT_COMMON
1940
2063
Stream_setFunctionPtr(self->stream, MidiNote_compute_next_data_frame);
1941
2064
self->mode_func_ptr = MidiNote_setProcMode;
1942
1943
return (PyObject *)self;
1944
}
1945
2065
1946
static int
1947
MidiNote_init(MidiNote *self, PyObject *args, PyObject *kwds)
1948
{
1949
int i;
1950
1951
2066
static char *kwlist[] = {"voices", "scale", "first", "last", "channel", NULL};
1952
2067
1953
2068
if (! PyArg_ParseTupleAndKeywords(args, kwds, "|iiiii", kwlist, &self->voices, &self->scale, &self->first, &self->last, &self->channel))
1954
return -1;
2069
Py_RETURN_NONE;
1955
2070
1956
Py_INCREF(self->stream);
1957
2071
PyObject_CallMethod(self->server, "addStream", "O", self->stream);
1958
2072
1959
2073
self->notebuf = (int *)realloc(self->notebuf, self->voices * 2 * sizeof(int));
1966
2080
self->centralkey = (self->first + self->last) / 2;
1967
2081
1968
2082
(*self->mode_func_ptr)(self);
1969
1970
Py_INCREF(self);
1971
return 0;
2083
2084
return (PyObject *)self;
1972
2085
}
1973
2086
1974
2087
MYFLT MidiNote_getValue(MidiNote *self, int voice, int which)
2049
2162
static PyMethodDef MidiNote_methods[] = {
2050
2163
{"getServer", (PyCFunction)MidiNote_getServer, METH_NOARGS, "Returns server object."},
2051
2164
{"_getStream", (PyCFunction)MidiNote_getStream, METH_NOARGS, "Returns stream object."},
2052
{"deleteStream", (PyCFunction)MidiNote_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
2053
2165
{"play", (PyCFunction)MidiNote_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
2054
2166
{"stop", (PyCFunction)MidiNote_stop, METH_NOARGS, "Stops computing."},
2055
2167
{"setChannel", (PyCFunction)MidiNote_setChannel, METH_O, "Sets the midi channel."},
2094
2206
0, /* tp_descr_get */
2095
2207
0, /* tp_descr_set */
2096
2208
0, /* tp_dictoffset */
2097
(initproc)MidiNote_init, /* tp_init */
2209
0, /* tp_init */
2098
2210
0, /* tp_alloc */
2099
2211
MidiNote_new, /* tp_new */
2100
2212
};
2194
2306
static void
2195
2307
Notein_dealloc(Notein* self)
2196
2308
{
2197
free(self->data);
2309
pyo_DEALLOC
2198
2310
Notein_clear(self);
2199
2311
self->ob_type->tp_free((PyObject*)self);
2200
2312
}
2201
2313
2202
static PyObject * Notein_deleteStream(Notein *self) { DELETE_STREAM };
2203
2204
2314
static PyObject *
2205
2315
Notein_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2206
2316
{
2207
2317
int i;
2318
PyObject *handlertmp=NULL, *multmp=NULL, *addtmp=NULL;
2208
2319
Notein *self;
2209
2320
self = (Notein *)type->tp_alloc(type, 0);
2210
2321
2216
2327
INIT_OBJECT_COMMON
2217
2328
Stream_setFunctionPtr(self->stream, Notein_compute_next_data_frame);
2218
2329
self->mode_func_ptr = Notein_setProcMode;
2219
2220
return (PyObject *)self;
2221
}
2222
2330
2223
static int
2224
Notein_init(Notein *self, PyObject *args, PyObject *kwds)
2225
{
2226
PyObject *handlertmp=NULL, *multmp=NULL, *addtmp=NULL;
2227
2228
2331
static char *kwlist[] = {"handler", "voice", "mode", "mul", "add", NULL};
2229
2332
2230
2333
if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|iiOO", kwlist, &handlertmp, &self->voice, &self->mode, &multmp, &addtmp))
2231
return -1;
2334
Py_RETURN_NONE;
2232
2335
2233
2336
Py_XDECREF(self->handler);
2234
2337
Py_INCREF(handlertmp);
2242
2345
PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
2243
2346
}
2244
2347
2245
Py_INCREF(self->stream);
2246
2348
PyObject_CallMethod(self->server, "addStream", "O", self->stream);
2247
2349
2248
2350
(*self->mode_func_ptr)(self);
2249
2351
2250
Py_INCREF(self);
2251
return 0;
2352
return (PyObject *)self;
2252
2353
}
2253
2354
2254
2355
static PyObject * Notein_getServer(Notein* self) { GET_SERVER };
2281
2382
static PyMethodDef Notein_methods[] = {
2282
2383
{"getServer", (PyCFunction)Notein_getServer, METH_NOARGS, "Returns server object."},
2283
2384
{"_getStream", (PyCFunction)Notein_getStream, METH_NOARGS, "Returns stream object."},
2284
{"deleteStream", (PyCFunction)Notein_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
2285
2385
{"play", (PyCFunction)Notein_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
2286
2386
{"stop", (PyCFunction)Notein_stop, METH_NOARGS, "Stops computing."},
2287
2387
{"setMul", (PyCFunction)Notein_setMul, METH_O, "Sets Notein mul factor."},
2370
2470
0, /* tp_descr_get */
2371
2471
0, /* tp_descr_set */
2372
2472
0, /* tp_dictoffset */
2373
(initproc)Notein_init, /* tp_init */
2473
0, /* tp_init */
2374
2474
0, /* tp_alloc */
2375
2475
Notein_new, /* tp_new */
2376
2476
};
2523
2623
static void
2524
2624
MidiAdsr_dealloc(MidiAdsr* self)
2525
2625
{
2526
free(self->data);
2626
pyo_DEALLOC
2527
2627
MidiAdsr_clear(self);
2528
2628
self->ob_type->tp_free((PyObject*)self);
2529
2629
}
2530
2630
2531
static PyObject * MidiAdsr_deleteStream(MidiAdsr *self) { DELETE_STREAM };
2532
2533
2631
static PyObject *
2534
2632
MidiAdsr_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2535
2633
{
2536
2634
int i;
2635
PyObject *inputtmp, *input_streamtmp, *multmp=NULL, *addtmp=NULL;
2537
2636
MidiAdsr *self;
2538
2637
self = (MidiAdsr *)type->tp_alloc(type, 0);
2539
2638
2553
2652
self->mode_func_ptr = MidiAdsr_setProcMode;
2554
2653
2555
2654
self->sampleToSec = 1. / self->sr;
2556
2557
return (PyObject *)self;
2558
}
2559
2655
2560
static int
2561
MidiAdsr_init(MidiAdsr *self, PyObject *args, PyObject *kwds)
2562
{
2563
PyObject *inputtmp, *input_streamtmp, *multmp=NULL, *addtmp=NULL;
2564
2565
2656
static char *kwlist[] = {"input", "attack", "decay", "sustain", "release", "mul", "add", NULL};
2566
2657
2567
2658
if (! PyArg_ParseTupleAndKeywords(args, kwds, TYPE_O_FFFFOO, kwlist, &inputtmp, &self->attack, &self->decay, &self->sustain, &self->release, &multmp, &addtmp))
2568
return -1;
2659
Py_RETURN_NONE;
2569
2660
2570
2661
INIT_INPUT_STREAM
2571
2662
2577
2668
PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
2578
2669
}
2579
2670
2580
Py_INCREF(self->stream);
2581
2671
PyObject_CallMethod(self->server, "addStream", "O", self->stream);
2582
2672
2583
2673
(*self->mode_func_ptr)(self);
2584
2585
Py_INCREF(self);
2586
return 0;
2674
2675
return (PyObject *)self;
2587
2676
}
2588
2677
2589
2678
static PyObject * MidiAdsr_getServer(MidiAdsr* self) { GET_SERVER };
2654
2743
static PyMethodDef MidiAdsr_methods[] = {
2655
2744
{"getServer", (PyCFunction)MidiAdsr_getServer, METH_NOARGS, "Returns server object."},
2656
2745
{"_getStream", (PyCFunction)MidiAdsr_getStream, METH_NOARGS, "Returns stream object."},
2657
{"deleteStream", (PyCFunction)MidiAdsr_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
2658
2746
{"play", (PyCFunction)MidiAdsr_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
2659
2747
{"stop", (PyCFunction)MidiAdsr_stop, METH_NOARGS, "Starts fadeout and stops computing."},
2660
2748
{"setMul", (PyCFunction)MidiAdsr_setMul, METH_O, "Sets MidiAdsr mul factor."},
2747
2835
0, /* tp_descr_get */
2748
2836
0, /* tp_descr_set */
2749
2837
0, /* tp_dictoffset */
2750
(initproc)MidiAdsr_init, /* tp_init */
2838
0, /* tp_init */
2751
2839
0, /* tp_alloc */
2752
2840
MidiAdsr_new, /* tp_new */
2753
2841
};
2905
2993
static void
2906
2994
MidiDelAdsr_dealloc(MidiDelAdsr* self)
2907
2995
{
2908
free(self->data);
2996
pyo_DEALLOC
2909
2997
MidiDelAdsr_clear(self);
2910
2998
self->ob_type->tp_free((PyObject*)self);
2911
2999
}
2912
3000
2913
static PyObject * MidiDelAdsr_deleteStream(MidiDelAdsr *self) { DELETE_STREAM };
2914
2915
3001
static PyObject *
2916
3002
MidiDelAdsr_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2917
3003
{
2918
3004
int i;
3005
PyObject *inputtmp, *input_streamtmp, *multmp=NULL, *addtmp=NULL;
2919
3006
MidiDelAdsr *self;
2920
3007
self = (MidiDelAdsr *)type->tp_alloc(type, 0);
2921
3008
2936
3023
self->mode_func_ptr = MidiDelAdsr_setProcMode;
2937
3024
2938
3025
self->sampleToSec = 1. / self->sr;
2939
2940
return (PyObject *)self;
2941
}
2942
3026
2943
static int
2944
MidiDelAdsr_init(MidiDelAdsr *self, PyObject *args, PyObject *kwds)
2945
{
2946
PyObject *inputtmp, *input_streamtmp, *multmp=NULL, *addtmp=NULL;
2947
2948
3027
static char *kwlist[] = {"input", "delay", "attack", "decay", "sustain", "release", "mul", "add", NULL};
2949
3028
2950
3029
if (! PyArg_ParseTupleAndKeywords(args, kwds, TYPE_O_FFFFFOO, kwlist, &inputtmp, &self->delay, &self->attack, &self->decay, &self->sustain, &self->release, &multmp, &addtmp))
2951
return -1;
3030
Py_RETURN_NONE;
2952
3031
2953
3032
INIT_INPUT_STREAM
2954
3033
2960
3039
PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
2961
3040
}
2962
3041
2963
Py_INCREF(self->stream);
2964
3042
PyObject_CallMethod(self->server, "addStream", "O", self->stream);
2965
3043
2966
3044
(*self->mode_func_ptr)(self);
2967
3045
2968
Py_INCREF(self);
2969
return 0;
3046
return (PyObject *)self;
2970
3047
}
2971
3048
2972
3049
static PyObject * MidiDelAdsr_getServer(MidiDelAdsr* self) { GET_SERVER };
3048
3125
static PyMethodDef MidiDelAdsr_methods[] = {
3049
3126
{"getServer", (PyCFunction)MidiDelAdsr_getServer, METH_NOARGS, "Returns server object."},
3050
3127
{"_getStream", (PyCFunction)MidiDelAdsr_getStream, METH_NOARGS, "Returns stream object."},
3051
{"deleteStream", (PyCFunction)MidiDelAdsr_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
3052
3128
{"play", (PyCFunction)MidiDelAdsr_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
3053
3129
{"stop", (PyCFunction)MidiDelAdsr_stop, METH_NOARGS, "Starts fadeout and stops computing."},
3054
3130
{"setMul", (PyCFunction)MidiDelAdsr_setMul, METH_O, "Sets MidiDelAdsr mul factor."},
3142
3218
0, /* tp_descr_get */
3143
3219
0, /* tp_descr_set */
3144
3220
0, /* tp_dictoffset */
3145
(initproc)MidiDelAdsr_init, /* tp_init */
3221
0, /* tp_init */
3146
3222
0, /* tp_alloc */
3147
3223
MidiDelAdsr_new, /* tp_new */
3148
3224
};
Loggerhead is a web-based interface for Breezy
Version: 2.0.1