← Back to branch summary

~ubuntu-branches/ubuntu/wily/python-pyo/wily-proposed

« back to all changes in this revision

Viewing changes to src/objects/lfomodule.c

  • Committer: Package Import Robot
  • Author(s): Tiago Bortoletto Vaz
  • Date: 2015-05-25 09:55:36 UTC
  • mfrom: (13.1.2 experimental)
  • Revision ID: package-import@ubuntu.com-20150525095536-haz5xfrxl6u3m085
Tags: 0.7.5-2
Minor packaging fixes and push to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/objects/lfomodule.c
1
 
/*************************************************************************
2
 
 * Copyright 2010 Olivier Belanger                                        *                  
3
 
 *                                                                        * 
 
1
/**************************************************************************
 
2
 * Copyright 2009-2015 Olivier Belanger                                   *
 
3
 *                                                                        *
4
4
 * This file is part of pyo, a python module to help digital signal       *
5
 
 * processing script creation.                                            *  
6
 
 *                                                                        * 
 
5
 * processing script creation.                                            *
 
6
 *                                                                        *
7
7
 * pyo is free software: you can redistribute it and/or modify            *
8
 
 * it under the terms of the GNU General Public License as published by   *
9
 
 * the Free Software Foundation, either version 3 of the License, or      *
10
 
 * (at your option) any later version.                                    * 
 
8
 * it under the terms of the GNU Lesser General Public License as         *
 
9
 * published by the Free Software Foundation, either version 3 of the     *
 
10
 * License, or (at your option) any later version.                        *
11
11
 *                                                                        *
12
12
 * pyo is distributed in the hope that it will be useful,                 *
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of         *    
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of         *
14
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
15
 
 * GNU General Public License for more details.                           *
 
15
 * GNU Lesser General Public License for more details.                    *
16
16
 *                                                                        *
17
 
 * You should have received a copy of the GNU General Public License      *
18
 
 * along with pyo.  If not, see <http://www.gnu.org/licenses/>.           *
 
17
 * You should have received a copy of the GNU Lesser General Public       *
 
18
 * License along with pyo.  If not, see <http://www.gnu.org/licenses/>.   *
19
19
 *************************************************************************/
20
20
 
21
21
#include <Python.h>
32
32
    Stream *freq_stream;
33
33
    PyObject *sharp;
34
34
    Stream *sharp_stream;
35
 
    int modebuffer[4]; // need at least 2 slots for mul & add 
 
35
    int modebuffer[4]; // need at least 2 slots for mul & add
36
36
    int wavetype;
37
37
    MYFLT oneOverPiOverTwo;
38
38
    MYFLT srOverFour;
66
66
            maxHarms = (int)(self->srOverFour/freq);
67
67
            numh = sharp * 46.0 + 4.0;
68
68
            if (numh > maxHarms)
69
 
                numh = maxHarms;   
 
69
                numh = maxHarms;
70
70
                for (i=0; i<self->bufsize; i++) {
71
71
                    pointer = self->pointerPos * 2.0 - 1.0;
72
72
                    val = pointer - MYTANH(numh * pointer) / MYTANH(numh);
75
75
                    if (self->pointerPos < 0)
76
76
                        self->pointerPos += 1.0;
77
77
                    else if (self->pointerPos >= 1)
78
 
                        self->pointerPos -= 1.0;        
79
 
                }            
 
78
                        self->pointerPos -= 1.0;
 
79
                }
80
80
            break;
81
81
        case 1: /* Saw down */
82
82
            maxHarms = (int)(self->srOverFour/freq);
83
83
            numh = sharp * 46.0 + 4.0;
84
84
            if (numh > maxHarms)
85
 
                numh = maxHarms;   
 
85
                numh = maxHarms;
86
86
                for (i=0; i<self->bufsize; i++) {
87
87
                    pointer = self->pointerPos * 2.0 - 1.0;
88
88
                    val = -(pointer - MYTANH(numh * pointer) / MYTANH(numh));
91
91
                    if (self->pointerPos < 0)
92
92
                        self->pointerPos += 1.0;
93
93
                    else if (self->pointerPos >= 1)
94
 
                        self->pointerPos -= 1.0;        
95
 
                }            
 
94
                        self->pointerPos -= 1.0;
 
95
                }
96
96
            break;
97
97
        case 2: /* Square */
98
98
            maxHarms = (int)(self->srOverEight/freq);
99
99
            numh = sharp * 46.0 + 4.0;
100
100
            if (numh > maxHarms)
101
 
                numh = maxHarms;    
 
101
                numh = maxHarms;
102
102
                for (i=0; i<self->bufsize; i++) {
103
103
                    val = MYATAN(numh * MYSIN(TWOPI*self->pointerPos));
104
104
                    self->data[i] = val * self->oneOverPiOverTwo;
106
106
                    if (self->pointerPos < 0)
107
107
                        self->pointerPos += 1.0;
108
108
                    else if (self->pointerPos >= 1)
109
 
                        self->pointerPos -= 1.0;        
110
 
                }            
 
109
                        self->pointerPos -= 1.0;
 
110
                }
111
111
            break;
112
112
        case 3: /* Triangle */
113
113
            maxHarms = (int)(self->srOverFour/freq);
114
114
            if ((sharp * 36.0) > maxHarms)
115
115
                numh = (MYFLT)(maxHarms / 36.0);
116
116
            else
117
 
                numh = sharp;    
 
117
                numh = sharp;
118
118
            for (i=0; i<self->bufsize; i++) {
119
119
                v1 = MYTAN(MYSIN(TWOPI*self->pointerPos));
120
120
                pointer = self->pointerPos + 0.25;
127
127
                if (self->pointerPos < 0)
128
128
                    self->pointerPos += 1.0;
129
129
                else if (self->pointerPos >= 1)
130
 
                    self->pointerPos -= 1.0;        
131
 
            }            
 
130
                    self->pointerPos -= 1.0;
 
131
            }
132
132
            break;
133
133
        case 4: /* Pulse */
134
134
            maxHarms = (int)(self->srOverEight/freq);
144
144
                if (self->pointerPos < 0)
145
145
                    self->pointerPos += 1.0;
146
146
                else if (self->pointerPos >= 1)
147
 
                    self->pointerPos -= 1.0;        
148
 
            }            
 
147
                    self->pointerPos -= 1.0;
 
148
            }
149
149
            break;
150
150
        case 5: /* Bi-Pulse */
151
151
            maxHarms = (int)(self->srOverEight/freq);
152
152
            numh = MYFLOOR(sharp * 46.0 + 4.0);
153
153
            if (numh > maxHarms)
154
 
                numh = maxHarms;    
 
154
                numh = maxHarms;
155
155
            if (MYFMOD(numh, 2.0) == 0.0)
156
156
                numh += 1.0;
157
157
            for (i=0; i<self->bufsize; i++) {
161
161
                if (self->pointerPos < 0)
162
162
                    self->pointerPos += 1.0;
163
163
                else if (self->pointerPos >= 1)
164
 
                    self->pointerPos -= 1.0;        
165
 
            }            
 
164
                    self->pointerPos -= 1.0;
 
165
            }
166
166
            break;
167
167
        case 6: /* SAH */
168
168
            numh = 1.0 - sharp;
186
186
                    val = self->sahCurrentValue;
187
187
                }
188
188
                self->data[i] = val;
189
 
            }            
 
189
            }
190
190
            break;
191
191
        case 7: /* Sine-mod */
192
192
            inc2 = inc * sharp;
203
203
                    self->pointerPos += 1.0;
204
204
                else if (self->pointerPos >= 1)
205
205
                    self->pointerPos -= 1.0;
206
 
            }            
 
206
            }
207
207
            break;
208
208
        default:
209
209
            break;
215
215
    MYFLT val, inc, freq, sharp, pointer, numh;
216
216
    MYFLT v1, v2, inc2, fade;
217
217
    int i, maxHarms;
218
 
    
 
218
 
219
219
    MYFLT *fr = Stream_getData((Stream *)self->freq_stream);
220
220
    if (fr[0] <= 0) {
221
221
        return;
225
225
        sharp = 0.0;
226
226
    else if (sharp > 1.0)
227
227
        sharp = 1.0;
228
 
    
 
228
 
229
229
    switch (self->wavetype) {
230
230
        case 0: /* Saw up */
231
231
            for (i=0; i<self->bufsize; i++) {
234
234
                maxHarms = (int)(self->srOverFour/freq);
235
235
                numh = sharp * 46.0 + 4.0;
236
236
                if (numh > maxHarms)
237
 
                    numh = maxHarms;   
 
237
                    numh = maxHarms;
238
238
                pointer = self->pointerPos * 2.0 - 1.0;
239
239
                val = pointer - MYTANH(numh * pointer) / MYTANH(numh);
240
240
                self->data[i] = val;
242
242
                if (self->pointerPos < 0)
243
243
                    self->pointerPos += 1.0;
244
244
                else if (self->pointerPos >= 1)
245
 
                    self->pointerPos -= 1.0;        
246
 
            }            
 
245
                    self->pointerPos -= 1.0;
 
246
            }
247
247
            break;
248
248
        case 1: /* Saw down */
249
249
            for (i=0; i<self->bufsize; i++) {
252
252
                maxHarms = (int)(self->srOverFour/freq);
253
253
                numh = sharp * 46.0 + 4.0;
254
254
                if (numh > maxHarms)
255
 
                    numh = maxHarms;   
 
255
                    numh = maxHarms;
256
256
                pointer = self->pointerPos * 2.0 - 1.0;
257
257
                val = -(pointer - MYTANH(numh * pointer) / MYTANH(numh));
258
258
                self->data[i] = val;
260
260
                if (self->pointerPos < 0)
261
261
                    self->pointerPos += 1.0;
262
262
                else if (self->pointerPos >= 1)
263
 
                    self->pointerPos -= 1.0;        
264
 
            }            
 
263
                    self->pointerPos -= 1.0;
 
264
            }
265
265
            break;
266
266
        case 2: /* Square */
267
267
            for (i=0; i<self->bufsize; i++) {
270
270
                maxHarms = (int)(self->srOverEight/freq);
271
271
                numh = sharp * 46.0 + 4.0;
272
272
                if (numh > maxHarms)
273
 
                    numh = maxHarms;    
 
273
                    numh = maxHarms;
274
274
                val = MYATAN(numh * MYSIN(TWOPI*self->pointerPos));
275
275
                self->data[i] = val * self->oneOverPiOverTwo;
276
276
                self->pointerPos += inc;
277
277
                if (self->pointerPos < 0)
278
278
                    self->pointerPos += 1.0;
279
279
                else if (self->pointerPos >= 1)
280
 
                    self->pointerPos -= 1.0;        
281
 
            }            
 
280
                    self->pointerPos -= 1.0;
 
281
            }
282
282
            break;
283
283
        case 3: /* Triangle */
284
284
            for (i=0; i<self->bufsize; i++) {
288
288
                if ((sharp * 36.0) > maxHarms)
289
289
                    numh = (MYFLT)(maxHarms / 36.0);
290
290
                else
291
 
                    numh = sharp;    
 
291
                    numh = sharp;
292
292
                v1 = MYTAN(MYSIN(TWOPI*self->pointerPos));
293
293
                pointer = self->pointerPos + 0.25;
294
294
                if (pointer > 1.0)
300
300
                if (self->pointerPos < 0)
301
301
                    self->pointerPos += 1.0;
302
302
                else if (self->pointerPos >= 1)
303
 
                    self->pointerPos -= 1.0;        
304
 
            }            
 
303
                    self->pointerPos -= 1.0;
 
304
            }
305
305
            break;
306
306
        case 4: /* Pulse */
307
307
            for (i=0; i<self->bufsize; i++) {
319
319
                if (self->pointerPos < 0)
320
320
                    self->pointerPos += 1.0;
321
321
                else if (self->pointerPos >= 1)
322
 
                    self->pointerPos -= 1.0;        
323
 
            }            
 
322
                    self->pointerPos -= 1.0;
 
323
            }
324
324
            break;
325
325
        case 5: /* Bi-Pulse */
326
326
            for (i=0; i<self->bufsize; i++) {
329
329
                maxHarms = (int)(self->srOverEight/freq);
330
330
                numh = MYFLOOR(sharp * 46.0 + 4.0);
331
331
                if (numh > maxHarms)
332
 
                    numh = maxHarms;    
 
332
                    numh = maxHarms;
333
333
                if (MYFMOD(numh, 2.0) == 0.0)
334
334
                    numh += 1.0;
335
335
                val = MYTAN(MYPOW(MYSIN(TWOPI*self->pointerPos), numh));
338
338
                if (self->pointerPos < 0)
339
339
                    self->pointerPos += 1.0;
340
340
                else if (self->pointerPos >= 1)
341
 
                    self->pointerPos -= 1.0;        
342
 
            }            
 
341
                    self->pointerPos -= 1.0;
 
342
            }
343
343
            break;
344
344
        case 6: /* SAH */
345
345
            numh = 1.0 - sharp;
365
365
                    val = self->sahCurrentValue;
366
366
                }
367
367
                self->data[i] = val;
368
 
            }            
 
368
            }
369
369
            break;
370
370
        case 7: /* Sine-mod */
371
371
            for (i=0; i<self->bufsize; i++) {
384
384
                    self->pointerPos += 1.0;
385
385
                else if (self->pointerPos >= 1)
386
386
                    self->pointerPos -= 1.0;
387
 
            }            
 
387
            }
388
388
            break;
389
389
        default:
390
390
            break;
391
 
    }    
 
391
    }
392
392
}
393
393
 
394
394
static void
396
396
    MYFLT val, inc, freq, sharp, pointer, numh;
397
397
    MYFLT v1, v2, inc2, fade;
398
398
    int i, maxHarms;
399
 
    
 
399
 
400
400
    freq = PyFloat_AS_DOUBLE(self->freq);
401
401
    if (freq <= 0) {
402
402
        return;
403
403
    }
404
404
    MYFLT *sh = Stream_getData((Stream *)self->sharp_stream);
405
405
    inc = freq / self->sr;
406
 
    
 
406
 
407
407
    switch (self->wavetype) {
408
408
        case 0: /* Saw up */
409
409
            maxHarms = (int)(self->srOverFour/freq);
415
415
                    sharp = 1.0;
416
416
                numh = sharp * 46.0 + 4.0;
417
417
                if (numh > maxHarms)
418
 
                    numh = maxHarms;   
 
418
                    numh = maxHarms;
419
419
                pointer = self->pointerPos * 2.0 - 1.0;
420
420
                val = pointer - MYTANH(numh * pointer) / MYTANH(numh);
421
421
                self->data[i] = val;
423
423
                if (self->pointerPos < 0)
424
424
                    self->pointerPos += 1.0;
425
425
                else if (self->pointerPos >= 1)
426
 
                    self->pointerPos -= 1.0;        
427
 
            }            
 
426
                    self->pointerPos -= 1.0;
 
427
            }
428
428
            break;
429
429
        case 1: /* Saw down */
430
430
            maxHarms = (int)(self->srOverFour/freq);
436
436
                    sharp = 1.0;
437
437
                numh = sharp * 46.0 + 4.0;
438
438
                if (numh > maxHarms)
439
 
                    numh = maxHarms;   
 
439
                    numh = maxHarms;
440
440
                pointer = self->pointerPos * 2.0 - 1.0;
441
441
                val = -(pointer - MYTANH(numh * pointer) / MYTANH(numh));
442
442
                self->data[i] = val;
444
444
                if (self->pointerPos < 0)
445
445
                    self->pointerPos += 1.0;
446
446
                else if (self->pointerPos >= 1)
447
 
                    self->pointerPos -= 1.0;        
448
 
            }            
 
447
                    self->pointerPos -= 1.0;
 
448
            }
449
449
            break;
450
450
        case 2: /* Square */
451
451
            maxHarms = (int)(self->srOverEight/freq);
457
457
                    sharp = 1.0;
458
458
                numh = sharp * 46.0 + 4.0;
459
459
                if (numh > maxHarms)
460
 
                    numh = maxHarms;   
 
460
                    numh = maxHarms;
461
461
                val = MYATAN(numh * MYSIN(TWOPI*self->pointerPos));
462
462
                self->data[i] = val * self->oneOverPiOverTwo;
463
463
                self->pointerPos += inc;
464
464
                if (self->pointerPos < 0)
465
465
                    self->pointerPos += 1.0;
466
466
                else if (self->pointerPos >= 1)
467
 
                    self->pointerPos -= 1.0;        
468
 
            }            
 
467
                    self->pointerPos -= 1.0;
 
468
            }
469
469
            break;
470
470
        case 3: /* Triangle */
471
471
            maxHarms = (int)(self->srOverFour/freq);
478
478
                if ((sharp * 36.0) > maxHarms)
479
479
                    numh = (MYFLT)(maxHarms / 36.0);
480
480
                else
481
 
                    numh = sharp;    
 
481
                    numh = sharp;
482
482
                v1 = MYTAN(MYSIN(TWOPI*self->pointerPos));
483
483
                pointer = self->pointerPos + 0.25;
484
484
                if (pointer > 1.0)
490
490
                if (self->pointerPos < 0)
491
491
                    self->pointerPos += 1.0;
492
492
                else if (self->pointerPos >= 1)
493
 
                    self->pointerPos -= 1.0;        
494
 
            }            
 
493
                    self->pointerPos -= 1.0;
 
494
            }
495
495
            break;
496
496
        case 4: /* Pulse */
497
497
            maxHarms = (int)(self->srOverEight/freq);
512
512
                if (self->pointerPos < 0)
513
513
                    self->pointerPos += 1.0;
514
514
                else if (self->pointerPos >= 1)
515
 
                    self->pointerPos -= 1.0;        
516
 
            }            
 
515
                    self->pointerPos -= 1.0;
 
516
            }
517
517
            break;
518
518
        case 5: /* Bi-Pulse */
519
519
            maxHarms = (int)(self->srOverEight/freq);
534
534
                if (self->pointerPos < 0)
535
535
                    self->pointerPos += 1.0;
536
536
                else if (self->pointerPos >= 1)
537
 
                    self->pointerPos -= 1.0;        
538
 
            }            
 
537
                    self->pointerPos -= 1.0;
 
538
            }
539
539
            break;
540
540
        case 6: /* SAH */
541
541
            for (i=0; i<self->bufsize; i++) {
564
564
                    val = self->sahCurrentValue;
565
565
                }
566
566
                self->data[i] = val;
567
 
            }            
 
567
            }
568
568
            break;
569
569
        case 7: /* Sine-mod */
570
570
            for (i=0; i<self->bufsize; i++) {
586
586
                    self->pointerPos += 1.0;
587
587
                else if (self->pointerPos >= 1)
588
588
                    self->pointerPos -= 1.0;
589
 
            }            
 
589
            }
590
590
            break;
591
591
        default:
592
592
            break;
598
598
    MYFLT val, inc, freq, sharp, pointer, numh;
599
599
    MYFLT v1, v2, inc2, fade;
600
600
    int i, maxHarms;
601
 
    
 
601
 
602
602
    MYFLT *fr = Stream_getData((Stream *)self->freq_stream);
603
603
    if (fr[0] <= 0) {
604
604
        return;
605
605
    }
606
606
    MYFLT *sh = Stream_getData((Stream *)self->sharp_stream);
607
 
    
 
607
 
608
608
    switch (self->wavetype) {
609
609
        case 0: /* Saw up */
610
610
            for (i=0; i<self->bufsize; i++) {
618
618
                maxHarms = (int)(self->srOverFour/freq);
619
619
                numh = sharp * 46.0 + 4.0;
620
620
                if (numh > maxHarms)
621
 
                    numh = maxHarms;   
 
621
                    numh = maxHarms;
622
622
                pointer = self->pointerPos * 2.0 - 1.0;
623
623
                val = pointer - MYTANH(numh * pointer) / MYTANH(numh);
624
624
                self->data[i] = val;
626
626
                if (self->pointerPos < 0)
627
627
                    self->pointerPos += 1.0;
628
628
                else if (self->pointerPos >= 1)
629
 
                    self->pointerPos -= 1.0;        
630
 
            }            
 
629
                    self->pointerPos -= 1.0;
 
630
            }
631
631
            break;
632
632
        case 1: /* Saw down */
633
633
            for (i=0; i<self->bufsize; i++) {
641
641
                maxHarms = (int)(self->srOverFour/freq);
642
642
                numh = sharp * 46.0 + 4.0;
643
643
                if (numh > maxHarms)
644
 
                    numh = maxHarms;   
 
644
                    numh = maxHarms;
645
645
                pointer = self->pointerPos * 2.0 - 1.0;
646
646
                val = -(pointer - MYTANH(numh * pointer) / MYTANH(numh));
647
647
                self->data[i] = val;
649
649
                if (self->pointerPos < 0)
650
650
                    self->pointerPos += 1.0;
651
651
                else if (self->pointerPos >= 1)
652
 
                    self->pointerPos -= 1.0;        
653
 
            }            
 
652
                    self->pointerPos -= 1.0;
 
653
            }
654
654
            break;
655
655
        case 2: /* Square */
656
656
            for (i=0; i<self->bufsize; i++) {
664
664
                maxHarms = (int)(self->srOverEight/freq);
665
665
                numh = sharp * 46.0 + 4.0;
666
666
                if (numh > maxHarms)
667
 
                    numh = maxHarms;    
 
667
                    numh = maxHarms;
668
668
                val = MYATAN(numh * MYSIN(TWOPI*self->pointerPos));
669
669
                self->data[i] = val * self->oneOverPiOverTwo;
670
670
                self->pointerPos += inc;
671
671
                if (self->pointerPos < 0)
672
672
                    self->pointerPos += 1.0;
673
673
                else if (self->pointerPos >= 1)
674
 
                    self->pointerPos -= 1.0;        
675
 
            }            
 
674
                    self->pointerPos -= 1.0;
 
675
            }
676
676
            break;
677
677
        case 3: /* Triangle */
678
678
            for (i=0; i<self->bufsize; i++) {
687
687
                if ((sharp * 36.0) > maxHarms)
688
688
                    numh = (MYFLT)(maxHarms / 36.0);
689
689
                else
690
 
                    numh = sharp;    
 
690
                    numh = sharp;
691
691
                v1 = MYTAN(MYSIN(TWOPI*self->pointerPos));
692
692
                pointer = self->pointerPos + 0.25;
693
693
                if (pointer > 1.0)
699
699
                if (self->pointerPos < 0)
700
700
                    self->pointerPos += 1.0;
701
701
                else if (self->pointerPos >= 1)
702
 
                    self->pointerPos -= 1.0;        
703
 
            }            
 
702
                    self->pointerPos -= 1.0;
 
703
            }
704
704
            break;
705
705
        case 4: /* Pulse */
706
706
            for (i=0; i<self->bufsize; i++) {
723
723
                if (self->pointerPos < 0)
724
724
                    self->pointerPos += 1.0;
725
725
                else if (self->pointerPos >= 1)
726
 
                    self->pointerPos -= 1.0;        
727
 
            }            
 
726
                    self->pointerPos -= 1.0;
 
727
            }
728
728
            break;
729
729
        case 5: /* Bi-Pulse */
730
730
            for (i=0; i<self->bufsize; i++) {
738
738
                maxHarms = (int)(self->srOverEight/freq);
739
739
                numh = MYFLOOR(sharp * 46.0 + 4.0);
740
740
                if (numh > maxHarms)
741
 
                    numh = maxHarms;    
 
741
                    numh = maxHarms;
742
742
                if (MYFMOD(numh, 2.0) == 0.0)
743
743
                    numh += 1.0;
744
744
                val = MYTAN(MYPOW(MYSIN(TWOPI*self->pointerPos), numh));
747
747
                if (self->pointerPos < 0)
748
748
                    self->pointerPos += 1.0;
749
749
                else if (self->pointerPos >= 1)
750
 
                    self->pointerPos -= 1.0;        
751
 
            }            
 
750
                    self->pointerPos -= 1.0;
 
751
            }
752
752
            break;
753
753
        case 6: /* SAH */
754
754
            for (i=0; i<self->bufsize; i++) {
779
779
                    val = self->sahCurrentValue;
780
780
                }
781
781
                self->data[i] = val;
782
 
            }            
 
782
            }
783
783
            break;
784
784
        case 7: /* Sine-mod */
785
785
            for (i=0; i<self->bufsize; i++) {
803
803
                    self->pointerPos += 1.0;
804
804
                else if (self->pointerPos >= 1)
805
805
                    self->pointerPos -= 1.0;
806
 
            }            
 
806
            }
807
807
            break;
808
808
        default:
809
809
            break;
826
826
    int procmode, muladdmode;
827
827
    procmode = self->modebuffer[2] + self->modebuffer[3] * 10;
828
828
    muladdmode = self->modebuffer[0] + self->modebuffer[1] * 10;
829
 
    
 
829
 
830
830
        switch (procmode) {
831
 
        case 0:    
 
831
        case 0:
832
832
            self->proc_func_ptr = LFO_generates_ii;
833
833
            break;
834
 
        case 1:    
 
834
        case 1:
835
835
            self->proc_func_ptr = LFO_generates_ai;
836
836
            break;
837
 
        case 10:        
 
837
        case 10:
838
838
            self->proc_func_ptr = LFO_generates_ia;
839
839
            break;
840
 
        case 11:    
 
840
        case 11:
841
841
            self->proc_func_ptr = LFO_generates_aa;
842
842
            break;
843
 
    } 
 
843
    }
844
844
        switch (muladdmode) {
845
 
        case 0:        
 
845
        case 0:
846
846
            self->muladd_func_ptr = LFO_postprocessing_ii;
847
847
            break;
848
 
        case 1:    
 
848
        case 1:
849
849
            self->muladd_func_ptr = LFO_postprocessing_ai;
850
850
            break;
851
 
        case 2:    
 
851
        case 2:
852
852
            self->muladd_func_ptr = LFO_postprocessing_revai;
853
853
            break;
854
 
        case 10:        
 
854
        case 10:
855
855
            self->muladd_func_ptr = LFO_postprocessing_ia;
856
856
            break;
857
 
        case 11:    
 
857
        case 11:
858
858
            self->muladd_func_ptr = LFO_postprocessing_aa;
859
859
            break;
860
 
        case 12:    
 
860
        case 12:
861
861
            self->muladd_func_ptr = LFO_postprocessing_revaa;
862
862
            break;
863
 
        case 20:        
 
863
        case 20:
864
864
            self->muladd_func_ptr = LFO_postprocessing_ireva;
865
865
            break;
866
 
        case 21:    
 
866
        case 21:
867
867
            self->muladd_func_ptr = LFO_postprocessing_areva;
868
868
            break;
869
 
        case 22:    
 
869
        case 22:
870
870
            self->muladd_func_ptr = LFO_postprocessing_revareva;
871
871
            break;
872
 
    }   
 
872
    }
873
873
}
874
874
 
875
875
static void
876
876
LFO_compute_next_data_frame(LFO *self)
877
877
{
878
 
    (*self->proc_func_ptr)(self); 
 
878
    (*self->proc_func_ptr)(self);
879
879
    (*self->muladd_func_ptr)(self);
880
880
}
881
881
 
883
883
LFO_traverse(LFO *self, visitproc visit, void *arg)
884
884
{
885
885
    pyo_VISIT
886
 
    Py_VISIT(self->freq);    
887
 
    Py_VISIT(self->freq_stream);    
888
 
    Py_VISIT(self->sharp);    
889
 
    Py_VISIT(self->sharp_stream);    
 
886
    Py_VISIT(self->freq);
 
887
    Py_VISIT(self->freq_stream);
 
888
    Py_VISIT(self->sharp);
 
889
    Py_VISIT(self->sharp_stream);
890
890
    return 0;
891
891
}
892
892
 
893
 
static int 
 
893
static int
894
894
LFO_clear(LFO *self)
895
895
{
896
896
    pyo_CLEAR
897
 
    Py_CLEAR(self->freq);    
898
 
    Py_CLEAR(self->freq_stream);    
899
 
    Py_CLEAR(self->sharp);    
900
 
    Py_CLEAR(self->sharp_stream);    
 
897
    Py_CLEAR(self->freq);
 
898
    Py_CLEAR(self->freq_stream);
 
899
    Py_CLEAR(self->sharp);
 
900
    Py_CLEAR(self->sharp_stream);
901
901
    return 0;
902
902
}
903
903
 
916
916
    PyObject *freqtmp=NULL, *sharptmp=NULL, *multmp=NULL, *addtmp=NULL;
917
917
    LFO *self;
918
918
    self = (LFO *)type->tp_alloc(type, 0);
919
 
        
 
919
 
920
920
    self->freq = PyFloat_FromDouble(100);
921
921
    self->sharp = PyFloat_FromDouble(0.5);
922
922
    self->oneOverPiOverTwo = 1.0 / (PI / 2.0);
930
930
        self->modebuffer[3] = 0;
931
931
 
932
932
    INIT_OBJECT_COMMON
933
 
    
 
933
 
934
934
    self->srOverFour = (MYFLT)self->sr * 0.25;
935
935
    self->srOverEight = (MYFLT)self->sr * 0.125;
936
936
    Stream_setFunctionPtr(self->stream, LFO_compute_next_data_frame);
948
948
    if (sharptmp) {
949
949
        PyObject_CallMethod((PyObject *)self, "setSharp", "O", sharptmp);
950
950
    }
951
 
    
 
951
 
952
952
    if (multmp) {
953
953
        PyObject_CallMethod((PyObject *)self, "setMul", "O", multmp);
954
954
    }
956
956
    if (addtmp) {
957
957
        PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp);
958
958
    }
959
 
            
 
959
 
960
960
    PyObject_CallMethod(self->server, "addStream", "O", self->stream);
961
961
 
962
962
    Server_generateSeed((Server *)self->server, LFO_ID);
963
963
 
964
964
    self->sahCurrentValue = self->sahLastValue = rand()/((MYFLT)(RAND_MAX)*0.5) - 1.0;
965
 
    
 
965
 
966
966
    (*self->mode_func_ptr)(self);
967
967
 
968
968
    return (PyObject *)self;
970
970
 
971
971
static PyObject * LFO_getServer(LFO* self) { GET_SERVER };
972
972
static PyObject * LFO_getStream(LFO* self) { GET_STREAM };
973
 
static PyObject * LFO_setMul(LFO *self, PyObject *arg) { SET_MUL };     
974
 
static PyObject * LFO_setAdd(LFO *self, PyObject *arg) { SET_ADD };     
975
 
static PyObject * LFO_setSub(LFO *self, PyObject *arg) { SET_SUB };     
976
 
static PyObject * LFO_setDiv(LFO *self, PyObject *arg) { SET_DIV };     
 
973
static PyObject * LFO_setMul(LFO *self, PyObject *arg) { SET_MUL };
 
974
static PyObject * LFO_setAdd(LFO *self, PyObject *arg) { SET_ADD };
 
975
static PyObject * LFO_setSub(LFO *self, PyObject *arg) { SET_SUB };
 
976
static PyObject * LFO_setDiv(LFO *self, PyObject *arg) { SET_DIV };
977
977
 
978
978
static PyObject * LFO_play(LFO *self, PyObject *args, PyObject *kwds) { PLAY };
979
979
static PyObject * LFO_out(LFO *self, PyObject *args, PyObject *kwds) { OUT };
992
992
LFO_setFreq(LFO *self, PyObject *arg)
993
993
{
994
994
        PyObject *tmp, *streamtmp;
995
 
        
 
995
 
996
996
        if (arg == NULL) {
997
997
                Py_INCREF(Py_None);
998
998
                return Py_None;
999
999
        }
1000
 
    
 
1000
 
1001
1001
        int isNumber = PyNumber_Check(arg);
1002
 
        
 
1002
 
1003
1003
        tmp = arg;
1004
1004
        Py_INCREF(tmp);
1005
1005
        Py_DECREF(self->freq);
1015
1015
        self->freq_stream = (Stream *)streamtmp;
1016
1016
                self->modebuffer[2] = 1;
1017
1017
        }
1018
 
    
 
1018
 
1019
1019
    (*self->mode_func_ptr)(self);
1020
 
    
 
1020
 
1021
1021
        Py_INCREF(Py_None);
1022
1022
        return Py_None;
1023
 
}       
 
1023
}
1024
1024
 
1025
1025
static PyObject *
1026
1026
LFO_setSharp(LFO *self, PyObject *arg)
1027
1027
{
1028
1028
        PyObject *tmp, *streamtmp;
1029
 
        
 
1029
 
1030
1030
        if (arg == NULL) {
1031
1031
                Py_INCREF(Py_None);
1032
1032
                return Py_None;
1033
1033
        }
1034
 
    
 
1034
 
1035
1035
        int isNumber = PyNumber_Check(arg);
1036
 
        
 
1036
 
1037
1037
        tmp = arg;
1038
1038
        Py_INCREF(tmp);
1039
1039
        Py_DECREF(self->sharp);
1049
1049
        self->sharp_stream = (Stream *)streamtmp;
1050
1050
                self->modebuffer[3] = 1;
1051
1051
        }
1052
 
    
 
1052
 
1053
1053
    (*self->mode_func_ptr)(self);
1054
 
    
 
1054
 
1055
1055
        Py_INCREF(Py_None);
1056
1056
        return Py_None;
1057
 
}       
 
1057
}
1058
1058
 
1059
1059
static PyObject *
1060
1060
LFO_setType(LFO *self, PyObject *arg)
1061
1061
{
1062
1062
    int tmp;
1063
 
        
 
1063
 
1064
1064
        if (arg == NULL) {
1065
1065
                Py_INCREF(Py_None);
1066
1066
                return Py_None;
1067
1067
        }
1068
 
        
 
1068
 
1069
1069
        int isInt = PyInt_Check(arg);
1070
 
    
 
1070
 
1071
1071
        if (isInt == 1) {
1072
1072
                tmp = PyInt_AsLong(arg);
1073
1073
        if (tmp >= 0 && tmp < 8)
1075
1075
        }
1076
1076
 
1077
1077
    (*self->mode_func_ptr)(self);
1078
 
    
 
1078
 
1079
1079
        Py_INCREF(Py_None);
1080
1080
        return Py_None;
1081
 
}       
 
1081
}
1082
1082
 
1083
 
static PyObject * 
1084
 
LFO_reset(LFO *self) 
 
1083
static PyObject *
 
1084
LFO_reset(LFO *self)
1085
1085
{
1086
1086
    self->pointerPos = 0.0;
1087
1087
    self->sahPointerPos = 0.0;
1199
1199
    0,                          /* tp_init */
1200
1200
    0,                                              /* tp_alloc */
1201
1201
    LFO_new,                                     /* tp_new */
1202
 
};
 
1202
};
 
 
b'\\ No newline at end of file'