← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/objects/delaymodule.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/delaymodule.c
301
301
static void
302
302
Delay_dealloc(Delay* self)
303
303
{
304
 
    free(self->data);
 
304
    pyo_DEALLOC
305
305
    free(self->buffer);
306
306
    Delay_clear(self);
307
307
    self->ob_type->tp_free((PyObject*)self);
308
308
}
309
309
 
310
 
static PyObject * Delay_deleteStream(Delay *self) { DELETE_STREAM };
311
 
 
312
310
static PyObject *
313
311
Delay_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
314
312
{
315
313
    int i;
 
314
    PyObject *inputtmp, *input_streamtmp, *delaytmp=NULL, *feedbacktmp=NULL, *multmp=NULL, *addtmp=NULL;
316
315
    Delay *self;
317
316
    self = (Delay *)type->tp_alloc(type, 0);
318
317
 
328
327
    INIT_OBJECT_COMMON
329
328
    Stream_setFunctionPtr(self->stream, Delay_compute_next_data_frame);
330
329
    self->mode_func_ptr = Delay_setProcMode;
331
 
    
332
 
    return (PyObject *)self;
333
 
}
334
330
 
335
 
static int
336
 
Delay_init(Delay *self, PyObject *args, PyObject *kwds)
337
 
{
338
 
    PyObject *inputtmp, *input_streamtmp, *delaytmp=NULL, *feedbacktmp=NULL, *multmp=NULL, *addtmp=NULL;
339
 
    int i;
340
 
    
341
331
    static char *kwlist[] = {"input", "delay", "feedback", "maxdelay", "mul", "add", NULL};
342
332
 
343
333
    if (! PyArg_ParseTupleAndKeywords(args, kwds, TYPE_O_OOFOO, kwlist, &inputtmp, &delaytmp, &feedbacktmp, &self->maxdelay, &multmp, &addtmp))
344
 
        return -1; 
 
334
        Py_RETURN_NONE;
345
335
 
346
336
    INIT_INPUT_STREAM
347
337
 
361
351
        PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
362
352
    }
363
353
            
364
 
    Py_INCREF(self->stream);
365
354
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
366
355
 
367
356
    self->size = (long)(self->maxdelay * self->sr + 0.5);
372
361
    }    
373
362
 
374
363
    (*self->mode_func_ptr)(self);
375
 
 
376
 
    Py_INCREF(self);
377
 
    return 0;
 
364
    
 
365
    return (PyObject *)self;
378
366
}
379
367
 
380
368
static PyObject * Delay_getServer(Delay* self) { GET_SERVER };
490
478
static PyMethodDef Delay_methods[] = {
491
479
    {"getServer", (PyCFunction)Delay_getServer, METH_NOARGS, "Returns server object."},
492
480
    {"_getStream", (PyCFunction)Delay_getStream, METH_NOARGS, "Returns stream object."},
493
 
    {"deleteStream", (PyCFunction)Delay_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
494
481
    {"play", (PyCFunction)Delay_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
495
482
    {"out", (PyCFunction)Delay_out, METH_VARARGS|METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."},
496
483
    {"stop", (PyCFunction)Delay_stop, METH_NOARGS, "Stops computing."},
583
570
    0,                         /* tp_descr_get */
584
571
    0,                         /* tp_descr_set */
585
572
    0,                         /* tp_dictoffset */
586
 
    (initproc)Delay_init,      /* tp_init */
 
573
    0,      /* tp_init */
587
574
    0,                         /* tp_alloc */
588
575
    Delay_new,                 /* tp_new */
589
576
};
758
745
static void
759
746
SDelay_dealloc(SDelay* self)
760
747
{
761
 
    free(self->data);
 
748
    pyo_DEALLOC
762
749
    free(self->buffer);
763
750
    SDelay_clear(self);
764
751
    self->ob_type->tp_free((PyObject*)self);
765
752
}
766
753
 
767
 
static PyObject * SDelay_deleteStream(SDelay *self) { DELETE_STREAM };
768
 
 
769
754
static PyObject *
770
755
SDelay_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
771
756
{
772
757
    int i;
 
758
    PyObject *inputtmp, *input_streamtmp, *delaytmp=NULL, *multmp=NULL, *addtmp=NULL;
773
759
    SDelay *self;
774
760
    self = (SDelay *)type->tp_alloc(type, 0);
775
761
    
783
769
    INIT_OBJECT_COMMON
784
770
    Stream_setFunctionPtr(self->stream, SDelay_compute_next_data_frame);
785
771
    self->mode_func_ptr = SDelay_setProcMode;
786
 
    
787
 
    return (PyObject *)self;
788
 
}
789
772
 
790
 
static int
791
 
SDelay_init(SDelay *self, PyObject *args, PyObject *kwds)
792
 
{
793
 
    PyObject *inputtmp, *input_streamtmp, *delaytmp=NULL, *multmp=NULL, *addtmp=NULL;
794
 
    int i;
795
 
    
796
773
    static char *kwlist[] = {"input", "delay", "maxdelay", "mul", "add", NULL};
797
774
    
798
775
    if (! PyArg_ParseTupleAndKeywords(args, kwds, TYPE_O_OFOO, kwlist, &inputtmp, &delaytmp, &self->maxdelay, &multmp, &addtmp))
799
 
        return -1; 
 
776
        Py_RETURN_NONE;
800
777
    
801
778
    INIT_INPUT_STREAM
802
779
    
812
789
        PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
813
790
    }
814
791
    
815
 
    Py_INCREF(self->stream);
816
792
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
817
793
    
818
794
    self->size = (long)(self->maxdelay * self->sr + 0.5);
823
799
    }    
824
800
    
825
801
    (*self->mode_func_ptr)(self);
826
 
    
827
 
    Py_INCREF(self);
828
 
    return 0;
 
802
 
 
803
    return (PyObject *)self;
829
804
}
830
805
 
831
806
static PyObject * SDelay_getServer(SDelay* self) { GET_SERVER };
906
881
static PyMethodDef SDelay_methods[] = {
907
882
    {"getServer", (PyCFunction)SDelay_getServer, METH_NOARGS, "Returns server object."},
908
883
    {"_getStream", (PyCFunction)SDelay_getStream, METH_NOARGS, "Returns stream object."},
909
 
    {"deleteStream", (PyCFunction)SDelay_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
910
884
    {"play", (PyCFunction)SDelay_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
911
885
    {"out", (PyCFunction)SDelay_out, METH_VARARGS|METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."},
912
886
    {"stop", (PyCFunction)SDelay_stop, METH_NOARGS, "Stops computing."},
998
972
    0,                         /* tp_descr_get */
999
973
    0,                         /* tp_descr_set */
1000
974
    0,                         /* tp_dictoffset */
1001
 
    (initproc)SDelay_init,      /* tp_init */
 
975
    0,      /* tp_init */
1002
976
    0,                         /* tp_alloc */
1003
977
    SDelay_new,                 /* tp_new */
1004
978
};
1055
1029
    /* lagrange coeffs and feedback coeff */
1056
1030
    if (fr != self->lastFreq) {
1057
1031
        self->lastFreq = fr;
1058
 
        sampdel = 1.0 / fr * self->sr - 0.5;
 
1032
        sampdel = self->sr / fr - 0.5;
1059
1033
        self->lastSampDel = sampdel;
1060
1034
        isamp = (int)sampdel;
1061
1035
        frac = sampdel - isamp;
1066
1040
        self->coeffs[4] = frac*(frac-1)*(frac-2)*(frac-3)/24.0;
1067
1041
        
1068
1042
        self->lastDur = dur;
1069
 
        feed = MYPOW(100, -(1.0/fr)/dur);
 
1043
        feed = MYPOW(100, -1.0/(fr*dur));
1070
1044
        self->lastFeed = feed;
1071
1045
    } 
1072
1046
    else if (dur != self->lastDur) {
1073
1047
        self->lastDur = dur;
1074
 
        feed = MYPOW(100, -(1.0/fr)/dur);
 
1048
        feed = MYPOW(100, -1.0/(fr*dur));
1075
1049
        self->lastFeed = feed;
1076
1050
    }
1077
1051
    
1139
1113
        /* lagrange coeffs and feedback coeff */
1140
1114
        if (freq != self->lastFreq) {
1141
1115
            self->lastFreq = freq;
1142
 
            sampdel = 1.0 / freq * self->sr - 0.5;
 
1116
            sampdel = self->sr / freq - 0.5;
1143
1117
            self->lastSampDel = sampdel;
1144
1118
            isamp = (int)sampdel;
1145
1119
            frac = sampdel - isamp;
1150
1124
            self->coeffs[4] = frac*(frac-1)*(frac-2)*(frac-3)/24.0;
1151
1125
            
1152
1126
            self->lastDur = dur;
1153
 
            feed = MYPOW(100, -(1.0/freq)/dur);
 
1127
            feed = MYPOW(100, -1.0/(freq*dur));
1154
1128
            self->lastFeed = feed;
1155
1129
        }
1156
1130
        else if (dur != self->lastDur) {
1157
1131
            self->lastDur = dur;
1158
 
            feed = MYPOW(100, -(1.0/freq)/dur);
 
1132
            feed = MYPOW(100, -1.0/(freq*dur));
1159
1133
            self->lastFeed = feed;
1160
1134
        }
1161
1135
 
1217
1191
    /* lagrange coeffs and feedback coeff */
1218
1192
    if (fr != self->lastFreq) {
1219
1193
        self->lastFreq = fr;
1220
 
        sampdel = 1.0 / fr * self->sr - 0.5;
 
1194
        sampdel = self->sr / fr - 0.5;
1221
1195
        self->lastSampDel = sampdel;
1222
1196
        isamp = (int)sampdel;
1223
1197
        frac = sampdel - isamp;
1237
1211
            dur = 0.1;
1238
1212
        if (dur != self->lastDur) {
1239
1213
            self->lastDur = dur;
1240
 
            feed = MYPOW(100, -(1.0/fr)/dur);
 
1214
            feed = MYPOW(100, -1.0/(fr*dur));
1241
1215
            self->lastFeed = feed;
1242
1216
        }
1243
1217
        ind = self->in_count - isamp;
1302
1276
        /* lagrange coeffs and feedback coeff */
1303
1277
        if (freq != self->lastFreq) {
1304
1278
            self->lastFreq = freq;
1305
 
            sampdel = 1.0 / freq * self->sr - 0.5;
 
1279
            sampdel = self->sr / freq - 0.5;
1306
1280
            self->lastSampDel = sampdel;
1307
1281
            isamp = (int)sampdel;
1308
1282
            frac = sampdel - isamp;
1313
1287
            self->coeffs[4] = frac*(frac-1)*(frac-2)*(frac-3)/24.0;
1314
1288
            
1315
1289
            self->lastDur = dur;
1316
 
            feed = MYPOW(100, -(1.0/freq)/dur);
 
1290
            feed = MYPOW(100, -1.0/(freq*dur));
1317
1291
            self->lastFeed = feed;
1318
1292
        }
1319
1293
        else if (dur != self->lastDur) {
1320
1294
            self->lastDur = dur;
1321
 
            feed = MYPOW(100, -(1.0/freq)/dur);
 
1295
            feed = MYPOW(100, -1.0/(freq*dur));
1322
1296
            self->lastFeed = feed;
1323
1297
        }
1324
1298
        
1458
1432
static void
1459
1433
Waveguide_dealloc(Waveguide* self)
1460
1434
{
1461
 
    free(self->data);
 
1435
    pyo_DEALLOC
1462
1436
    free(self->buffer);
1463
1437
    Waveguide_clear(self);
1464
1438
    self->ob_type->tp_free((PyObject*)self);
1465
1439
}
1466
1440
 
1467
 
static PyObject * Waveguide_deleteStream(Waveguide *self) { DELETE_STREAM };
1468
 
 
1469
1441
static PyObject *
1470
1442
Waveguide_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1471
1443
{
1472
1444
    int i;
 
1445
    PyObject *inputtmp, *input_streamtmp, *freqtmp=NULL, *durtmp=NULL, *multmp=NULL, *addtmp=NULL;
1473
1446
    Waveguide *self;
1474
1447
    self = (Waveguide *)type->tp_alloc(type, 0);
1475
1448
    
1498
1471
 
1499
1472
    Stream_setFunctionPtr(self->stream, Waveguide_compute_next_data_frame);
1500
1473
    self->mode_func_ptr = Waveguide_setProcMode;
1501
 
    
1502
 
    return (PyObject *)self;
1503
 
}
1504
1474
 
1505
 
static int
1506
 
Waveguide_init(Waveguide *self, PyObject *args, PyObject *kwds)
1507
 
{
1508
 
    PyObject *inputtmp, *input_streamtmp, *freqtmp=NULL, *durtmp=NULL, *multmp=NULL, *addtmp=NULL;
1509
 
    int i;
1510
 
    
1511
1475
    static char *kwlist[] = {"input", "freq", "dur", "minfreq", "mul", "add", NULL};
1512
1476
    
1513
1477
    if (! PyArg_ParseTupleAndKeywords(args, kwds, TYPE_O_OOFOO, kwlist, &inputtmp, &freqtmp, &durtmp, &self->minfreq, &multmp, &addtmp))
1514
 
        return -1; 
 
1478
        Py_RETURN_NONE;
1515
1479
    
1516
1480
    INIT_INPUT_STREAM
1517
1481
    
1531
1495
        PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
1532
1496
    }
1533
1497
    
1534
 
    Py_INCREF(self->stream);
1535
1498
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
1536
1499
    
1537
1500
    self->size = (long)(1.0 / self->minfreq * self->sr + 0.5);
1542
1505
    }    
1543
1506
    
1544
1507
    (*self->mode_func_ptr)(self);
1545
 
        
1546
 
    Py_INCREF(self);
1547
 
    return 0;
 
1508
    
 
1509
    return (PyObject *)self;
1548
1510
}
1549
1511
 
1550
1512
static PyObject * Waveguide_getServer(Waveguide* self) { GET_SERVER };
1649
1611
static PyMethodDef Waveguide_methods[] = {
1650
1612
{"getServer", (PyCFunction)Waveguide_getServer, METH_NOARGS, "Returns server object."},
1651
1613
{"_getStream", (PyCFunction)Waveguide_getStream, METH_NOARGS, "Returns stream object."},
1652
 
{"deleteStream", (PyCFunction)Waveguide_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
1653
1614
{"play", (PyCFunction)Waveguide_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
1654
1615
{"out", (PyCFunction)Waveguide_out, METH_VARARGS|METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."},
1655
1616
{"stop", (PyCFunction)Waveguide_stop, METH_NOARGS, "Stops computing."},
1741
1702
0,                         /* tp_descr_get */
1742
1703
0,                         /* tp_descr_set */
1743
1704
0,                         /* tp_dictoffset */
1744
 
(initproc)Waveguide_init,      /* tp_init */
 
1705
0,      /* tp_init */
1745
1706
0,                         /* tp_alloc */
1746
1707
Waveguide_new,                 /* tp_new */
1747
1708
};
1803
1764
    else if (detune > 1.0)
1804
1765
        detune = 1.0;
1805
1766
    
1806
 
    sampdel = 1.0 / (fr * freqshift) * self->sr;
 
1767
    sampdel = self->sr / (fr * freqshift);
1807
1768
    alpdetune = detune * self->alpsize;
1808
1769
 
1809
1770
    for (i=0; i<self->bufsize; i++) {
1881
1842
            fr = self->nyquist;
1882
1843
        
1883
1844
        /* pick a new value in the delay line */
1884
 
        sampdel = 1.0 / (fr * freqshift) * self->sr;
 
1845
        sampdel = self->sr / (fr * freqshift);
1885
1846
        xind = self->in_count - sampdel;
1886
1847
        if (xind < 0)
1887
1848
            xind += self->size;
1946
1907
    else if (detune > 1.0)
1947
1908
        detune = 1.0;
1948
1909
    
1949
 
    sampdel = 1.0 / (fr * freqshift) * self->sr;
 
1910
    sampdel = self->sr / (fr * freqshift);
1950
1911
    alpdetune = detune * self->alpsize;
1951
1912
    
1952
1913
    for (i=0; i<self->bufsize; i++) {
2029
1990
            feed = 0;
2030
1991
        
2031
1992
        /* pick a new value in the delay line */
2032
 
        sampdel = 1.0 / (fr * freqshift) * self->sr;
 
1993
        sampdel = self->sr / (fr * freqshift);
2033
1994
        xind = self->in_count - sampdel;
2034
1995
        if (xind < 0)
2035
1996
            xind += self->size;
2103
2064
            detune = 1.0;
2104
2065
        
2105
2066
        /* pick a new value in the delay line */
2106
 
        sampdel = 1.0 / (fr * freqshift) * self->sr;
 
2067
        sampdel = self->sr / (fr * freqshift);
2107
2068
        xind = self->in_count - sampdel;
2108
2069
        if (xind < 0)
2109
2070
            xind += self->size;
2178
2139
            detune = 1.0;
2179
2140
        
2180
2141
        /* pick a new value in the delay line */
2181
 
        sampdel = 1.0 / (fr * freqshift) * self->sr;
 
2142
        sampdel = self->sr / (fr * freqshift);
2182
2143
        xind = self->in_count - sampdel;
2183
2144
        if (xind < 0)
2184
2145
            xind += self->size;
2253
2214
            detune = 1.0;
2254
2215
        
2255
2216
        /* pick a new value in the delay line */
2256
 
        sampdel = 1.0 / (fr * freqshift) * self->sr;
 
2217
        sampdel = self->sr / (fr * freqshift);
2257
2218
        xind = self->in_count - sampdel;
2258
2219
        if (xind < 0)
2259
2220
            xind += self->size;
2327
2288
            detune = 1.0;
2328
2289
        
2329
2290
        /* pick a new value in the delay line */
2330
 
        sampdel = 1.0 / (fr * freqshift) * self->sr;
 
2291
        sampdel = self->sr / (fr * freqshift);
2331
2292
        xind = self->in_count - sampdel;
2332
2293
        if (xind < 0)
2333
2294
            xind += self->size;
2485
2446
AllpassWG_dealloc(AllpassWG* self)
2486
2447
{
2487
2448
    int i;
2488
 
    free(self->data);
 
2449
    pyo_DEALLOC
2489
2450
    free(self->buffer);
2490
2451
    for(i=0; i<3; i++) {
2491
2452
        free(self->alpbuffer[i]);
2494
2455
    self->ob_type->tp_free((PyObject*)self);
2495
2456
}
2496
2457
 
2497
 
static PyObject * AllpassWG_deleteStream(AllpassWG *self) { DELETE_STREAM };
2498
 
 
2499
2458
static PyObject *
2500
2459
AllpassWG_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2501
2460
{
2502
 
    int i;
 
2461
    int i, j;
 
2462
    PyObject *inputtmp, *input_streamtmp, *freqtmp=NULL, *feedtmp=NULL, *detunetmp=NULL, *multmp=NULL, *addtmp=NULL;
2503
2463
    AllpassWG *self;
2504
2464
    self = (AllpassWG *)type->tp_alloc(type, 0);
2505
2465
    
2522
2482
 
2523
2483
    Stream_setFunctionPtr(self->stream, AllpassWG_compute_next_data_frame);
2524
2484
    self->mode_func_ptr = AllpassWG_setProcMode;
2525
 
    
2526
 
    return (PyObject *)self;
2527
 
}
2528
2485
 
2529
 
static int
2530
 
AllpassWG_init(AllpassWG *self, PyObject *args, PyObject *kwds)
2531
 
{
2532
 
    PyObject *inputtmp, *input_streamtmp, *freqtmp=NULL, *feedtmp=NULL, *detunetmp=NULL, *multmp=NULL, *addtmp=NULL;
2533
 
    int i, j;
2534
 
    
2535
2486
    static char *kwlist[] = {"input", "freq", "feed", "detune", "minfreq", "mul", "add", NULL};
2536
2487
    
2537
2488
    if (! PyArg_ParseTupleAndKeywords(args, kwds, TYPE_O_OOOFOO, kwlist, &inputtmp, &freqtmp, &feedtmp, &detunetmp, &self->minfreq, &multmp, &addtmp))
2538
 
        return -1; 
 
2489
        Py_RETURN_NONE;
2539
2490
    
2540
2491
    INIT_INPUT_STREAM
2541
2492
    
2558
2509
        PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
2559
2510
    }
2560
2511
    
2561
 
    Py_INCREF(self->stream);
2562
2512
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
2563
2513
    
2564
2514
    self->size = (long)(1.0 / self->minfreq * self->sr + 0.5);    
2577
2527
    
2578
2528
    (*self->mode_func_ptr)(self);
2579
2529
    
2580
 
    Py_INCREF(self);
2581
 
    return 0;
 
2530
    return (PyObject *)self;
2582
2531
}
2583
2532
 
2584
2533
static PyObject * AllpassWG_getServer(AllpassWG* self) { GET_SERVER };
2718
2667
static PyMethodDef AllpassWG_methods[] = {
2719
2668
    {"getServer", (PyCFunction)AllpassWG_getServer, METH_NOARGS, "Returns server object."},
2720
2669
    {"_getStream", (PyCFunction)AllpassWG_getStream, METH_NOARGS, "Returns stream object."},
2721
 
    {"deleteStream", (PyCFunction)AllpassWG_deleteStream, METH_NOARGS, "Remove stream from server and delete the object."},
2722
2670
    {"play", (PyCFunction)AllpassWG_play, METH_VARARGS|METH_KEYWORDS, "Starts computing without sending sound to soundcard."},
2723
2671
    {"out", (PyCFunction)AllpassWG_out, METH_VARARGS|METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."},
2724
2672
    {"stop", (PyCFunction)AllpassWG_stop, METH_NOARGS, "Stops computing."},
2811
2759
    0,                         /* tp_descr_get */
2812
2760
    0,                         /* tp_descr_set */
2813
2761
    0,                         /* tp_dictoffset */
2814
 
    (initproc)AllpassWG_init,      /* tp_init */
 
2762
    0,      /* tp_init */
2815
2763
    0,                         /* tp_alloc */
2816
2764
    AllpassWG_new,                 /* tp_new */
2817
2765
};