← Back to branch summary

~ubuntu-branches/ubuntu/quantal/python-pyo/quantal

« back to all changes in this revision

Viewing changes to src/objects/metromodule.c

  • 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.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/objects/metromodule.c
178
178
static void
179
179
Metro_dealloc(Metro* self)
180
180
{
181
 
    free(self->data);
 
181
    pyo_DEALLOC
182
182
    Metro_clear(self);
183
183
    self->ob_type->tp_free((PyObject*)self);
184
184
}
185
185
 
186
 
static PyObject * Metro_deleteStream(Metro *self) { DELETE_STREAM };
187
 
 
188
186
static PyObject *
189
187
Metro_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
190
188
{
191
189
    int i;
 
190
    PyObject *timetmp=NULL;
192
191
    Metro *self;
193
192
    self = (Metro *)type->tp_alloc(type, 0);
194
193
    
206
205
 
207
206
    self->sampleToSec = 1.0 / self->sr;
208
207
    self->currentTime = 0.;
209
 
    
210
 
    return (PyObject *)self;
211
 
}
212
208
 
213
 
static int
214
 
Metro_init(Metro *self, PyObject *args, PyObject *kwds)
215
 
{
216
 
    PyObject *timetmp=NULL;
217
 
    
218
209
    static char *kwlist[] = {"time", "offset", NULL};
219
210
    
220
211
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "|Od", kwlist, &timetmp, &self->offset))
221
 
        return -1; 
 
212
        Py_RETURN_NONE;
222
213
 
223
214
    if (timetmp) {
224
215
        PyObject_CallMethod((PyObject *)self, "setTime", "O", timetmp);
225
216
    }
226
217
    
227
 
    Py_INCREF(self->stream);
228
218
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
229
219
 
230
220
    (*self->mode_func_ptr)(self);
231
 
 
232
 
    Py_INCREF(self);
233
 
    return 0;
 
221
    
 
222
    return (PyObject *)self;
234
223
}
235
224
 
236
225
static PyObject * Metro_getServer(Metro* self) { GET_SERVER };
298
287
static PyMethodDef Metro_methods[] = {
299
288
{"getServer", (PyCFunction)Metro_getServer, METH_NOARGS, "Returns server object."},
300
289
{"_getStream", (PyCFunction)Metro_getStream, METH_NOARGS, "Returns stream object."},
301
 
{"deleteStream", (PyCFunction)Metro_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
302
290
{"play", (PyCFunction)Metro_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
303
291
{"stop", (PyCFunction)Metro_stop, METH_NOARGS, "Stops computing."},
304
292
{"setTime", (PyCFunction)Metro_setTime, METH_O, "Sets time factor."},
388
376
0,                         /* tp_descr_get */
389
377
0,                         /* tp_descr_set */
390
378
0,                         /* tp_dictoffset */
391
 
(initproc)Metro_init,      /* tp_init */
 
379
0,      /* tp_init */
392
380
0,                         /* tp_alloc */
393
381
Metro_new,                 /* tp_new */
394
382
};
553
541
static void
554
542
Seqer_dealloc(Seqer* self)
555
543
{
556
 
    free(self->data);
 
544
    pyo_DEALLOC
557
545
    free(self->buffer_streams);
558
546
    Seqer_clear(self);
559
547
    self->ob_type->tp_free((PyObject*)self);
560
548
}
561
549
 
562
 
static PyObject * Seqer_deleteStream(Seqer *self) { DELETE_STREAM };
563
 
 
564
550
static PyObject *
565
551
Seqer_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
566
552
{
567
553
    int i;
 
554
    PyObject *timetmp=NULL, *seqtmp=NULL;
568
555
    Seqer *self;
569
556
    self = (Seqer *)type->tp_alloc(type, 0);
570
557
    
589
576
    
590
577
    self->sampleToSec = 1.0 / self->sr;
591
578
    self->currentTime = -1.0;
592
 
    
593
 
    return (PyObject *)self;
594
 
}
595
579
 
596
 
static int
597
 
Seqer_init(Seqer *self, PyObject *args, PyObject *kwds)
598
 
{
599
 
    PyObject *timetmp=NULL, *seqtmp=NULL;
600
 
    
601
580
    static char *kwlist[] = {"time", "seq", "poly", NULL};
602
581
    
603
582
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "|OOi", kwlist, &timetmp, &seqtmp, &self->poly))
604
 
        return -1; 
 
583
        Py_RETURN_NONE;
605
584
    
606
585
    if (timetmp) {
607
586
        PyObject_CallMethod((PyObject *)self, "setTime", "O", timetmp);
611
590
        PyObject_CallMethod((PyObject *)self, "setSeq", "O", seqtmp);
612
591
    }
613
592
    
614
 
    Py_INCREF(self->stream);
615
593
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
616
594
 
617
595
    self->buffer_streams = (MYFLT *)realloc(self->buffer_streams, self->poly * self->bufsize * sizeof(MYFLT));
618
596
 
619
597
    (*self->mode_func_ptr)(self);
620
598
    
621
 
    Py_INCREF(self);
622
 
    return 0;
 
599
    return (PyObject *)self;
623
600
}
624
601
 
625
602
static PyObject * Seqer_getServer(Seqer* self) { GET_SERVER };
696
673
static PyMethodDef Seqer_methods[] = {
697
674
    {"getServer", (PyCFunction)Seqer_getServer, METH_NOARGS, "Returns server object."},
698
675
    {"_getStream", (PyCFunction)Seqer_getStream, METH_NOARGS, "Returns stream object."},
699
 
    {"deleteStream", (PyCFunction)Seqer_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
700
676
    {"play", (PyCFunction)Seqer_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
701
677
    {"stop", (PyCFunction)Seqer_stop, METH_NOARGS, "Stops computing."},
702
678
    {"setTime", (PyCFunction)Seqer_setTime, METH_O, "Sets time factor."},
741
717
    0,                         /* tp_descr_get */
742
718
    0,                         /* tp_descr_set */
743
719
    0,                         /* tp_dictoffset */
744
 
    (initproc)Seqer_init,      /* tp_init */
 
720
    0,      /* tp_init */
745
721
    0,                         /* tp_alloc */
746
722
    Seqer_new,                 /* tp_new */
747
723
};
834
810
static void
835
811
Seq_dealloc(Seq* self)
836
812
{
837
 
    free(self->data);
 
813
    pyo_DEALLOC
838
814
    Seq_clear(self);
839
815
    self->ob_type->tp_free((PyObject*)self);
840
816
}
841
817
 
842
 
static PyObject * Seq_deleteStream(Seq *self) { DELETE_STREAM };
843
 
 
844
818
static PyObject *
845
819
Seq_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
846
820
{
847
821
    int i;
 
822
    PyObject *maintmp=NULL;
848
823
    Seq *self;
849
824
    self = (Seq *)type->tp_alloc(type, 0);
850
825
    
855
830
    INIT_OBJECT_COMMON
856
831
    Stream_setFunctionPtr(self->stream, Seq_compute_next_data_frame);
857
832
    self->mode_func_ptr = Seq_setProcMode;
858
 
    
859
 
    return (PyObject *)self;
860
 
}
861
833
 
862
 
static int
863
 
Seq_init(Seq *self, PyObject *args, PyObject *kwds)
864
 
{
865
 
    PyObject *maintmp=NULL;
866
 
    
867
834
    static char *kwlist[] = {"mainPlayer", "chnl", NULL};
868
835
    
869
836
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|i", kwlist, &maintmp, &self->chnl))
870
 
        return -1; 
 
837
        Py_RETURN_NONE;
871
838
    
872
839
    Py_XDECREF(self->mainPlayer);
873
840
    Py_INCREF(maintmp);
874
841
    self->mainPlayer = (Seqer *)maintmp;
875
842
    
876
 
    Py_INCREF(self->stream);
877
843
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
878
844
    
879
845
    (*self->mode_func_ptr)(self);
880
846
    
881
 
    Py_INCREF(self);
882
 
    return 0;
 
847
    return (PyObject *)self;
883
848
}
884
849
 
885
850
static PyObject * Seq_getServer(Seq* self) { GET_SERVER };
913
878
static PyMethodDef Seq_methods[] = {
914
879
    {"getServer", (PyCFunction)Seq_getServer, METH_NOARGS, "Returns server object."},
915
880
    {"_getStream", (PyCFunction)Seq_getStream, METH_NOARGS, "Returns stream object."},
916
 
    {"deleteStream", (PyCFunction)Seq_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
917
881
    {"play", (PyCFunction)Seq_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
918
882
    {"out", (PyCFunction)Seq_out, METH_VARARGS|METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."},
919
883
    {"stop", (PyCFunction)Seq_stop, METH_NOARGS, "Stops computing."},
1003
967
    0,                         /* tp_descr_get */
1004
968
    0,                         /* tp_descr_set */
1005
969
    0,                         /* tp_dictoffset */
1006
 
    (initproc)Seq_init,      /* tp_init */
 
970
    0,      /* tp_init */
1007
971
    0,                         /* tp_alloc */
1008
972
    Seq_new,                 /* tp_new */
1009
973
};
1121
1085
static void
1122
1086
Clouder_dealloc(Clouder* self)
1123
1087
{
1124
 
    free(self->data);
 
1088
    pyo_DEALLOC
1125
1089
    free(self->buffer_streams);
1126
1090
    Clouder_clear(self);
1127
1091
    self->ob_type->tp_free((PyObject*)self);
1128
1092
}
1129
1093
 
1130
 
static PyObject * Clouder_deleteStream(Clouder *self) { DELETE_STREAM };
1131
 
 
1132
1094
static PyObject *
1133
1095
Clouder_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1134
1096
{
1135
1097
    int i;
 
1098
    PyObject *densitytmp=NULL;
1136
1099
    Clouder *self;
1137
1100
    self = (Clouder *)type->tp_alloc(type, 0);
1138
1101
    
1146
1109
    self->mode_func_ptr = Clouder_setProcMode;
1147
1110
    
1148
1111
    Stream_setStreamActive(self->stream, 0);
1149
 
    
1150
 
    return (PyObject *)self;
1151
 
}
1152
1112
 
1153
 
static int
1154
 
Clouder_init(Clouder *self, PyObject *args, PyObject *kwds)
1155
 
{
1156
 
    PyObject *densitytmp=NULL;
1157
 
    
1158
1113
    static char *kwlist[] = {"density", "poly", NULL};
1159
1114
    
1160
1115
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "|Oi", kwlist, &densitytmp, &self->poly))
1161
 
        return -1; 
 
1116
        Py_RETURN_NONE;
1162
1117
    
1163
1118
    if (densitytmp) {
1164
1119
        PyObject_CallMethod((PyObject *)self, "setDensity", "O", densitytmp);
1165
1120
    }
1166
1121
    
1167
 
    Py_INCREF(self->stream);
1168
1122
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
1169
1123
    
1170
1124
    (*self->mode_func_ptr)(self);
1172
1126
    Server_generateSeed((Server *)self->server, CLOUD_ID);
1173
1127
 
1174
1128
    self->buffer_streams = (MYFLT *)realloc(self->buffer_streams, self->poly * self->bufsize * sizeof(MYFLT));
1175
 
       
1176
 
    Py_INCREF(self);
1177
 
    return 0;
 
1129
    
 
1130
    return (PyObject *)self;
1178
1131
}
1179
1132
 
1180
1133
static PyObject * Clouder_getServer(Clouder* self) { GET_SERVER };
1227
1180
static PyMethodDef Clouder_methods[] = {
1228
1181
{"getServer", (PyCFunction)Clouder_getServer, METH_NOARGS, "Returns server object."},
1229
1182
{"_getStream", (PyCFunction)Clouder_getStream, METH_NOARGS, "Returns stream object."},
1230
 
{"deleteStream", (PyCFunction)Clouder_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
1231
1183
{"play", (PyCFunction)Clouder_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
1232
1184
{"stop", (PyCFunction)Clouder_stop, METH_NOARGS, "Stops computing."},
1233
1185
{"setDensity", (PyCFunction)Clouder_setDensity, METH_O, "Sets density factor."},
1271
1223
0,                         /* tp_descr_get */
1272
1224
0,                         /* tp_descr_set */
1273
1225
0,                         /* tp_dictoffset */
1274
 
(initproc)Clouder_init,      /* tp_init */
 
1226
0,      /* tp_init */
1275
1227
0,                         /* tp_alloc */
1276
1228
Clouder_new,                 /* tp_new */
1277
1229
};
1364
1316
static void
1365
1317
Cloud_dealloc(Cloud* self)
1366
1318
{
1367
 
    free(self->data);
 
1319
    pyo_DEALLOC
1368
1320
    Cloud_clear(self);
1369
1321
    self->ob_type->tp_free((PyObject*)self);
1370
1322
}
1371
1323
 
1372
 
static PyObject * Cloud_deleteStream(Cloud *self) { DELETE_STREAM };
1373
 
 
1374
1324
static PyObject *
1375
1325
Cloud_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1376
1326
{
1377
1327
    int i;
 
1328
    PyObject *maintmp=NULL;
1378
1329
    Cloud *self;
1379
1330
    self = (Cloud *)type->tp_alloc(type, 0);
1380
1331
    
1385
1336
    INIT_OBJECT_COMMON
1386
1337
    Stream_setFunctionPtr(self->stream, Cloud_compute_next_data_frame);
1387
1338
    self->mode_func_ptr = Cloud_setProcMode;
1388
 
    
1389
 
    return (PyObject *)self;
1390
 
}
1391
1339
 
1392
 
static int
1393
 
Cloud_init(Cloud *self, PyObject *args, PyObject *kwds)
1394
 
{
1395
 
    PyObject *maintmp=NULL;
1396
 
    
1397
1340
    static char *kwlist[] = {"mainPlayer", "chnl", NULL};
1398
1341
    
1399
1342
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|i", kwlist, &maintmp, &self->chnl))
1400
 
        return -1; 
 
1343
        Py_RETURN_NONE;
1401
1344
    
1402
1345
    Py_XDECREF(self->mainPlayer);
1403
1346
    Py_INCREF(maintmp);
1404
1347
    self->mainPlayer = (Clouder *)maintmp;
1405
1348
 
1406
 
    Py_INCREF(self->stream);
1407
1349
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
1408
1350
    
1409
1351
    (*self->mode_func_ptr)(self);
1410
 
        
1411
 
    Py_INCREF(self);
1412
 
    return 0;
 
1352
    
 
1353
    return (PyObject *)self;
1413
1354
}
1414
1355
 
1415
1356
static PyObject * Cloud_getServer(Cloud* self) { GET_SERVER };
1443
1384
static PyMethodDef Cloud_methods[] = {
1444
1385
{"getServer", (PyCFunction)Cloud_getServer, METH_NOARGS, "Returns server object."},
1445
1386
{"_getStream", (PyCFunction)Cloud_getStream, METH_NOARGS, "Returns stream object."},
1446
 
{"deleteStream", (PyCFunction)Cloud_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
1447
1387
{"play", (PyCFunction)Cloud_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
1448
1388
{"out", (PyCFunction)Cloud_out, METH_VARARGS|METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."},
1449
1389
{"stop", (PyCFunction)Cloud_stop, METH_NOARGS, "Stops computing."},
1533
1473
0,                         /* tp_descr_get */
1534
1474
0,                         /* tp_descr_set */
1535
1475
0,                         /* tp_dictoffset */
1536
 
(initproc)Cloud_init,      /* tp_init */
 
1476
0,      /* tp_init */
1537
1477
0,                         /* tp_alloc */
1538
1478
Cloud_new,                 /* tp_new */
1539
1479
};
1623
1563
static void
1624
1564
Trig_dealloc(Trig* self)
1625
1565
{
1626
 
    free(self->data);
 
1566
    pyo_DEALLOC
1627
1567
    Trig_clear(self);
1628
1568
    self->ob_type->tp_free((PyObject*)self);
1629
1569
}
1630
1570
 
1631
 
static PyObject * Trig_deleteStream(Trig *self) { DELETE_STREAM };
1632
 
 
1633
1571
static PyObject *
1634
1572
Trig_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1635
1573
{
1644
1582
    INIT_OBJECT_COMMON
1645
1583
    Stream_setFunctionPtr(self->stream, Trig_compute_next_data_frame);
1646
1584
    self->mode_func_ptr = Trig_setProcMode;
1647
 
    
1648
 
    return (PyObject *)self;
1649
 
}
1650
1585
 
1651
 
static int
1652
 
Trig_init(Trig *self, PyObject *args, PyObject *kwds)
1653
 
{
1654
1586
    static char *kwlist[] = {NULL};
1655
1587
    
1656
1588
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "", kwlist))
1657
 
        return -1; 
 
1589
        Py_RETURN_NONE;
1658
1590
 
1659
 
    Py_INCREF(self->stream);
1660
1591
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
1661
1592
 
1662
1593
    (*self->mode_func_ptr)(self);
1663
 
 
1664
 
    Py_INCREF(self);
1665
 
    return 0;
 
1594
    
 
1595
    return (PyObject *)self;
1666
1596
}
1667
1597
 
1668
1598
static PyObject * Trig_getServer(Trig* self) { GET_SERVER };
1700
1630
static PyMethodDef Trig_methods[] = {
1701
1631
{"getServer", (PyCFunction)Trig_getServer, METH_NOARGS, "Returns server object."},
1702
1632
{"_getStream", (PyCFunction)Trig_getStream, METH_NOARGS, "Returns stream object."},
1703
 
{"deleteStream", (PyCFunction)Trig_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
1704
1633
{"play", (PyCFunction)Trig_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
1705
1634
{"stop", (PyCFunction)Trig_stop, METH_NOARGS, "Stops computing."},
1706
1635
{"setMul", (PyCFunction)Trig_setMul, METH_O, "Sets oscillator mul factor."},
1789
1718
0,                         /* tp_descr_get */
1790
1719
0,                         /* tp_descr_set */
1791
1720
0,                         /* tp_dictoffset */
1792
 
(initproc)Trig_init,      /* tp_init */
 
1721
0,      /* tp_init */
1793
1722
0,                         /* tp_alloc */
1794
1723
Trig_new,                 /* tp_new */
1795
1724
};
2051
1980
    }
2052
1981
    
2053
1982
    for (i=0; i<self->bufsize; i++) {
2054
 
        self->currentTime += self->sampleToSec;
2055
1983
        self->tap_buffer_streams[i + self->voiceCount * self->bufsize] = (MYFLT)self->currentTap;
2056
1984
        for (j=0; j<self->poly; j++) {
2057
1985
            self->amp_buffer_streams[i + j * self->bufsize] = self->amplitudes[j];
2059
1987
        self->dur_buffer_streams[i + self->voiceCount * self->bufsize] = self->durations[self->tapCount];
2060
1988
        if (self->currentTime >= tm) {
2061
1989
            self->currentTime -= tm;
2062
 
            if (self->tapCount == (self->last_taps-2))
 
1990
            if (self->tapCount == (self->last_taps-1))
2063
1991
                self->end_buffer_streams[i + self->voiceCount * self->bufsize] = 1.0;
2064
1992
            if (self->sequence[self->tapCount] == 1) {
2065
1993
                self->currentTap = self->tapCount;
2098
2026
                }    
2099
2027
            }
2100
2028
        }
 
2029
        self->currentTime += self->sampleToSec;
2101
2030
    }
2102
2031
}
2103
2032
 
2121
2050
    
2122
2051
    for (i=0; i<self->bufsize; i++) {
2123
2052
        tm = (double)time[i];
2124
 
        self->currentTime += self->sampleToSec;
2125
2053
        self->tap_buffer_streams[i + self->voiceCount * self->bufsize] = (MYFLT)self->currentTap;
2126
2054
        for (j=0; j<self->poly; j++) {
2127
2055
            self->amp_buffer_streams[i + j * self->bufsize] = self->amplitudes[j];
2129
2057
        self->dur_buffer_streams[i + self->voiceCount * self->bufsize] = self->durations[self->tapCount];
2130
2058
        if (self->currentTime >= tm) {
2131
2059
            self->currentTime -= tm;
2132
 
            if (self->tapCount == (self->last_taps-2))
 
2060
            if (self->tapCount == (self->last_taps-1))
2133
2061
                self->end_buffer_streams[i + self->voiceCount * self->bufsize] = 1.0;
2134
2062
            if (self->sequence[self->tapCount] == 1) {
2135
2063
                self->currentTap = self->tapCount;
2169
2097
                }    
2170
2098
            }
2171
2099
        }
 
2100
        self->currentTime += self->sampleToSec;
2172
2101
    }
2173
2102
}
2174
2103
 
2243
2172
static void
2244
2173
Beater_dealloc(Beater* self)
2245
2174
{
2246
 
    free(self->data);
 
2175
    pyo_DEALLOC
2247
2176
    free(self->buffer_streams);
2248
2177
    free(self->tap_buffer_streams);
2249
2178
    free(self->amp_buffer_streams);
2250
2179
    free(self->dur_buffer_streams);
2251
2180
    free(self->end_buffer_streams);
 
2181
    free(self->amplitudes);
2252
2182
    Beater_clear(self);
2253
2183
    self->ob_type->tp_free((PyObject*)self);
2254
2184
}
2255
2185
 
2256
 
static PyObject * Beater_deleteStream(Beater *self) { DELETE_STREAM };
2257
 
 
2258
2186
static PyObject *
2259
2187
Beater_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2260
2188
{
2261
2189
    int i, j;
 
2190
    PyObject *timetmp=NULL;
2262
2191
    Beater *self;
2263
2192
    self = (Beater *)type->tp_alloc(type, 0);
2264
2193
    
2293
2222
    self->currentTime = -1.0;
2294
2223
 
2295
2224
    Stream_setStreamActive(self->stream, 0);
2296
 
    
2297
 
    return (PyObject *)self;
2298
 
}
2299
2225
 
2300
 
static int
2301
 
Beater_init(Beater *self, PyObject *args, PyObject *kwds)
2302
 
{
2303
 
    int i;
2304
 
    PyObject *timetmp=NULL;
2305
 
    
2306
2226
    static char *kwlist[] = {"time", "taps", "weight1", "weight2", "weight3", "poly", NULL};
2307
2227
    
2308
2228
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "|Oiiiii", kwlist, &timetmp, &self->taps, &self->weight1, &self->weight2, &self->weight3, &self->poly))
2309
 
        return -1; 
 
2229
        Py_RETURN_NONE;
2310
2230
    
2311
2231
    if (timetmp) {
2312
2232
        PyObject_CallMethod((PyObject *)self, "setTime", "O", timetmp);
2313
2233
    }
2314
2234
    
2315
 
    Py_INCREF(self->stream);
2316
2235
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
2317
2236
    
2318
2237
    (*self->mode_func_ptr)(self);
2335
2254
    Beater_makeTable(self, 0);
2336
2255
    Beater_makeSequence(self);
2337
2256
    
2338
 
    Py_INCREF(self);
2339
 
    return 0;
 
2257
    return (PyObject *)self;
2340
2258
}
2341
2259
 
2342
2260
static PyObject * Beater_getServer(Beater* self) { GET_SERVER };
2520
2438
static PyMethodDef Beater_methods[] = {
2521
2439
    {"getServer", (PyCFunction)Beater_getServer, METH_NOARGS, "Returns server object."},
2522
2440
    {"_getStream", (PyCFunction)Beater_getStream, METH_NOARGS, "Returns stream object."},
2523
 
    {"deleteStream", (PyCFunction)Beater_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
2524
2441
    {"play", (PyCFunction)Beater_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
2525
2442
    {"stop", (PyCFunction)Beater_stop, METH_NOARGS, "Stops computing."},
2526
2443
    {"setTime", (PyCFunction)Beater_setTime, METH_O, "Sets tap duration."},
2572
2489
    0,                         /* tp_descr_get */
2573
2490
    0,                         /* tp_descr_set */
2574
2491
    0,                         /* tp_dictoffset */
2575
 
    (initproc)Beater_init,      /* tp_init */
 
2492
    0,      /* tp_init */
2576
2493
    0,                         /* tp_alloc */
2577
2494
    Beater_new,                 /* tp_new */
2578
2495
};
2665
2582
static void
2666
2583
Beat_dealloc(Beat* self)
2667
2584
{
2668
 
    free(self->data);
 
2585
    pyo_DEALLOC
2669
2586
    Beat_clear(self);
2670
2587
    self->ob_type->tp_free((PyObject*)self);
2671
2588
}
2672
2589
 
2673
 
static PyObject * Beat_deleteStream(Beat *self) { DELETE_STREAM };
2674
 
 
2675
2590
static PyObject *
2676
2591
Beat_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2677
2592
{
2678
2593
    int i;
 
2594
    PyObject *maintmp=NULL;
2679
2595
    Beat *self;
2680
2596
    self = (Beat *)type->tp_alloc(type, 0);
2681
2597
    
2686
2602
    INIT_OBJECT_COMMON
2687
2603
    Stream_setFunctionPtr(self->stream, Beat_compute_next_data_frame);
2688
2604
    self->mode_func_ptr = Beat_setProcMode;
2689
 
    
2690
 
    return (PyObject *)self;
2691
 
}
2692
2605
 
2693
 
static int
2694
 
Beat_init(Beat *self, PyObject *args, PyObject *kwds)
2695
 
{
2696
 
    PyObject *maintmp=NULL;
2697
 
    
2698
2606
    static char *kwlist[] = {"mainPlayer", "chnl", NULL};
2699
2607
    
2700
2608
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|i", kwlist, &maintmp, &self->chnl))
2701
 
        return -1; 
 
2609
        Py_RETURN_NONE;
2702
2610
    
2703
2611
    Py_XDECREF(self->mainPlayer);
2704
2612
    Py_INCREF(maintmp);
2705
2613
    self->mainPlayer = (Beater *)maintmp;
2706
2614
    
2707
 
    Py_INCREF(self->stream);
2708
2615
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
2709
2616
    
2710
2617
    (*self->mode_func_ptr)(self);
2711
 
        
2712
 
    Py_INCREF(self);
2713
 
    return 0;
 
2618
    
 
2619
    return (PyObject *)self;
2714
2620
}
2715
2621
 
2716
2622
static PyObject * Beat_getServer(Beat* self) { GET_SERVER };
2744
2650
static PyMethodDef Beat_methods[] = {
2745
2651
    {"getServer", (PyCFunction)Beat_getServer, METH_NOARGS, "Returns server object."},
2746
2652
    {"_getStream", (PyCFunction)Beat_getStream, METH_NOARGS, "Returns stream object."},
2747
 
    {"deleteStream", (PyCFunction)Beat_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
2748
2653
    {"play", (PyCFunction)Beat_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
2749
2654
    {"out", (PyCFunction)Beat_out, METH_VARARGS|METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."},
2750
2655
    {"stop", (PyCFunction)Beat_stop, METH_NOARGS, "Stops computing."},
2834
2739
    0,                         /* tp_descr_get */
2835
2740
    0,                         /* tp_descr_set */
2836
2741
    0,                         /* tp_dictoffset */
2837
 
    (initproc)Beat_init,      /* tp_init */
 
2742
    0,      /* tp_init */
2838
2743
    0,                         /* tp_alloc */
2839
2744
    Beat_new,                 /* tp_new */
2840
2745
};
2927
2832
static void
2928
2833
BeatTapStream_dealloc(BeatTapStream* self)
2929
2834
{
2930
 
    free(self->data);
 
2835
    pyo_DEALLOC
2931
2836
    BeatTapStream_clear(self);
2932
2837
    self->ob_type->tp_free((PyObject*)self);
2933
2838
}
2934
2839
 
2935
 
static PyObject * BeatTapStream_deleteStream(BeatTapStream *self) { DELETE_STREAM };
2936
 
 
2937
2840
static PyObject *
2938
2841
BeatTapStream_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2939
2842
{
2940
2843
    int i;
 
2844
    PyObject *maintmp=NULL;
2941
2845
    BeatTapStream *self;
2942
2846
    self = (BeatTapStream *)type->tp_alloc(type, 0);
2943
2847
    
2948
2852
    INIT_OBJECT_COMMON
2949
2853
    Stream_setFunctionPtr(self->stream, BeatTapStream_compute_next_data_frame);
2950
2854
    self->mode_func_ptr = BeatTapStream_setProcMode;
2951
 
    
2952
 
    return (PyObject *)self;
2953
 
}
2954
2855
 
2955
 
static int
2956
 
BeatTapStream_init(BeatTapStream *self, PyObject *args, PyObject *kwds)
2957
 
{
2958
 
    PyObject *maintmp=NULL;
2959
 
    
2960
2856
    static char *kwlist[] = {"mainPlayer", "chnl", NULL};
2961
2857
    
2962
2858
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|i", kwlist, &maintmp, &self->chnl))
2963
 
        return -1; 
 
2859
        Py_RETURN_NONE;
2964
2860
    
2965
2861
    Py_XDECREF(self->mainPlayer);
2966
2862
    Py_INCREF(maintmp);
2967
2863
    self->mainPlayer = (Beater *)maintmp;
2968
2864
    
2969
 
    Py_INCREF(self->stream);
2970
2865
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
2971
2866
    
2972
2867
    (*self->mode_func_ptr)(self);
2973
2868
    
2974
 
    Py_INCREF(self);
2975
 
    return 0;
 
2869
    return (PyObject *)self;
2976
2870
}
2977
2871
 
2978
2872
static PyObject * BeatTapStream_getServer(BeatTapStream* self) { GET_SERVER };
3006
2900
static PyMethodDef BeatTapStream_methods[] = {
3007
2901
    {"getServer", (PyCFunction)BeatTapStream_getServer, METH_NOARGS, "Returns server object."},
3008
2902
    {"_getStream", (PyCFunction)BeatTapStream_getStream, METH_NOARGS, "Returns stream object."},
3009
 
    {"deleteStream", (PyCFunction)BeatTapStream_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
3010
2903
    {"play", (PyCFunction)BeatTapStream_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
3011
2904
    {"out", (PyCFunction)BeatTapStream_out, METH_VARARGS|METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."},
3012
2905
    {"stop", (PyCFunction)BeatTapStream_stop, METH_NOARGS, "Stops computing."},
3096
2989
    0,                         /* tp_descr_get */
3097
2990
    0,                         /* tp_descr_set */
3098
2991
    0,                         /* tp_dictoffset */
3099
 
    (initproc)BeatTapStream_init,      /* tp_init */
 
2992
    0,      /* tp_init */
3100
2993
    0,                         /* tp_alloc */
3101
2994
    BeatTapStream_new,                 /* tp_new */
3102
2995
};
3189
3082
static void
3190
3083
BeatAmpStream_dealloc(BeatAmpStream* self)
3191
3084
{
3192
 
    free(self->data);
 
3085
    pyo_DEALLOC
3193
3086
    BeatAmpStream_clear(self);
3194
3087
    self->ob_type->tp_free((PyObject*)self);
3195
3088
}
3196
3089
 
3197
 
static PyObject * BeatAmpStream_deleteStream(BeatAmpStream *self) { DELETE_STREAM };
3198
 
 
3199
3090
static PyObject *
3200
3091
BeatAmpStream_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
3201
3092
{
3202
3093
    int i;
 
3094
    PyObject *maintmp=NULL;
3203
3095
    BeatAmpStream *self;
3204
3096
    self = (BeatAmpStream *)type->tp_alloc(type, 0);
3205
3097
    
3210
3102
    INIT_OBJECT_COMMON
3211
3103
    Stream_setFunctionPtr(self->stream, BeatAmpStream_compute_next_data_frame);
3212
3104
    self->mode_func_ptr = BeatAmpStream_setProcMode;
3213
 
    
3214
 
    return (PyObject *)self;
3215
 
}
3216
3105
 
3217
 
static int
3218
 
BeatAmpStream_init(BeatAmpStream *self, PyObject *args, PyObject *kwds)
3219
 
{
3220
 
    PyObject *maintmp=NULL;
3221
 
    
3222
3106
    static char *kwlist[] = {"mainPlayer", "chnl", NULL};
3223
3107
    
3224
3108
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|i", kwlist, &maintmp, &self->chnl))
3225
 
        return -1; 
 
3109
        Py_RETURN_NONE;
3226
3110
    
3227
3111
    Py_XDECREF(self->mainPlayer);
3228
3112
    Py_INCREF(maintmp);
3229
3113
    self->mainPlayer = (Beater *)maintmp;
3230
3114
    
3231
 
    Py_INCREF(self->stream);
3232
3115
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
3233
3116
    
3234
3117
    (*self->mode_func_ptr)(self);
3235
 
        
3236
 
    Py_INCREF(self);
3237
 
    return 0;
 
3118
    
 
3119
    return (PyObject *)self;
3238
3120
}
3239
3121
 
3240
3122
static PyObject * BeatAmpStream_getServer(BeatAmpStream* self) { GET_SERVER };
3268
3150
static PyMethodDef BeatAmpStream_methods[] = {
3269
3151
    {"getServer", (PyCFunction)BeatAmpStream_getServer, METH_NOARGS, "Returns server object."},
3270
3152
    {"_getStream", (PyCFunction)BeatAmpStream_getStream, METH_NOARGS, "Returns stream object."},
3271
 
    {"deleteStream", (PyCFunction)BeatAmpStream_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
3272
3153
    {"play", (PyCFunction)BeatAmpStream_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
3273
3154
    {"out", (PyCFunction)BeatAmpStream_out, METH_VARARGS|METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."},
3274
3155
    {"stop", (PyCFunction)BeatAmpStream_stop, METH_NOARGS, "Stops computing."},
3358
3239
    0,                         /* tp_descr_get */
3359
3240
    0,                         /* tp_descr_set */
3360
3241
    0,                         /* tp_dictoffset */
3361
 
    (initproc)BeatAmpStream_init,      /* tp_init */
 
3242
    0,      /* tp_init */
3362
3243
    0,                         /* tp_alloc */
3363
3244
    BeatAmpStream_new,                 /* tp_new */
3364
3245
};
3451
3332
static void
3452
3333
BeatDurStream_dealloc(BeatDurStream* self)
3453
3334
{
3454
 
    free(self->data);
 
3335
    pyo_DEALLOC
3455
3336
    BeatDurStream_clear(self);
3456
3337
    self->ob_type->tp_free((PyObject*)self);
3457
3338
}
3458
3339
 
3459
 
static PyObject * BeatDurStream_deleteStream(BeatDurStream *self) { DELETE_STREAM };
3460
 
 
3461
3340
static PyObject *
3462
3341
BeatDurStream_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
3463
3342
{
3464
3343
    int i;
 
3344
    PyObject *maintmp=NULL;
3465
3345
    BeatDurStream *self;
3466
3346
    self = (BeatDurStream *)type->tp_alloc(type, 0);
3467
3347
    
3472
3352
    INIT_OBJECT_COMMON
3473
3353
    Stream_setFunctionPtr(self->stream, BeatDurStream_compute_next_data_frame);
3474
3354
    self->mode_func_ptr = BeatDurStream_setProcMode;
3475
 
    
3476
 
    return (PyObject *)self;
3477
 
}
3478
3355
 
3479
 
static int
3480
 
BeatDurStream_init(BeatDurStream *self, PyObject *args, PyObject *kwds)
3481
 
{
3482
 
    PyObject *maintmp=NULL;
3483
 
    
3484
3356
    static char *kwlist[] = {"mainPlayer", "chnl", NULL};
3485
3357
    
3486
3358
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|i", kwlist, &maintmp, &self->chnl))
3487
 
        return -1; 
 
3359
        Py_RETURN_NONE;
3488
3360
    
3489
3361
    Py_XDECREF(self->mainPlayer);
3490
3362
    Py_INCREF(maintmp);
3491
3363
    self->mainPlayer = (Beater *)maintmp;
3492
3364
    
3493
 
    Py_INCREF(self->stream);
3494
3365
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
3495
3366
    
3496
3367
    (*self->mode_func_ptr)(self);
3497
 
        
3498
 
    Py_INCREF(self);
3499
 
    return 0;
 
3368
    
 
3369
    return (PyObject *)self;
3500
3370
}
3501
3371
 
3502
3372
static PyObject * BeatDurStream_getServer(BeatDurStream* self) { GET_SERVER };
3530
3400
static PyMethodDef BeatDurStream_methods[] = {
3531
3401
    {"getServer", (PyCFunction)BeatDurStream_getServer, METH_NOARGS, "Returns server object."},
3532
3402
    {"_getStream", (PyCFunction)BeatDurStream_getStream, METH_NOARGS, "Returns stream object."},
3533
 
    {"deleteStream", (PyCFunction)BeatDurStream_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
3534
3403
    {"play", (PyCFunction)BeatDurStream_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
3535
3404
    {"out", (PyCFunction)BeatDurStream_out, METH_VARARGS|METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."},
3536
3405
    {"stop", (PyCFunction)BeatDurStream_stop, METH_NOARGS, "Stops computing."},
3620
3489
    0,                         /* tp_descr_get */
3621
3490
    0,                         /* tp_descr_set */
3622
3491
    0,                         /* tp_dictoffset */
3623
 
    (initproc)BeatDurStream_init,      /* tp_init */
 
3492
    0,      /* tp_init */
3624
3493
    0,                         /* tp_alloc */
3625
3494
    BeatDurStream_new,                 /* tp_new */
3626
3495
};
3713
3582
static void
3714
3583
BeatEndStream_dealloc(BeatEndStream* self)
3715
3584
{
3716
 
    free(self->data);
 
3585
    pyo_DEALLOC
3717
3586
    BeatEndStream_clear(self);
3718
3587
    self->ob_type->tp_free((PyObject*)self);
3719
3588
}
3720
3589
 
3721
 
static PyObject * BeatEndStream_deleteStream(BeatEndStream *self) { DELETE_STREAM };
3722
 
 
3723
3590
static PyObject *
3724
3591
BeatEndStream_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
3725
3592
{
3726
3593
    int i;
 
3594
    PyObject *maintmp=NULL;
3727
3595
    BeatEndStream *self;
3728
3596
    self = (BeatEndStream *)type->tp_alloc(type, 0);
3729
3597
    
3734
3602
    INIT_OBJECT_COMMON
3735
3603
    Stream_setFunctionPtr(self->stream, BeatEndStream_compute_next_data_frame);
3736
3604
    self->mode_func_ptr = BeatEndStream_setProcMode;
3737
 
    
3738
 
    return (PyObject *)self;
3739
 
}
3740
3605
 
3741
 
static int
3742
 
BeatEndStream_init(BeatEndStream *self, PyObject *args, PyObject *kwds)
3743
 
{
3744
 
    PyObject *maintmp=NULL;
3745
 
    
3746
3606
    static char *kwlist[] = {"mainPlayer", "chnl", NULL};
3747
3607
    
3748
3608
    if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|i", kwlist, &maintmp, &self->chnl))
3749
 
        return -1; 
 
3609
        Py_RETURN_NONE;
3750
3610
    
3751
3611
    Py_XDECREF(self->mainPlayer);
3752
3612
    Py_INCREF(maintmp);
3753
3613
    self->mainPlayer = (Beater *)maintmp;
3754
3614
    
3755
 
    Py_INCREF(self->stream);
3756
3615
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
3757
3616
    
3758
3617
    (*self->mode_func_ptr)(self);
3759
 
        
3760
 
    Py_INCREF(self);
3761
 
    return 0;
 
3618
    
 
3619
    return (PyObject *)self;
3762
3620
}
3763
3621
 
3764
3622
static PyObject * BeatEndStream_getServer(BeatEndStream* self) { GET_SERVER };
3792
3650
static PyMethodDef BeatEndStream_methods[] = {
3793
3651
    {"getServer", (PyCFunction)BeatEndStream_getServer, METH_NOARGS, "Returns server object."},
3794
3652
    {"_getStream", (PyCFunction)BeatEndStream_getStream, METH_NOARGS, "Returns stream object."},
3795
 
    {"deleteStream", (PyCFunction)BeatEndStream_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
3796
3653
    {"play", (PyCFunction)BeatEndStream_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
3797
3654
    {"out", (PyCFunction)BeatEndStream_out, METH_VARARGS|METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."},
3798
3655
    {"stop", (PyCFunction)BeatEndStream_stop, METH_NOARGS, "Stops computing."},
3882
3739
    0,                         /* tp_descr_get */
3883
3740
    0,                         /* tp_descr_set */
3884
3741
    0,                         /* tp_dictoffset */
3885
 
    (initproc)BeatEndStream_init,      /* tp_init */
 
3742
    0,      /* tp_init */
3886
3743
    0,                         /* tp_alloc */
3887
3744
    BeatEndStream_new,                 /* tp_new */
3888
3745
};