?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
FFT: Prevent user from attempting hops smaller than SC's block size
[supercollider.git] / server / plugins / NoiseUGens.cpp
blobaad6bc5c5422cd7ab67c90801196443907851be0
1 /*
2 SuperCollider real time audio synthesis system
3 Copyright (c) 2002 James McCartney. All rights reserved.
4 http://www.audiosynth.com
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21
22 #include "SC_PlugIn.h"
23
24 static InterfaceTable *ft;
25
26 struct WhiteNoise : public Unit
27 {
28 };
29
30 struct ClipNoise : public Unit
31 {
32 };
33
34 struct BrownNoise : public Unit
35 {
36 float mLevel;
37 };
38
39 struct PinkNoise : public Unit
40 {
41 uint32 mDice[16];
42 int32 mTotal;
43 };
44
45 struct Dust : public Unit
46 {
47 float m_density, m_thresh, m_scale;
48 };
49
50 struct Dust2 : public Unit
51 {
52 float m_density, m_thresh, m_scale;
53 };
54
55 struct GrayNoise : public Unit
56 {
57 int32 mCounter;
58 };
59
60 struct Crackle : public Unit
61 {
62 double m_y1, m_y2;
63 };
64
65 struct Logistic : public Unit
66 {
67 double m_y1;
68 int mCounter;
69 };
70
71 struct Hasher : public Unit
72 {
73 };
74
75 struct MantissaMask : public Unit
76 {
77 };
78
79 struct IRand : public Unit
80 {
81 };
82
83 struct Rand : public Unit
84 {
85 };
86
87 struct TRand : public Unit
88 {
89 float m_trig, m_value;
90 };
91
92 struct TIRand : public Unit
93 {
94 float m_trig, m_value;
95 };
96
97 struct TExpRand : public Unit
98 {
99 float m_trig, m_value;
100 };
101
102 struct NRand : public Unit
103 {
104 };
105
106 struct LinRand : public Unit
107 {
108 };
109
110 struct ExpRand : public Unit
111 {
112 };
113
114 struct CoinGate : public Unit
115 {
116 float m_trig;
117 };
118
119 struct LFClipNoise : public Unit
120 {
121 float mLevel;
122 int mCounter;
123 };
124
125 struct LFNoise0 : public Unit
126 {
127 float mLevel;
128 int mCounter;
129 };
130
131 struct LFNoise1 : public Unit
132 {
133 float mLevel, mSlope;
134 int mCounter;
135 };
136
137 struct LFNoise2 : public Unit
138 {
139 float mLevel, mSlope, mCurve;
140 float m_nextvalue, m_nextmidpt;
141 int mCounter;
142 };
143
144 struct RandSeed : public Unit
145 {
146 float m_trig;
147 };
148
149 struct RandID : public Unit
150 {
151 float m_id;
152 };
153
154 //////////////////////////////////////////////////////////////////////////////////////////////////
155
156
157 extern "C"
158 {
159 void WhiteNoise_next(WhiteNoise *unit, int inNumSamples);
160 void WhiteNoise_Ctor(WhiteNoise* unit);
161
162 void GrayNoise_next(GrayNoise *unit, int inNumSamples);
163 void GrayNoise_Ctor(GrayNoise* unit);
164
165 void ClipNoise_next(ClipNoise *unit, int inNumSamples);
166 void ClipNoise_Ctor(ClipNoise* unit);
167
168 void PinkNoise_next(PinkNoise *unit, int inNumSamples);
169 void PinkNoise_Ctor(PinkNoise* unit);
170
171 void BrownNoise_next(BrownNoise *unit, int inNumSamples);
172 void BrownNoise_Ctor(BrownNoise* unit);
173
174 void Dust_next(Dust *unit, int inNumSamples);
175 void Dust_Ctor(Dust *unit);
176
177 void Dust2_next(Dust2 *unit, int inNumSamples);
178 void Dust2_Ctor(Dust2 *unit);
179
180 void Crackle_next(Crackle *unit, int inNumSamples);
181 void Crackle_Ctor(Crackle *unit);
182
183 void Hasher_next(Hasher *unit, int inNumSamples);
184 void Hasher_Ctor(Hasher *unit);
185
186 void MantissaMask_next(MantissaMask *unit, int inNumSamples);
187 void MantissaMask_Ctor(MantissaMask *unit);
188
189 void IRand_Ctor(IRand *unit);
190 void Rand_Ctor(Rand *unit);
191 void LinRand_Ctor(LinRand* unit);
192 void NRand_Ctor(NRand* unit);
193 void ExpRand_Ctor(ExpRand *unit);
194
195 void CoinGate_Ctor(CoinGate *unit);
196 void CoinGate_next_k(CoinGate *unit, int inNumSamples);
197 void CoinGate_next(CoinGate *unit, int inNumSamples);
198
199 void TIRand_next_a(TIRand *unit, int inNumSamples);
200 void TIRand_next_k(TIRand *unit, int inNumSamples);
201 void TIRand_Ctor(TIRand *unit);
202
203 void TRand_next_a(TRand *unit, int inNumSamples);
204 void TRand_next_k(TRand *unit, int inNumSamples);
205 void TRand_Ctor(TRand *unit);
206
207 void TExpRand_next_a(TExpRand *unit, int inNumSamples);
208 void TExpRand_next_k(TExpRand *unit, int inNumSamples);
209 void TExpRand_Ctor(TExpRand *unit);
210
211 void Logistic_next_1(Logistic *unit, int inNumSamples);
212 void Logistic_next_k(Logistic *unit, int inNumSamples);
213 void Logistic_Ctor(Logistic *unit);
214
215 void LFClipNoise_next(LFClipNoise *unit, int inNumSamples);
216 void LFClipNoise_Ctor(LFClipNoise *unit);
217
218 void LFNoise0_next(LFNoise0 *unit, int inNumSamples);
219 void LFNoise0_Ctor(LFNoise0 *unit);
220
221 void LFNoise1_next(LFNoise1 *unit, int inNumSamples);
222 void LFNoise1_Ctor(LFNoise1 *unit);
223
224 void LFNoise2_next(LFNoise2 *unit, int inNumSamples);
225 void LFNoise2_Ctor(LFNoise2 *unit);
226
227 void RandSeed_next(RandSeed *unit, int inNumSamples);
228 void RandSeed_next_k(RandSeed *unit, int inNumSamples);
229 void RandSeed_Ctor(RandSeed *unit);
230
231 void RandID_next(RandID *unit, int inNumSamples);
232 void RandID_Ctor(RandID *unit);
233 }
234
235 //////////////////////////////////////////////////////////////////////////////////////////////////
236
237 void ClipNoise_next(ClipNoise *unit, int inNumSamples)
238 {
239 float *out = ZOUT(0);
240
241 RGET
242 LOOP1(inNumSamples,
243 ZXP(out) = fcoin(s1, s2, s3);
244 );
245 RPUT
246 }
247
248 void ClipNoise_Ctor(ClipNoise* unit)
249 {
250 SETCALC(ClipNoise_next);
251
252 ClipNoise_next(unit, 1);
253 }
254
255 //////////////////////////////////////////////////////////////////////////////////////////////////
256
257 void GrayNoise_next(GrayNoise *unit, int inNumSamples)
258 {
259 float *out = ZOUT(0);
260
261 RGET
262 int counter = unit->mCounter;
263
264 LOOP1(inNumSamples,
265 counter ^= 1L << (trand(s1,s2,s3) & 31);
266 ZXP(out) = counter * 4.65661287308e-10f;
267 );
268 unit->mCounter = counter;
269 RPUT
270 }
271
272 void GrayNoise_Ctor(GrayNoise* unit)
273 {
274 SETCALC(GrayNoise_next);
275 unit->mCounter = 0;
276
277 GrayNoise_next(unit, 1);
278 }
279
280 //////////////////////////////////////////////////////////////////////////////////////////////////
281
282 void WhiteNoise_next(WhiteNoise *unit, int inNumSamples)
283 {
284 float *out = ZOUT(0);
285
286 RGET
287 LOOP1(inNumSamples,
288 ZXP(out) = frand2(s1, s2, s3);
289 );
290 RPUT
291 }
292
293 void WhiteNoise_Ctor(WhiteNoise* unit)
294 {
295 SETCALC(WhiteNoise_next);
296
297 WhiteNoise_next(unit, 1);
298 }
299
300
301 //////////////////////////////////////////////////////////////////////////////////////////////////
302
303 void PinkNoise_next(PinkNoise *unit, int inNumSamples)
304 {
305 float *out = ZOUT(0);
306
307 RGET
308
309 uint32 total = unit->mTotal;
310 uint32 *dice = unit->mDice;
311 LOOP1(inNumSamples,
312 uint32 counter = trand(s1,s2,s3); // Magnus Jonsson's suggestion.
313 uint32 newrand = counter >> 13;
314 int k = (CTZ(counter)) & 15;
315 uint32 prevrand = dice[k];
316 dice[k] = newrand;
317 total += (newrand - prevrand);
318 newrand = trand(s1,s2,s3) >> 13;
319 elem32 val; // ensure write before read <sk>
320 val.u = (total + newrand) | 0x40000000;
321 ZXP(out) = val.f - 3.0f;
322 counter ++;
323 );
324 unit->mTotal = total;
325 RPUT
326 }
327
328 void PinkNoise_Ctor(PinkNoise* unit)
329 {
330 SETCALC(PinkNoise_next);
331
332 RGET
333 uint32 *dice = unit->mDice;
334 int32 total = 0;
335 for (int i=0; i<16; ++i) {
336 uint32 newrand = trand(s1,s2,s3) >> 13;
337 total += newrand;
338 dice[i] = newrand;
339 }
340 unit->mTotal = total;
341
342 RPUT
343
344 PinkNoise_next(unit, 1);
345 }
346
347 ////////////////////////////////////////////////////////////////////////////////////////////////////////
348
349 void BrownNoise_next(BrownNoise *unit, int inNumSamples)
350 {
351 float *out = ZOUT(0);
352 RGET
353
354 float z = unit->mLevel;
355 LOOP1(inNumSamples,
356 z += frand8(s1, s2, s3);
357 if (z > 1.f) z = 2.f - z;
358 else if (z < -1.f) z = -2.f - z;
359 ZXP(out) = z;
360 );
361 unit->mLevel = z;
362 RPUT
363 }
364
365 void BrownNoise_Ctor(BrownNoise* unit)
366 {
367 SETCALC(BrownNoise_next);
368
369 unit->mLevel = unit->mParent->mRGen->frand2();
370
371 ZOUT0(0) = unit->mLevel;
372 }
373
374 ////////////////////////////////////////////////////////////////////////////////////////////////////////
375
376 void Dust_Ctor(Dust *unit)
377 {
378 SETCALC(Dust_next);
379
380 unit->m_density = 0.f;
381 unit->m_scale = 0.f;
382 unit->m_thresh = 0.f;
383 Dust_next(unit, 1);
384 }
385
386 void Dust_next(Dust *unit, int inNumSamples)
387 {
388 float *out = ZOUT(0);
389 float density = ZIN0(0);
390 float thresh, scale;
391
392 RGET
393
394 if (density != unit->m_density) {
395 thresh = unit->m_thresh = density * unit->mRate->mSampleDur;
396 scale = unit->m_scale = thresh > 0.f ? 1.f / thresh : 0.f;
397 unit->m_density = density;
398 } else {
399 thresh = unit->m_thresh;
400 scale = unit->m_scale;
401 }
402
403 LOOP1(inNumSamples,
404 float z = frand(s1,s2,s3);
405 if (z < thresh) ZXP(out) = z * scale;
406 else ZXP(out) = 0.f;
407 );
408
409 RPUT
410 }
411
412 ////////////////////////////////////////////////////////////////////////////////////////////////////////
413
414 void Dust2_Ctor(Dust2 *unit)
415 {
416 SETCALC(Dust2_next);
417
418 unit->m_density = 0.f;
419 unit->m_scale = 0.f;
420 unit->m_thresh = 0.f;
421 Dust2_next(unit, 1);
422 }
423
424 void Dust2_next(Dust2 *unit, int inNumSamples)
425 {
426 float *out = ZOUT(0);
427 float density = ZIN0(0);
428 float thresh, scale;
429
430 RGET
431
432 if (density != unit->m_density) {
433 thresh = unit->m_thresh = density * unit->mRate->mSampleDur;
434 scale = unit->m_scale = thresh > 0.f ? 2.f / thresh : 0.f;
435 unit->m_density = density;
436 } else {
437 thresh = unit->m_thresh;
438 scale = unit->m_scale;
439 }
440
441 LOOP1(inNumSamples,
442 float z = frand(s1,s2,s3);
443 if (z < thresh) ZXP(out) = z * scale - 1.f;
444 else ZXP(out) = 0.f;
445 );
446
447 RPUT
448 }
449
450 ////////////////////////////////////////////////////////////////////////////////////////////////////////
451
452 void Crackle_next(Crackle *unit, int inNumSamples)
453 {
454 float *out = ZOUT(0);
455 float paramf = ZIN0(0);
456 float y1 = unit->m_y1;
457 float y2 = unit->m_y2;
458 float y0;
459
460 LOOP1(inNumSamples,
461 ZXP(out) = y0 = fabs(y1 * paramf - y2 - 0.05f);
462 y2 = y1; y1 = y0;
463 );
464 unit->m_y1 = y1;
465 unit->m_y2 = y2;
466 }
467
468 void Crackle_Ctor(Crackle* unit)
469 {
470 SETCALC(Crackle_next);
471
472 unit->m_y1 = unit->mParent->mRGen->drand();
473 unit->m_y2 = 0.f;
474
475 Crackle_next(unit, 1);
476 }
477
478 ////////////////////////////////////////////////////////////////////////////////////////////////////////
479
480 void Logistic_next_1(Logistic *unit, int inNumSamples)
481 {
482 float *out = ZOUT(0);
483 double paramf = ZIN0(0);
484 double y1 = unit->m_y1;
485
486 LOOP1(inNumSamples,
487 ZXP(out) = y1 = paramf * y1 * (1.0 - y1); // chaotic equation
488 );
489 unit->m_y1 = y1;
490 }
491
492 void Logistic_next_k(Logistic *unit, int inNumSamples)
493 {
494 float *out = ZOUT(0);
495 double paramf = ZIN0(0);
496 float freq = ZIN0(1);
497 double y1 = unit->m_y1;
498 int32 counter = unit->mCounter;
499
500 long remain = inNumSamples;
501 do {
502 if (counter<=0) {
503 counter = (int32)(unit->mRate->mSampleRate / sc_max(freq, .001f));
504 counter = sc_max(1, counter);
505 y1 = paramf * y1 * (1.0 - y1); // chaotic equation
506 }
507 long nsmps = sc_min(counter, remain);
508 counter -= nsmps;
509 remain -= nsmps;
510 LOOP(nsmps, ZXP(out) = y1;);
511 } while (remain);
512 unit->m_y1 = y1;
513 unit->mCounter = counter;
514 }
515
516 void Logistic_Ctor(Logistic* unit)
517 {
518 if (INRATE(0) == calc_ScalarRate && ZIN0(1) >= unit->mRate->mSampleRate)
519 SETCALC(Logistic_next_1);
520 else
521 SETCALC(Logistic_next_k);
522
523 unit->m_y1 = ZIN0(2);
524 unit->mCounter = 0;
525
526 Logistic_next_1(unit, 1);
527 }
528
529 ////////////////////////////////////////////////////////////////////////////////////////////////////////
530
531 void Rand_Ctor(Rand* unit)
532 {
533 float lo = ZIN0(0);
534 float hi = ZIN0(1);
535 float range = hi - lo;
536 RGen& rgen = *unit->mParent->mRGen;
537 ZOUT0(0) = rgen.frand() * range + lo;
538 }
539
540 ////////////////////////////////////////////////////////////////////////////////////////////////////////
541
542 void TRand_next_k(TRand* unit, int inNumSamples)
543 {
544 float trig = ZIN0(2);
545 if (trig > 0.f && unit->m_trig <= 0.f) {
546 float lo = ZIN0(0);
547 float hi = ZIN0(1);
548 float range = hi - lo;
549 RGen& rgen = *unit->mParent->mRGen;
550 ZOUT0(0) = unit->m_value = rgen.frand() * range + lo;
551 } else {
552 ZOUT0(0) = unit->m_value;
553 }
554 unit->m_trig = trig;
555 }
556
557 void TRand_next_a(TRand* unit, int inNumSamples)
558 {
559 float *trig = ZIN(2);
560 float prev = unit->m_trig;
561 float *out = ZOUT(0);
562 float outval = unit->m_value;
563 float next;
564
565 LOOP1(inNumSamples,
566 next = ZXP(trig);
567 if (next > 0.f && prev <= 0.f) {
568 float lo = ZIN0(0);
569 float hi = ZIN0(1);
570 float range = hi - lo;
571 RGen& rgen = *unit->mParent->mRGen;
572 ZXP(out) = outval = rgen.frand() * range + lo;
573 } else {
574 ZXP(out) = outval;
575 };
576 prev = next;
577 )
578
579 unit->m_trig = next;
580 unit->m_value = outval;
581 }
582
583 void TRand_Ctor(TRand* unit)
584 {
585 float lo = ZIN0(0);
586 float hi = ZIN0(1);
587 float range = hi - lo;
588 RGen& rgen = *unit->mParent->mRGen;
589 ZOUT0(0) = unit->m_value = rgen.frand() * range + lo;
590 if(unit->mCalcRate == calc_FullRate){ SETCALC(TRand_next_a); } else { SETCALC(TRand_next_k); }
591 unit->m_trig = ZIN0(2);
592 }
593
594
595 ////////////////////////////////////////////////////////////////////////////////////////////////////////
596
597 void TExpRand_next_k(TExpRand* unit, int inNumSamples)
598 {
599 float trig = ZIN0(2);
600 if (trig > 0.f && unit->m_trig <= 0.f) {
601 float lo = ZIN0(0);
602 float hi = ZIN0(1);
603 float ratio = hi / lo;
604 RGen& rgen = *unit->mParent->mRGen;
605 ZOUT0(0) = unit->m_value = pow(ratio, rgen.frand()) * lo;
606 } else {
607 ZOUT0(0) = unit->m_value;
608 }
609 unit->m_trig = trig;
610 }
611
612 void TExpRand_next_a(TExpRand* unit, int inNumSamples)
613 {
614 float *trig = ZIN(2);
615 float prev = unit->m_trig;
616 float *out = ZOUT(0);
617 float outval = unit->m_value;
618 float next;
619
620 LOOP1(inNumSamples,
621 next = ZXP(trig);
622 if (next > 0.f && prev <= 0.f) {
623 float lo = ZIN0(0);
624 float hi = ZIN0(1);
625 float ratio = hi / lo;
626 RGen& rgen = *unit->mParent->mRGen;
627 ZXP(out) = outval = pow(ratio, rgen.frand()) * lo;
628 } else {
629 ZXP(out) = outval;
630 }
631 )
632
633 unit->m_trig = next;
634 unit->m_value = outval;
635 }
636
637 void TExpRand_Ctor(TExpRand* unit)
638 {
639 float lo = ZIN0(0);
640 float hi = ZIN0(1);
641 float ratio = hi / lo;
642 RGen& rgen = *unit->mParent->mRGen;
643
644 ZOUT0(0) = unit->m_value = pow(ratio, rgen.frand()) * lo;
645 if(unit->mCalcRate == calc_FullRate){ SETCALC(TExpRand_next_a); } else { SETCALC(TExpRand_next_k); }
646 unit->m_trig = ZIN0(2);
647 }
648
649
650 ////////////////////////////////////////////////////////////////////////////////////////////////////////
651
652 void IRand_Ctor(IRand* unit)
653 {
654 int lo = (int)ZIN0(0);
655 int hi = (int)ZIN0(1);
656 int range = hi - lo + 1;
657 RGen& rgen = *unit->mParent->mRGen;
658 ZOUT0(0) = (float)(rgen.irand(range) + lo);
659 }
660
661 ////////////////////////////////////////////////////////////////////////////////////////////////////////
662
663 void TIRand_next_k(TIRand* unit, int inNumSamples)
664 {
665 float trig = ZIN0(2);
666 if (trig > 0.f && unit->m_trig <= 0.f) {
667 int lo = (int)ZIN0(0);
668 int hi = (int)ZIN0(1);
669 int range = hi - lo + 1;
670 RGen& rgen = *unit->mParent->mRGen;
671 ZOUT0(0) = unit->m_value = (float)(rgen.irand(range) + lo);
672 } else {
673 ZOUT0(0) = unit->m_value;
674 }
675 unit->m_trig = trig;
676 }
677
678 void TIRand_next_a(TIRand* unit, int inNumSamples)
679 {
680 float *trig = ZIN(2);
681 float prev = unit->m_trig;
682 float *out = ZOUT(0);
683 float outval = unit->m_value;
684 float next;
685
686 LOOP1(inNumSamples,
687 next = ZXP(trig);
688 if (next > 0.f && prev <= 0.f) {
689 int lo = (int)ZIN0(0);
690 int hi = (int)ZIN0(1);
691 int range = hi - lo + 1;
692 RGen& rgen = *unit->mParent->mRGen;
693 ZXP(out) = outval = (float)(rgen.irand(range) + lo);
694 } else {
695 ZXP(out) = outval;
696 }
697 )
698
699 unit->m_trig = next;
700 unit->m_value = outval;
701 }
702
703
704 void TIRand_Ctor(TIRand* unit)
705 {
706 int lo = (int)ZIN0(0);
707 int hi = (int)ZIN0(1);
708 int range = hi - lo + 1;
709 RGen& rgen = *unit->mParent->mRGen;
710 ZOUT0(0) = unit->m_value = (float)(rgen.irand(range) + lo);
711 if(unit->mCalcRate == calc_FullRate){ SETCALC(TIRand_next_a); } else { SETCALC(TIRand_next_k); }
712 unit->m_trig = ZIN0(2);
713 }
714
715
716 ////////////////////////////////////////////////////////////////////////////////////////////////////////
717
718 void CoinGate_Ctor(CoinGate* unit)
719 {
720 if (unit->mCalcRate == calc_FullRate) {
721 SETCALC(CoinGate_next);
722 } else {
723 SETCALC(CoinGate_next_k);
724 }
725 unit->m_trig = ZIN0(1);
726 }
727
728 void CoinGate_next_k(CoinGate* unit, int inNumSamples)
729 {
730 float trig = ZIN0(1);
731 float level = 0.f;
732 RGen& rgen = *unit->mParent->mRGen;
733 if (trig > 0.f && unit->m_trig <= 0.f) {
734
735 if(rgen.frand() < ZIN0(0)) {
736 level = trig;
737 }
738 }
739
740 ZOUT0(0) = level;
741 unit->m_trig = trig;
742 }
743
744 void CoinGate_next(CoinGate* unit, int inNumSamples)
745 {
746 float *trig = ZIN(1);
747 float *out = ZOUT(0);
748 float prevtrig = unit->m_trig;
749 float probability = ZIN0(0);
750 RGen& rgen = *unit->mParent->mRGen;
751 LOOP1(inNumSamples,
752 float curtrig = ZXP(trig);
753 float level = 0.f;
754 if (prevtrig <= 0.f && curtrig > 0.f) {
755 if(rgen.frand() < probability) {
756 level = curtrig;
757 } else {
758 level = 0.f;
759 }
760 }
761 prevtrig = curtrig;
762 ZXP(out) = level;
763 )
764
765 unit->m_trig = prevtrig;
766 }
767
768 ////////////////////////////////////////////////////////////////////////////////////////////////////////
769
770 void RandSeed_Ctor(RandSeed* unit)
771 {
772 unit->m_trig = 0.;
773 if(unit->mCalcRate == calc_FullRate){ SETCALC(RandSeed_next); } else { SETCALC(RandSeed_next_k); }
774 RandSeed_next(unit, 1);
775 }
776
777 void RandSeed_next_k(RandSeed* unit, int inNumSamples)
778 {
779 float trig = ZIN0(0);
780
781 if (trig > 0.f && unit->m_trig <= 0.f) {
782 RGen& rgen = *unit->mParent->mRGen;
783 int seed = (int)DEMANDINPUT_A(1, inNumSamples);
784 rgen.init(seed);
785 }
786 unit->m_trig = trig;
787 ZOUT0(0) = 0.f;
788 }
789
790 void RandSeed_next(RandSeed* unit, int inNumSamples)
791 {
792 float *trig = ZIN(0);
793 float *out = ZOUT(0);
794
795 float prevtrig = unit->m_trig;
796 float curtrig;
797
798 LOOP1(inNumSamples,
799
800 curtrig = ZXP(trig);
801 if (curtrig > 0.f && prevtrig <= 0.f) {
802 RGen& rgen = *unit->mParent->mRGen;
803 int seed = (int)DEMANDINPUT_A(1, inNumSamples);
804 rgen.init(seed);
805 }
806 prevtrig = curtrig;
807 ZXP(out) = 0.f;
808
809 )
810
811 unit->m_trig = curtrig;
812 }
813
814 ////////////////////////////////////////////////////////////////////////////////////////////////////////
815
816 void RandID_Ctor(RandID* unit)
817 {
818 unit->m_id = -1.;
819 SETCALC(RandID_next);
820 RandID_next(unit, 1);
821 }
822
823 void RandID_next(RandID* unit, int inNumSamples)
824 {
825 float id = ZIN0(0);
826
827 if (id != unit->m_id) {
828 unit->m_id = id;
829 uint32 iid = (uint32)id;
830 if (iid < unit->mWorld->mNumRGens) {
831 unit->mParent->mRGen = unit->mWorld->mRGen + iid;
832 }
833 }
834 ZOUT0(0) = 0.f;
835 }
836
837 ////////////////////////////////////////////////////////////////////////////////////////////////////////
838
839 void LinRand_Ctor(LinRand* unit)
840 {
841 float lo = ZIN0(0);
842 float hi = ZIN0(1);
843 int n = (int)ZIN0(2);
844
845 float range = hi - lo;
846 RGen& rgen = *unit->mParent->mRGen;
847 float a, b;
848 a = rgen.frand();
849 b = rgen.frand();
850 if (n <= 0) {
851 ZOUT0(0) = sc_min(a, b) * range + lo;
852 } else {
853 ZOUT0(0) = sc_max(a, b) * range + lo;
854 }
855 }
856
857 ////////////////////////////////////////////////////////////////////////////////////////////////////////
858
859 void NRand_Ctor(NRand* unit)
860 {
861 float lo = ZIN0(0);
862 float hi = ZIN0(1);
863 int n = (int)ZIN0(2);
864
865 float range = hi - lo;
866 RGen& rgen = *unit->mParent->mRGen;
867 float sum = 0;
868 for (int i=0; i<n; ++i) {
869 sum += rgen.frand();
870 }
871 ZOUT0(0) = (sum/n) * range + lo;
872 }
873
874 ////////////////////////////////////////////////////////////////////////////////////////////////////////
875
876 void ExpRand_Ctor(ExpRand* unit)
877 {
878 float lo = ZIN0(0);
879 float hi = ZIN0(1);
880 float ratio = hi / lo;
881
882 ZOUT0(0) = pow(ratio, unit->mParent->mRGen->frand()) * lo;
883 }
884
885 ////////////////////////////////////////////////////////////////////////////////////////////////////////
886
887 void Hasher_next(Hasher *unit, int inNumSamples)
888 {
889 int32 *in = (int32*)ZIN(0);
890 float *out = ZOUT(0);
891
892 LOOP1(inNumSamples,
893 union { float f; int i; } u;
894 int z = ZXP(in);
895 u.i = 0x40000000 | ((uint32)Hash(z) >> 9);
896 ZXP(out) = u.f - 3.f;
897 );
898 }
899
900 void Hasher_Ctor(Hasher* unit)
901 {
902 SETCALC(Hasher_next);
903
904 Hasher_next(unit, 1);
905 }
906
907 ////////////////////////////////////////////////////////////////////////////////////////////////////////
908
909 void MantissaMask_next(MantissaMask *unit, int inNumSamples)
910 {
911 int32 *in = (int32*)ZIN(0);
912 int32 bits = (int32)ZIN0(1);
913 int32 *out = (int32*)ZOUT(0);
914 int32 mask = -1 << (23 - bits);
915 LOOP1(inNumSamples,
916 ZXP(out) = mask & ZXP(in);
917 );
918 }
919
920 void MantissaMask_Ctor(MantissaMask* unit)
921 {
922 SETCALC(MantissaMask_next);
923
924 MantissaMask_next(unit, 1);
925 }
926
927 ////////////////////////////////////////////////////////////////////////////////////////////////////////
928
929 void LFClipNoise_next(LFClipNoise *unit, int inNumSamples)
930 {
931 float *out = ZOUT(0);
932 float freq = ZIN0(0);
933 float level = unit->mLevel;
934 int32 counter = unit->mCounter;
935 RGET
936
937 int remain = inNumSamples;
938 do {
939 if (counter<=0) {
940 counter = (int)(unit->mRate->mSampleRate / sc_max(freq, .001f));
941 counter = sc_max(1, counter);
942 level = fcoin(s1,s2,s3);
943 }
944 int nsmps = sc_min(remain, counter);
945 remain -= nsmps;
946 counter -= nsmps;
947 LOOP(nsmps, ZXP(out) = level;);
948 } while (remain);
949 unit->mLevel = level;
950 unit->mCounter = counter;
951 RPUT
952 }
953
954 void LFClipNoise_Ctor(LFClipNoise* unit)
955 {
956 SETCALC(LFClipNoise_next);
957
958 unit->mCounter = 0;
959 unit->mLevel = 0.f;
960
961 LFClipNoise_next(unit, 1);
962 }
963
964 ////////////////////////////////////////////////////////////////////////////////////////////////////////
965
966 void LFNoise0_next(LFNoise0 *unit, int inNumSamples)
967 {
968 float *out = ZOUT(0);
969 float freq = ZIN0(0);
970 float level = unit->mLevel;
971 int32 counter = unit->mCounter;
972 RGET
973
974 int remain = inNumSamples;
975 do {
976 if (counter<=0) {
977 counter = (int32)(unit->mRate->mSampleRate / sc_max(freq, .001f));
978 counter = sc_max(1, counter);
979 level = frand2(s1,s2,s3);
980 }
981 int nsmps = sc_min(remain, counter);
982 remain -= nsmps;
983 counter -= nsmps;
984 LOOP(nsmps, ZXP(out) = level;);
985 } while (remain);
986 unit->mLevel = level;
987 unit->mCounter = counter;
988 RPUT
989 }
990
991 void LFNoise0_next_1(LFNoise0 *unit, int inNumSamples)
992 {
993 assert(inNumSamples == 1);
994 float freq = ZIN0(0);
995 float level = unit->mLevel;
996 int32 counter = unit->mCounter;
997
998 if (counter<=0) {
999 counter = (int32)(unit->mRate->mSampleRate / sc_max(freq, .001f));
1000 counter = sc_max(1, counter);
1001 RGET
1002 level = frand2(s1,s2,s3);
1003 unit->mLevel = level;
1004 RPUT
1005 }
1006 ZOUT0(0) = level;
1007 counter -= 1;
1008 unit->mCounter = counter;
1009 }
1010
1011
1012 void LFNoise0_Ctor(LFNoise0* unit)
1013 {
1014 if (BUFLENGTH == 1)
1015 SETCALC(LFNoise0_next_1);
1016 else
1017 SETCALC(LFNoise0_next);
1018
1019 unit->mCounter = 0;
1020 unit->mLevel = 0.f;
1021
1022 LFNoise0_next_1(unit, 1);
1023 }
1024
1025 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1026
1027 void LFNoise1_next(LFNoise1 *unit, int inNumSamples)
1028 {
1029 float *out = ZOUT(0);
1030 float freq = ZIN0(0);
1031 float level = unit->mLevel;
1032 float slope = unit->mSlope;
1033 int32 counter = unit->mCounter;
1034 RGET
1035
1036 int remain = inNumSamples;
1037 do {
1038 if (counter<=0) {
1039 counter = (int32)(unit->mRate->mSampleRate / sc_max(freq, .001f));
1040 counter = sc_max(1, counter);
1041 float nextlevel = frand2(s1,s2,s3);
1042 slope = (nextlevel - level) / counter;
1043 }
1044 int nsmps = sc_min(remain, counter);
1045 remain -= nsmps;
1046 counter -= nsmps;
1047 LOOP(nsmps, ZXP(out) = level; level += slope;);
1048 } while (remain);
1049 unit->mLevel = level;
1050 unit->mSlope = slope;
1051 unit->mCounter = counter;
1052 RPUT
1053 }
1054
1055 void LFNoise1_Ctor(LFNoise1* unit)
1056 {
1057 SETCALC(LFNoise1_next);
1058
1059 unit->mCounter = 0;
1060 unit->mLevel = unit->mParent->mRGen->frand2();
1061 unit->mSlope = 0.f;
1062
1063 LFNoise1_next(unit, 1);
1064 }
1065
1066 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1067
1068 void LFNoise2_next(LFNoise2 *unit, int inNumSamples)
1069 {
1070 float *out = ZOUT(0);
1071 float freq = ZIN0(0);
1072 float level = unit->mLevel;
1073 float slope = unit->mSlope;
1074 float curve = unit->mCurve;
1075 int counter = unit->mCounter;
1076 RGET
1077
1078 int remain = inNumSamples;
1079 do {
1080 if (counter<=0) {
1081 float value = unit->m_nextvalue;
1082 unit->m_nextvalue = frand2(s1,s2,s3);
1083 level = unit->m_nextmidpt;
1084 unit->m_nextmidpt = (unit->m_nextvalue + value) * .5;
1085
1086 counter = (int32)(unit->mRate->mSampleRate / sc_max(freq, .001f));
1087 counter = sc_max(2, counter);
1088 float fseglen = (float)counter;
1089 curve = 2.f * (unit->m_nextmidpt - level - fseglen * slope) / (fseglen * fseglen + fseglen);
1090 }
1091 int nsmps = sc_min(remain, counter);
1092 remain -= nsmps;
1093 counter -= nsmps;
1094 LOOP(nsmps,
1095 ZXP(out) = level;
1096 slope += curve;
1097 level += slope;
1098 );
1099 } while (remain);
1100 unit->mLevel = level;
1101 unit->mSlope = slope;
1102 unit->mCurve = curve;
1103 unit->mCounter = counter;
1104 RPUT
1105 }
1106
1107 void LFNoise2_Ctor(LFNoise2* unit)
1108 {
1109 SETCALC(LFNoise2_next);
1110
1111 unit->mCounter = 0;
1112 unit->mSlope = 0.f;
1113 unit->mLevel = 0.f;
1114 unit->m_nextvalue = unit->mParent->mRGen->frand2();
1115 unit->m_nextmidpt = unit->m_nextvalue * .5f;
1116
1117 LFNoise2_next(unit, 1);
1118 }
1119
1120 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1121
1122 void WrapBufRd_next0(Unit *unit, int inNumSamples);
1123 void WrapBufRd_next0(Unit *unit, int inNumSamples)
1124 {
1125 int bufnum = (int)ZIN0(0);
1126 float *pos = ZIN(1);
1127
1128 const SndBuf *buf = unit->mWorld->mSndBufs + bufnum;
1129 int numchan = buf->channels;
1130
1131 LOCK_SNDBUF_SHARED(buf);
1132 if (numchan != unit->mNumOutputs) {
1133 ClearUnitOutputs(unit, inNumSamples);
1134 return;
1135 }
1136
1137 const float *data = buf->data;
1138 int numframes = buf->frames;
1139
1140 float *out[16];
1141 for (int i=0; i<numchan; ++i) out[i] = OUT(i);
1142
1143 LOOP1(inNumSamples,
1144 float fpos = ZXP(pos);
1145 int ipos = (int)fpos * numchan;
1146 ipos = sc_mod(ipos, numframes);
1147 int index = numchan * ipos;
1148 for (int i=0; i<numchan; ++i) {
1149 *++(out[i]) = data[index];
1150 index++;
1151 }
1152 );
1153 }
1154
1155 void ClipBufRd_next0(Unit *unit, int inNumSamples);
1156 void ClipBufRd_next0(Unit *unit, int inNumSamples)
1157 {
1158 int bufnum = (int)ZIN0(0);
1159 float *pos = ZIN(1);
1160
1161 const SndBuf *buf = unit->mWorld->mSndBufs + bufnum;
1162 LOCK_SNDBUF_SHARED(buf);
1163 int numchan = buf->channels;
1164
1165 if (numchan != unit->mNumOutputs) {
1166 ClearUnitOutputs(unit, inNumSamples);
1167 return;
1168 }
1169
1170 const float *data = buf->data;
1171 int numframes = buf->frames;
1172 int maxframe = numframes - 2;
1173
1174 float *out[16];
1175 for (int i=0; i<numchan; ++i) out[i] = OUT(i);
1176
1177 LOOP1(inNumSamples,
1178 float fpos = ZXP(pos);
1179 int ipos = (int)fpos * numchan;
1180 ipos = sc_clip(ipos, 0, maxframe);
1181 int index = numchan * ipos;
1182 for (int i=0; i<numchan; ++i) {
1183 *++(out[i]) = data[index];
1184 index++;
1185 }
1186 );
1187 }
1188
1189 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1190
1191 PluginLoad(Noise)
1192 {
1193 ft = inTable;
1194
1195 DefineSimpleUnit(WhiteNoise);
1196 DefineSimpleUnit(GrayNoise);
1197 DefineSimpleUnit(ClipNoise);
1198 DefineSimpleUnit(PinkNoise);
1199 DefineSimpleUnit(BrownNoise);
1200 DefineSimpleUnit(Dust);
1201 DefineSimpleUnit(Dust2);
1202 DefineSimpleUnit(Crackle);
1203 DefineSimpleUnit(Logistic);
1204 DefineSimpleUnit(Hasher);
1205 DefineSimpleUnit(MantissaMask);
1206 DefineSimpleUnit(LFClipNoise);
1207 DefineSimpleUnit(LFNoise0);
1208 DefineSimpleUnit(LFNoise1);
1209 DefineSimpleUnit(LFNoise2);
1210 DefineSimpleUnit(Rand);
1211 DefineSimpleUnit(IRand);
1212 DefineSimpleUnit(TRand);
1213 DefineSimpleUnit(TExpRand);
1214 DefineSimpleUnit(TIRand);
1215 DefineSimpleUnit(NRand);
1216 DefineSimpleUnit(LinRand);
1217 DefineSimpleUnit(ExpRand);
1218 DefineSimpleUnit(CoinGate);
1219 DefineSimpleUnit(RandSeed);
1220 DefineSimpleUnit(RandID);
1221 }
1222
1223 ////////////////////////////////////////////////////////////////////////////////////////////////////////