?  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 / DelayUGens.cpp
blob5fdeaeaad1f1ba8c9b99869c0015ecf9e5d0b54e
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 #ifdef NOVA_SIMD
22 #include "simd_memory.hpp"
23 #endif
24
25 #include "SC_PlugIn.h"
26 #include <cstdio>
27
28 using namespace std; // for math functions
29
30
31 const int kMAXMEDIANSIZE = 32;
32
33 static InterfaceTable *ft;
34
35 struct ScopeOut : public Unit
36 {
37 SndBuf *m_buf;
38 SndBufUpdates *m_bufupdates;
39 float m_fbufnum;
40 uint32 m_framepos, m_framecount;
41 float **mIn;
42 };
43
44 struct PlayBuf : public Unit
45 {
46 double m_phase;
47 float m_prevtrig;
48 float m_fbufnum;
49 SndBuf *m_buf;
50 };
51
52
53 struct Grain
54 {
55 double phase, rate;
56 double b1, y1, y2; // envelope
57 float pan1, pan2;
58 int counter;
59 int bufnum;
60 int chan;
61 int interp;
62 };
63
64 const int kMaxGrains = 64;
65
66 struct TGrains : public Unit
67 {
68 float mPrevTrig;
69 int mNumActive;
70 Grain mGrains[kMaxGrains];
71 };
72
73
74 #if NOTYET
75 struct SimpleLoopBuf : public Unit
76 {
77 int m_phase;
78 float m_prevtrig;
79 float m_fbufnum;
80 SndBuf *m_buf;
81 };
82 #endif
83
84 struct BufRd : public Unit
85 {
86 float m_fbufnum;
87 SndBuf *m_buf;
88 };
89
90 struct BufWr : public Unit
91 {
92 float m_fbufnum;
93 SndBuf *m_buf;
94 };
95
96 struct RecordBuf : public Unit
97 {
98 float m_fbufnum;
99 SndBuf *m_buf;
100 int32 m_writepos;
101 float m_recLevel, m_preLevel;
102 float m_prevtrig;
103 float **mIn;
104 };
105
106 struct Pitch : public Unit
107 {
108 float m_values[kMAXMEDIANSIZE];
109 int m_ages[kMAXMEDIANSIZE];
110 float *m_buffer;
111
112 float m_freq, m_minfreq, m_maxfreq, m_hasfreq, m_srate, m_ampthresh, m_peakthresh;
113 int m_minperiod, m_maxperiod, m_execPeriod, m_index, m_readp, m_size;
114 int m_downsamp, m_maxlog2bins, m_medianSize;
115 int m_state;
116 bool m_getClarity;
117 };
118
119 struct InterpolationUnit
120 {
121 static const int minDelaySamples = 1;
122 };
123
124 struct CubicInterpolationUnit
125 {
126 static const int minDelaySamples = 2;
127 };
128
129 struct BufDelayUnit : public Unit
130 {
131 float m_fbufnum;
132 SndBuf *m_buf;
133 float m_dsamp;
134 float m_delaytime;
135 int m_iwrphase;
136 uint32 m_numoutput;
137 };
138
139 struct BufDelayN : public BufDelayUnit, InterpolationUnit
140 {};
141
142 struct BufDelayL : public BufDelayUnit, InterpolationUnit
143 {};
144
145 struct BufDelayC : public BufDelayUnit, CubicInterpolationUnit
146 {};
147
148 struct BufFeedbackDelay : public BufDelayUnit
149 {
150 float m_feedbk, m_decaytime;
151 };
152
153 struct BufCombN : public BufFeedbackDelay, InterpolationUnit
154 {};
155
156 struct BufCombL : public BufFeedbackDelay, InterpolationUnit
157 {};
158
159 struct BufCombC : public BufFeedbackDelay, CubicInterpolationUnit
160 {};
161
162 struct BufAllpassN : public BufFeedbackDelay, InterpolationUnit
163 {};
164
165 struct BufAllpassL : public BufFeedbackDelay, InterpolationUnit
166 {};
167
168 struct BufAllpassC : public BufFeedbackDelay, CubicInterpolationUnit
169 {};
170
171 struct DelayUnit : public Unit
172 {
173 float *m_dlybuf;
174
175 float m_dsamp, m_fdelaylen;
176 float m_delaytime, m_maxdelaytime;
177 long m_iwrphase, m_idelaylen, m_mask;
178 long m_numoutput;
179 };
180
181 struct DelayN : public DelayUnit, InterpolationUnit
182 {};
183
184 struct DelayL : public DelayUnit, InterpolationUnit
185 {};
186
187 struct DelayC : public DelayUnit, InterpolationUnit
188 {};
189
190 struct FeedbackDelay : public DelayUnit
191 {
192 float m_feedbk, m_decaytime;
193 };
194
195 struct CombN : public FeedbackDelay, InterpolationUnit
196 {};
197
198 struct CombL : public FeedbackDelay, InterpolationUnit
199 {};
200
201 struct CombC : public FeedbackDelay, CubicInterpolationUnit
202 {};
203
204 struct AllpassN : public FeedbackDelay, InterpolationUnit
205 {};
206
207 struct AllpassL : public FeedbackDelay, InterpolationUnit
208 {};
209
210 struct AllpassC : public FeedbackDelay, CubicInterpolationUnit
211 {};
212
213 struct BufInfoUnit : public Unit
214 {
215 float m_fbufnum;
216 SndBuf *m_buf;
217 };
218
219 struct Pluck : public FeedbackDelay, CubicInterpolationUnit
220 {
221 float m_lastsamp, m_prevtrig, m_coef;
222 long m_inputsamps;
223 };
224
225 struct LocalBuf : public Unit
226 {
227 SndBuf *m_buf;
228 };
229
230 struct MaxLocalBufs : public Unit
231 {
232 };
233
234 struct SetBuf : public Unit
235 {};
236
237 struct ClearBuf : public Unit
238 {};
239
240 struct DelTapWr : public Unit
241 {
242 SndBuf *m_buf;
243 float m_fbufnum;
244 uint32 m_phase;
245 };
246
247 struct DelTapRd : public Unit
248 {
249 SndBuf *m_buf;
250 float m_fbufnum, m_delTime;
251 };
252
253
254 //////////////////////////////////////////////////////////////////////////////////////////////////
255
256 extern "C"
257 {
258
259 void SampleRate_Ctor(Unit *unit, int inNumSamples);
260 void ControlRate_Ctor(Unit *unit, int inNumSamples);
261 void SampleDur_Ctor(Unit *unit, int inNumSamples);
262 void ControlDur_Ctor(Unit *unit, int inNumSamples);
263 void SubsampleOffset_Ctor(Unit *unit, int inNumSamples);
264 void RadiansPerSample_Ctor(Unit *unit, int inNumSamples);
265 void NumInputBuses_Ctor(Unit *unit, int inNumSamples);
266 void NumOutputBuses_Ctor(Unit *unit, int inNumSamples);
267 void NumAudioBuses_Ctor(Unit *unit, int inNumSamples);
268 void NumControlBuses_Ctor(Unit *unit, int inNumSamples);
269 void NumBuffers_Ctor(Unit *unit, int inNumSamples);
270 void NumRunningSynths_Ctor(Unit *unit, int inNumSamples);
271 void NumRunningSynths_next(Unit *unit, int inNumSamples);
272
273 void BufSampleRate_next(BufInfoUnit *unit, int inNumSamples);
274 void BufSampleRate_Ctor(BufInfoUnit *unit, int inNumSamples);
275
276 void BufFrames_next(BufInfoUnit *unit, int inNumSamples);
277 void BufFrames_Ctor(BufInfoUnit *unit, int inNumSamples);
278
279 void BufDur_next(BufInfoUnit *unit, int inNumSamples);
280 void BufDur_Ctor(BufInfoUnit *unit, int inNumSamples);
281
282 void BufChannels_next(BufInfoUnit *unit, int inNumSamples);
283 void BufChannels_Ctor(BufInfoUnit *unit, int inNumSamples);
284
285 void BufSamples_next(BufInfoUnit *unit, int inNumSamples);
286 void BufSamples_Ctor(BufInfoUnit *unit, int inNumSamples);
287
288 void BufRateScale_next(BufInfoUnit *unit, int inNumSamples);
289 void BufRateScale_Ctor(BufInfoUnit *unit, int inNumSamples);
290
291 void PlayBuf_next_aa(PlayBuf *unit, int inNumSamples);
292 void PlayBuf_next_ak(PlayBuf *unit, int inNumSamples);
293 void PlayBuf_next_ka(PlayBuf *unit, int inNumSamples);
294 void PlayBuf_next_kk(PlayBuf *unit, int inNumSamples);
295 void PlayBuf_Ctor(PlayBuf* unit);
296
297 void TGrains_next(TGrains *unit, int inNumSamples);
298 void TGrains_Ctor(TGrains* unit);
299
300 #if NOTYET
301 void SimpleLoopBuf_next_kk(SimpleLoopBuf *unit, int inNumSamples);
302 void SimpleLoopBuf_Ctor(SimpleLoopBuf* unit);
303 void SimpleLoopBuf_Dtor(SimpleLoopBuf* unit);
304 #endif
305
306 void BufRd_Ctor(BufRd *unit);
307 void BufRd_next_4(BufRd *unit, int inNumSamples);
308 void BufRd_next_2(BufRd *unit, int inNumSamples);
309 void BufRd_next_1(BufRd *unit, int inNumSamples);
310
311 void BufWr_Ctor(BufWr *unit);
312 void BufWr_next(BufWr *unit, int inNumSamples);
313
314 void RecordBuf_Ctor(RecordBuf *unit);
315 void RecordBuf_Dtor(RecordBuf *unit);
316 void RecordBuf_next(RecordBuf *unit, int inNumSamples);
317 void RecordBuf_next_10(RecordBuf *unit, int inNumSamples);
318
319 void Pitch_Ctor(Pitch *unit);
320 void Pitch_next_a(Pitch *unit, int inNumSamples);
321 void Pitch_next_k(Pitch *unit, int inNumSamples);
322
323 void LocalBuf_Ctor(LocalBuf *unit);
324 void LocalBuf_Dtor(LocalBuf *unit);
325
326 void MaxLocalBufs_Ctor(MaxLocalBufs *unit);
327
328 void SetBuf_Ctor(SetBuf *unit);
329 void ClearBuf_Ctor(ClearBuf *unit);
330
331 void BufDelayN_Ctor(BufDelayN *unit);
332 void BufDelayN_next(BufDelayN *unit, int inNumSamples);
333 void BufDelayN_next_z(BufDelayN *unit, int inNumSamples);
334 void BufDelayN_next_a(BufDelayN *unit, int inNumSamples);
335 void BufDelayN_next_a_z(BufDelayN *unit, int inNumSamples);
336
337 void BufDelayL_Ctor(BufDelayL *unit);
338 void BufDelayL_next(BufDelayL *unit, int inNumSamples);
339 void BufDelayL_next_z(BufDelayL *unit, int inNumSamples);
340 void BufDelayL_next_a(BufDelayL *unit, int inNumSamples);
341 void BufDelayL_next_a_z(BufDelayL *unit, int inNumSamples);
342
343 void BufDelayC_Ctor(BufDelayC *unit);
344 void BufDelayC_next(BufDelayC *unit, int inNumSamples);
345 void BufDelayC_next_z(BufDelayC *unit, int inNumSamples);
346 void BufDelayC_next_a(BufDelayC *unit, int inNumSamples);
347 void BufDelayC_next_a_z(BufDelayC *unit, int inNumSamples);
348
349 void BufCombN_Ctor(BufCombN *unit);
350 void BufCombN_next(BufCombN *unit, int inNumSamples);
351 void BufCombN_next_z(BufCombN *unit, int inNumSamples);
352 void BufCombN_next_a(BufCombN *unit, int inNumSamples);
353 void BufCombN_next_a_z(BufCombN *unit, int inNumSamples);
354
355 void BufCombL_Ctor(BufCombL *unit);
356 void BufCombL_next(BufCombL *unit, int inNumSamples);
357 void BufCombL_next_z(BufCombL *unit, int inNumSamples);
358 void BufCombL_next_a(BufCombL *unit, int inNumSamples);
359 void BufCombL_next_a_z(BufCombL *unit, int inNumSamples);
360
361 void BufCombC_Ctor(BufCombC *unit);
362 void BufCombC_next(BufCombC *unit, int inNumSamples);
363 void BufCombC_next_z(BufCombC *unit, int inNumSamples);
364 void BufCombC_next_a(BufCombC *unit, int inNumSamples);
365 void BufCombC_next_a_z(BufCombC *unit, int inNumSamples);
366
367 void BufAllpassN_Ctor(BufAllpassN *unit);
368 void BufAllpassN_next(BufAllpassN *unit, int inNumSamples);
369 void BufAllpassN_next_z(BufAllpassN *unit, int inNumSamples);
370 void BufAllpassN_next_a(BufAllpassN *unit, int inNumSamples);
371 void BufAllpassN_next_a_z(BufAllpassN *unit, int inNumSamples);
372
373 void BufAllpassL_Ctor(BufAllpassL *unit);
374 void BufAllpassL_next(BufAllpassL *unit, int inNumSamples);
375 void BufAllpassL_next_z(BufAllpassL *unit, int inNumSamples);
376 void BufAllpassL_next_a(BufAllpassL *unit, int inNumSamples);
377 void BufAllpassL_next_a_z(BufAllpassL *unit, int inNumSamples);
378
379 void BufAllpassC_Ctor(BufAllpassC *unit);
380 void BufAllpassC_next(BufAllpassC *unit, int inNumSamples);
381 void BufAllpassC_next_z(BufAllpassC *unit, int inNumSamples);
382 void BufAllpassC_next_a(BufAllpassC *unit, int inNumSamples);
383 void BufAllpassC_next_a_z(BufAllpassC *unit, int inNumSamples);
384
385 void DelayUnit_Dtor(DelayUnit *unit);
386
387 void DelayN_Ctor(DelayN *unit);
388 void DelayN_next(DelayN *unit, int inNumSamples);
389 void DelayN_next_z(DelayN *unit, int inNumSamples);
390 void DelayN_next_a(DelayN *unit, int inNumSamples);
391 void DelayN_next_a_z(DelayN *unit, int inNumSamples);
392
393 void DelayL_Ctor(DelayL *unit);
394 void DelayL_next(DelayL *unit, int inNumSamples);
395 void DelayL_next_z(DelayL *unit, int inNumSamples);
396 void DelayL_next_a(DelayL *unit, int inNumSamples);
397 void DelayL_next_a_z(DelayL *unit, int inNumSamples);
398
399 void DelayC_Ctor(DelayC *unit);
400 void DelayC_next(DelayC *unit, int inNumSamples);
401 void DelayC_next_z(DelayC *unit, int inNumSamples);
402 void DelayC_next_a(DelayC *unit, int inNumSamples);
403 void DelayC_next_a_z(DelayC *unit, int inNumSamples);
404
405 void CombN_Ctor(CombN *unit);
406 void CombN_next(CombN *unit, int inNumSamples);
407 void CombN_next_z(CombN *unit, int inNumSamples);
408 void CombN_next_a(CombN *unit, int inNumSamples);
409 void CombN_next_a_z(CombN *unit, int inNumSamples);
410
411 void CombL_Ctor(CombL *unit);
412 void CombL_next(CombL *unit, int inNumSamples);
413 void CombL_next_z(CombL *unit, int inNumSamples);
414 void CombL_next_a(CombL *unit, int inNumSamples);
415 void CombL_next_a_z(CombL *unit, int inNumSamples);
416
417 void CombC_Ctor(CombC *unit);
418 void CombC_next(CombC *unit, int inNumSamples);
419 void CombC_next_z(CombC *unit, int inNumSamples);
420 void CombC_next_a(CombC *unit, int inNumSamples);
421 void CombC_next_a_z(CombC *unit, int inNumSamples);
422
423 void AllpassN_Ctor(AllpassN *unit);
424 void AllpassN_next(AllpassN *unit, int inNumSamples);
425 void AllpassN_next_z(AllpassN *unit, int inNumSamples);
426 void AllpassN_next_a(AllpassN *unit, int inNumSamples);
427 void AllpassN_next_a_z(AllpassN *unit, int inNumSamples);
428
429 void AllpassL_Ctor(AllpassL *unit);
430 void AllpassL_next(AllpassL *unit, int inNumSamples);
431 void AllpassL_next_z(AllpassL *unit, int inNumSamples);
432 void AllpassL_next_a(AllpassL *unit, int inNumSamples);
433 void AllpassL_next_a_z(AllpassL *unit, int inNumSamples);
434
435 void AllpassC_Ctor(AllpassC *unit);
436 void AllpassC_next(AllpassC *unit, int inNumSamples);
437 void AllpassC_next_z(AllpassC *unit, int inNumSamples);
438 void AllpassC_next_a(AllpassC *unit, int inNumSamples);
439 void AllpassC_next_a_z(AllpassC *unit, int inNumSamples);
440
441 void ScopeOut_next(ScopeOut *unit, int inNumSamples);
442 void ScopeOut_Ctor(ScopeOut *unit);
443 void ScopeOut_Dtor(ScopeOut *unit);
444
445 void Pluck_Ctor(Pluck* unit);
446 void Pluck_next_aa(Pluck *unit, int inNumSamples);
447 void Pluck_next_aa_z(Pluck *unit, int inNumSamples);
448 void Pluck_next_kk(Pluck *unit, int inNumSamples);
449 void Pluck_next_kk_z(Pluck *unit, int inNumSamples);
450 void Pluck_next_ka(Pluck *unit, int inNumSamples);
451 void Pluck_next_ka_z(Pluck *unit, int inNumSamples);
452 void Pluck_next_ak(Pluck *unit, int inNumSamples);
453 void Pluck_next_ak_z(Pluck *unit, int inNumSamples);
454
455 void DelTapWr_Ctor(DelTapWr* unit);
456 void DelTapWr_next(DelTapWr *unit, int inNumSamples);
457 void DelTapWr_next_simd(DelTapWr *unit, int inNumSamples);
458
459 void DelTapRd_Ctor(DelTapRd* unit);
460 void DelTapRd_next1_a(DelTapRd *unit, int inNumSamples);
461 void DelTapRd_next2_a(DelTapRd *unit, int inNumSamples);
462 void DelTapRd_next4_a(DelTapRd *unit, int inNumSamples);
463 void DelTapRd_next1_k(DelTapRd *unit, int inNumSamples);
464 void DelTapRd_next1_k_simd(DelTapRd *unit, int inNumSamples);
465 void DelTapRd_next2_k(DelTapRd *unit, int inNumSamples);
466 void DelTapRd_next4_k(DelTapRd *unit, int inNumSamples);
467 }
468
469 //////////////////////////////////////////////////////////////////////////////////////////////////
470
471 void SampleRate_Ctor(Unit *unit, int inNumSamples)
472 {
473 ZOUT0(0) = unit->mWorld->mSampleRate;
474 }
475
476
477 void ControlRate_Ctor(Unit *unit, int inNumSamples)
478 {
479 ZOUT0(0) = unit->mWorld->mBufRate.mSampleRate;
480 }
481
482
483 void SampleDur_Ctor(Unit *unit, int inNumSamples)
484 {
485 ZOUT0(0) = unit->mWorld->mFullRate.mSampleDur;
486 }
487
488 void ControlDur_Ctor(Unit *unit, int inNumSamples)
489 {
490 ZOUT0(0) = unit->mWorld->mFullRate.mBufDuration;
491 }
492
493 void RadiansPerSample_Ctor(Unit *unit, int inNumSamples)
494 {
495 ZOUT0(0) = unit->mWorld->mFullRate.mRadiansPerSample;
496 }
497
498 void SubsampleOffset_Ctor(Unit *unit, int inNumSamples)
499 {
500 ZOUT0(0) = unit->mParent->mSubsampleOffset;
501 }
502
503
504 void NumInputBuses_Ctor(Unit *unit, int inNumSamples)
505 {
506 ZOUT0(0) = unit->mWorld->mNumInputs;
507 }
508
509 void NumOutputBuses_Ctor(Unit *unit, int inNumSamples)
510 {
511 ZOUT0(0) = unit->mWorld->mNumOutputs;
512 }
513
514 void NumAudioBuses_Ctor(Unit *unit, int inNumSamples)
515 {
516 ZOUT0(0) = unit->mWorld->mNumAudioBusChannels;
517 }
518
519 void NumControlBuses_Ctor(Unit *unit, int inNumSamples)
520 {
521 ZOUT0(0) = unit->mWorld->mNumControlBusChannels;
522 }
523
524 void NumBuffers_Ctor(Unit *unit, int inNumSamples)
525 {
526 ZOUT0(0) = unit->mWorld->mNumSndBufs;
527 }
528
529 //////////////////////////////////////////////////////////////////////////////////////////////////
530
531 void NumRunningSynths_Ctor(Unit *unit, int inNumSamples)
532 {
533 if(INRATE(0) != calc_ScalarRate) { SETCALC(NumRunningSynths_next); }
534 ZOUT0(0) = unit->mWorld->mNumGraphs;
535 }
536
537 void NumRunningSynths_next(Unit *unit, int inNumSamples)
538 {
539 ZOUT0(0) = unit->mWorld->mNumGraphs;
540 }
541
542
543 //////////////////////////////////////////////////////////////////////////////////////////////////
544
545
546 #define CTOR_GET_BUF \
547 float fbufnum = ZIN0(0); \
548 fbufnum = sc_max(0.f, fbufnum); \
549 uint32 bufnum = (int)fbufnum; \
550 World *world = unit->mWorld; \
551 SndBuf *buf; \
552 if (bufnum >= world->mNumSndBufs) { \
553 int localBufNum = bufnum - world->mNumSndBufs; \
554 Graph *parent = unit->mParent; \
555 if(localBufNum <= parent->localBufNum) { \
556 buf = parent->mLocalSndBufs + localBufNum; \
557 } else { \
558 bufnum = 0; \
559 buf = world->mSndBufs + bufnum; \
560 } \
561 } else { \
562 buf = world->mSndBufs + bufnum; \
563 }
564
565 void BufSampleRate_next(BufInfoUnit *unit, int inNumSamples)
566 {
567 SIMPLE_GET_BUF_SHARED
568 ZOUT0(0) = buf->samplerate;
569 }
570
571 void BufSampleRate_Ctor(BufInfoUnit *unit, int inNumSamples)
572 {
573 SETCALC(BufSampleRate_next);
574 CTOR_GET_BUF
575 unit->m_fbufnum = fbufnum;
576 unit->m_buf = buf;
577 ZOUT0(0) = buf->samplerate;
578 }
579
580
581 void BufFrames_next(BufInfoUnit *unit, int inNumSamples)
582 {
583 SIMPLE_GET_BUF_SHARED
584 ZOUT0(0) = buf->frames;
585 }
586
587 void BufFrames_Ctor(BufInfoUnit *unit, int inNumSamples)
588 {
589 SETCALC(BufFrames_next);
590 CTOR_GET_BUF
591 unit->m_fbufnum = fbufnum;
592 unit->m_buf = buf;
593 ZOUT0(0) = buf->frames;
594 }
595
596
597 void BufDur_next(BufInfoUnit *unit, int inNumSamples)
598 {
599 SIMPLE_GET_BUF_SHARED
600 ZOUT0(0) = buf->frames * buf->sampledur;
601 }
602
603 void BufDur_Ctor(BufInfoUnit *unit, int inNumSamples)
604 {
605 SETCALC(BufDur_next);
606 CTOR_GET_BUF
607 unit->m_fbufnum = fbufnum;
608 unit->m_buf = buf;
609 ZOUT0(0) = buf->frames * buf->sampledur;
610 }
611
612
613 void BufChannels_next(BufInfoUnit *unit, int inNumSamples)
614 {
615 SIMPLE_GET_BUF_SHARED
616 ZOUT0(0) = buf->channels;
617 }
618
619 void BufChannels_Ctor(BufInfoUnit *unit, int inNumSamples)
620 {
621 SETCALC(BufChannels_next);
622 CTOR_GET_BUF
623 unit->m_fbufnum = fbufnum;
624 unit->m_buf = buf;
625 ZOUT0(0) = buf->channels;
626 }
627
628
629 void BufSamples_next(BufInfoUnit *unit, int inNumSamples)
630 {
631 SIMPLE_GET_BUF_SHARED
632 ZOUT0(0) = buf->samples;
633 }
634
635 void BufSamples_Ctor(BufInfoUnit *unit, int inNumSamples)
636 {
637 SETCALC(BufSamples_next);
638 CTOR_GET_BUF
639 unit->m_fbufnum = fbufnum;
640 unit->m_buf = buf;
641 ZOUT0(0) = buf->samples;
642 }
643
644
645 void BufRateScale_next(BufInfoUnit *unit, int inNumSamples)
646 {
647 SIMPLE_GET_BUF_SHARED
648 ZOUT0(0) = buf->samplerate * unit->mWorld->mFullRate.mSampleDur;
649 }
650
651 void BufRateScale_Ctor(BufInfoUnit *unit, int inNumSamples)
652 {
653 SETCALC(BufRateScale_next);
654 CTOR_GET_BUF
655 unit->m_fbufnum = fbufnum;
656 unit->m_buf = buf;
657 ZOUT0(0) = buf->samplerate * unit->mWorld->mFullRate.mSampleDur;
658 }
659
660 //////////////////////////////////////////////////////////////////////////////////////////////////
661
662 inline int32 BUFMASK(int32 x)
663 {
664 return (1 << (31 - CLZ(x))) - 1;
665 }
666
667
668 static void LocalBuf_allocBuffer(LocalBuf *unit, SndBuf *buf, int numChannels, int numFrames)
669 {
670 int numSamples = numFrames * numChannels;
671 // Print("bufnum: %i, allocating %i channels and %i frames. memsize: %i\n", (int)unit->m_fbufnum, numChannels, numFrames, numSamples * sizeof(float));
672 buf->data = (float*)RTAlloc(unit->mWorld, numSamples * sizeof(float));
673
674 if (!buf->data) {
675 if(unit->mWorld->mVerbosity > -2){
676 Print("failed to allocate memory for LocalBuffer\n");
677 }
678 return;
679 }
680
681 buf->channels = numChannels;
682 buf->frames = numFrames;
683 buf->samples = numSamples;
684 buf->mask = BUFMASK(numSamples); // for delay lines
685 buf->mask1 = buf->mask - 1; // for oscillators
686 buf->samplerate = unit->mWorld->mSampleRate;
687 buf->sampledur = 1. / buf->samplerate;
688 #if SUPERNOVA
689 buf->isLocal = true;
690 #endif
691 }
692
693
694
695
696 void LocalBuf_Ctor(LocalBuf *unit)
697 {
698 Graph *parent = unit->mParent;
699
700 int offset = unit->mWorld->mNumSndBufs;
701 int bufnum = parent->localBufNum;
702 float fbufnum;
703
704 if (parent->localBufNum >= parent->localMaxBufNum) {
705 fbufnum = -1.f;
706 if(unit->mWorld->mVerbosity > -2)
707 printf("warning: LocalBuf tried to allocate too many local buffers.\n");
708 } else {
709 fbufnum = (float) (bufnum + offset);
710 unit->m_buf = parent->mLocalSndBufs + bufnum;
711 parent->localBufNum = parent->localBufNum + 1;
712
713 LocalBuf_allocBuffer(unit, unit->m_buf, (int)IN0(0), (int)IN0(1));
714 }
715
716 OUT0(0) = fbufnum;
717 }
718
719 void LocalBuf_Dtor(LocalBuf *unit)
720 {
721 RTFree(unit->mWorld, unit->m_buf->data);
722 if(unit->mParent->localBufNum <= 1) { // only the last time.
723 for (int i = 0; i != unit->mParent->localMaxBufNum; ++i)
724 unit->mParent->mLocalSndBufs[i].~SndBuf();
725 RTFree(unit->mWorld, unit->mParent->mLocalSndBufs);
726 unit->mParent->localMaxBufNum = 0;
727 } else {
728 unit->mParent->localBufNum = unit->mParent->localBufNum - 1;
729 }
730 }
731
732
733 //////////////////////////////////////////////////////////////////////////////////////////////////
734
735 void MaxLocalBufs_Ctor(MaxLocalBufs *unit)
736 {
737 Graph *parent = unit->mParent;
738
739 int offset = unit->mWorld->mNumSndBufs;
740 int bufnum = parent->localBufNum;
741 int maxBufNum = (int)(IN0(0) + .5f);
742 if(!parent->localMaxBufNum) {
743 parent->mLocalSndBufs = (SndBuf*)RTAlloc(unit->mWorld, maxBufNum * sizeof(SndBuf));
744 #ifdef SUPERNOVA
745 for (int i = 0; i != maxBufNum; ++i)
746 new(&parent->mLocalSndBufs[i]) SndBuf();
747 #endif
748 parent->localMaxBufNum = maxBufNum;
749 } else {
750 printf("warning: MaxLocalBufs - maximum number of local buffers is already declared (%i) and must remain unchanged.\n", parent->localMaxBufNum);
751 }
752
753 }
754
755 //////////////////////////////////////////////////////////////////////////////////////////////////
756
757 void SetBuf_Ctor(SetBuf *unit)
758 {
759 OUT0(0) = 0.f;
760 CTOR_GET_BUF
761 if (!buf || !buf->data) {
762 if(unit->mWorld->mVerbosity > -2){
763 Print("SetBuf: no valid buffer\n");
764 }
765 return;
766 }
767
768 int offset = (int)IN0(1);
769 int numArgs = (int)IN0(2);
770 int end = sc_min(buf->samples, numArgs + offset);
771
772 int j = 3;
773 for(int i=offset; i<end; ++j, ++i) {
774 buf->data[i] = IN0(j);
775 }
776 }
777
778
779 //////////////////////////////////////////////////////////////////////////////////////////////////
780
781 void ClearBuf_Ctor(ClearBuf *unit)
782 {
783 OUT0(0) = 0.f;
784 CTOR_GET_BUF
785
786 if (!buf || !buf->data) {
787 if(unit->mWorld->mVerbosity > -2){
788 Print("ClearBuf: no valid buffer\n");
789 }
790 return;
791 }
792
793 Clear(buf->samples, buf->data);
794 }
795
796
797 ////////////////////////////////////////////////////////////////////////////////////////////////////////
798
799 inline double sc_loop(Unit *unit, double in, double hi, int loop)
800 {
801 // avoid the divide if possible
802 if (in >= hi) {
803 if (!loop) {
804 unit->mDone = true;
805 return hi;
806 }
807 in -= hi;
808 if (in < hi) return in;
809 } else if (in < 0.) {
810 if (!loop) {
811 unit->mDone = true;
812 return 0.;
813 }
814 in += hi;
815 if (in >= 0.) return in;
816 } else return in;
817
818 return in - hi * floor(in/hi);
819 }
820
821 #define CHECK_BUF \
822 if (!bufData) { \
823 unit->mDone = true; \
824 ClearUnitOutputs(unit, inNumSamples); \
825 return; \
826 }
827
828 static inline bool checkBuffer(Unit * unit, const float * bufData, uint32 bufChannels,
829 uint32 expectedChannels, int inNumSamples)
830 {
831 if (!bufData)
832 goto handle_failure;
833
834 if (expectedChannels > bufChannels) {
835 if(unit->mWorld->mVerbosity > -1 && !unit->mDone)
836 Print("Buffer UGen channel mismatch: expected %i, yet buffer has %i channels\n",
837 expectedChannels, bufChannels);
838 goto handle_failure;
839 }
840 return true;
841
842 handle_failure:
843 unit->mDone = true;
844 ClearUnitOutputs(unit, inNumSamples);
845 return false;
846 }
847
848 #define SETUP_IN(offset) \
849 uint32 numInputs = unit->mNumInputs - (uint32)offset; \
850 if (numInputs != bufChannels) { \
851 if(unit->mWorld->mVerbosity > -1 && !unit->mDone){ \
852 Print("buffer-writing UGen channel mismatch: numInputs %i, yet buffer has %i channels\n", numInputs, bufChannels); \
853 } \
854 unit->mDone = true; \
855 ClearUnitOutputs(unit, inNumSamples); \
856 return; \
857 } \
858 if(!unit->mIn){ \
859 unit->mIn = (float**)RTAlloc(unit->mWorld, numInputs * sizeof(float*)); \
860 if (unit->mIn == NULL) { \
861 unit->mDone = true; \
862 ClearUnitOutputs(unit, inNumSamples); \
863 return; \
864 } \
865 } \
866 float **in = unit->mIn; \
867 for (uint32 i=0; i<numInputs; ++i) { \
868 in[i] = ZIN(i+offset); \
869 }
870
871 #define TAKEDOWN_IN \
872 if(unit->mIn){ \
873 RTFree(unit->mWorld, unit->mIn); \
874 }
875
876
877 #define LOOP_BODY_4(SAMPLE_INDEX) \
878 phase = sc_loop((Unit*)unit, phase, loopMax, loop); \
879 int32 iphase = (int32)phase; \
880 const float* table1 = bufData + iphase * bufChannels; \
881 const float* table0 = table1 - bufChannels; \
882 const float* table2 = table1 + bufChannels; \
883 const float* table3 = table2 + bufChannels; \
884 if (iphase == 0) { \
885 if (loop) { \
886 table0 += bufSamples; \
887 } else { \
888 table0 += bufChannels; \
889 } \
890 } else if (iphase >= guardFrame) { \
891 if (iphase == guardFrame) { \
892 if (loop) { \
893 table3 -= bufSamples; \
894 } else { \
895 table3 -= bufChannels; \
896 } \
897 } else { \
898 if (loop) { \
899 table2 -= bufSamples; \
900 table3 -= bufSamples; \
901 } else { \
902 table2 -= bufChannels; \
903 table3 -= 2 * bufChannels; \
904 } \
905 } \
906 } \
907 int32 index = 0; \
908 float fracphase = phase - (double)iphase; \
909 for (uint32 channel=0; channel<numOutputs; ++channel) { \
910 float a = table0[index]; \
911 float b = table1[index]; \
912 float c = table2[index]; \
913 float d = table3[index]; \
914 OUT(channel)[SAMPLE_INDEX] = cubicinterp(fracphase, a, b, c, d); \
915 index++; \
916 }
917
918 #define LOOP_BODY_2(SAMPLE_INDEX) \
919 phase = sc_loop((Unit*)unit, phase, loopMax, loop); \
920 int32 iphase = (int32)phase; \
921 const float* table1 = bufData + iphase * bufChannels; \
922 const float* table2 = table1 + bufChannels; \
923 if (iphase > guardFrame) { \
924 if (loop) { \
925 table2 -= bufSamples; \
926 } else { \
927 table2 -= bufChannels; \
928 } \
929 } \
930 int32 index = 0; \
931 float fracphase = phase - (double)iphase; \
932 for (uint32 channel=0; channel<numOutputs; ++channel) { \
933 float b = table1[index]; \
934 float c = table2[index]; \
935 OUT(channel)[SAMPLE_INDEX] = b + fracphase * (c - b); \
936 index++; \
937 }
938
939 #define LOOP_BODY_1(SAMPLE_INDEX) \
940 phase = sc_loop((Unit*)unit, phase, loopMax, loop); \
941 int32 iphase = (int32)phase; \
942 const float* table1 = bufData + iphase * bufChannels; \
943 int32 index = 0; \
944 for (uint32 channel=0; channel<numOutputs; ++channel) { \
945 OUT(channel)[SAMPLE_INDEX] = table1[index++]; \
946 }
947
948
949 void PlayBuf_Ctor(PlayBuf *unit)
950 {
951 if (INRATE(1) == calc_FullRate) {
952 if (INRATE(2) == calc_FullRate) {
953 SETCALC(PlayBuf_next_aa);
954 } else {
955 SETCALC(PlayBuf_next_ak);
956 }
957 } else {
958 if (INRATE(2) == calc_FullRate) {
959 SETCALC(PlayBuf_next_ka);
960 } else {
961 SETCALC(PlayBuf_next_kk);
962 }
963 }
964
965 unit->m_fbufnum = -1e9f;
966 unit->m_prevtrig = 0.;
967 unit->m_phase = ZIN0(3);
968
969 ClearUnitOutputs(unit, 1);
970 }
971
972 void PlayBuf_next_aa(PlayBuf *unit, int inNumSamples)
973 {
974 float *ratein = ZIN(1);
975 float *trigin = ZIN(2);
976 int32 loop = (int32)ZIN0(4);
977
978 float fbufnum = ZIN0(0);
979 if (fbufnum != unit->m_fbufnum) {
980 uint32 bufnum = (int)fbufnum;
981 World *world = unit->mWorld;
982 if (bufnum >= world->mNumSndBufs) bufnum = 0;
983 unit->m_fbufnum = fbufnum;
984 unit->m_buf = world->mSndBufs + bufnum;
985 }
986 const SndBuf *buf = unit->m_buf;
987 ACQUIRE_SNDBUF_SHARED(buf);
988 const float *bufData __attribute__((__unused__)) = buf->data;
989 uint32 bufChannels __attribute__((__unused__)) = buf->channels;
990 uint32 bufSamples __attribute__((__unused__)) = buf->samples;
991 uint32 bufFrames = buf->frames;
992 int mask __attribute__((__unused__)) = buf->mask;
993 int guardFrame __attribute__((__unused__)) = bufFrames - 2;
994
995 int numOutputs = unit->mNumOutputs;
996 if (!checkBuffer(unit, bufData, bufChannels, numOutputs, inNumSamples))
997 return;
998
999 double loopMax = (double)(loop ? bufFrames : bufFrames - 1);
1000 double phase = unit->m_phase;
1001 float prevtrig = unit->m_prevtrig;
1002
1003 for (int i=0; i<inNumSamples; ++i) {
1004 float trig = ZXP(trigin);
1005 if (trig > 0.f && prevtrig <= 0.f) {
1006 unit->mDone = false;
1007 phase = ZIN0(3);
1008 }
1009 prevtrig = trig;
1010
1011 LOOP_BODY_4(i)
1012
1013 phase += ZXP(ratein);
1014 }
1015 RELEASE_SNDBUF_SHARED(buf);
1016
1017 if(unit->mDone)
1018 DoneAction((int)ZIN0(5), unit);
1019 unit->m_phase = phase;
1020 unit->m_prevtrig = prevtrig;
1021 }
1022
1023 void PlayBuf_next_ak(PlayBuf *unit, int inNumSamples)
1024 {
1025 float *ratein = ZIN(1);
1026 float trig = ZIN0(2);
1027 int32 loop = (int32)ZIN0(4);
1028
1029 float fbufnum = ZIN0(0);
1030 if (fbufnum != unit->m_fbufnum) {
1031 uint32 bufnum = (int)fbufnum;
1032 World *world = unit->mWorld;
1033 if (bufnum >= world->mNumSndBufs) bufnum = 0;
1034 unit->m_fbufnum = fbufnum;
1035 unit->m_buf = world->mSndBufs + bufnum;
1036 }
1037 const SndBuf *buf = unit->m_buf;
1038 ACQUIRE_SNDBUF_SHARED(buf);
1039 const float *bufData __attribute__((__unused__)) = buf->data;
1040 uint32 bufChannels __attribute__((__unused__)) = buf->channels;
1041 uint32 bufSamples __attribute__((__unused__)) = buf->samples;
1042 uint32 bufFrames = buf->frames;
1043 int mask __attribute__((__unused__)) = buf->mask;
1044 int guardFrame __attribute__((__unused__)) = bufFrames - 2;
1045
1046 int numOutputs = unit->mNumOutputs;
1047 if (!checkBuffer(unit, bufData, bufChannels, numOutputs, inNumSamples))
1048 return;
1049
1050 double loopMax = (double)(loop ? bufFrames : bufFrames - 1);
1051 double phase = unit->m_phase;
1052 if(phase == -1.) phase = bufFrames;
1053 if (trig > 0.f && unit->m_prevtrig <= 0.f) {
1054 unit->mDone = false;
1055 phase = ZIN0(3);
1056 }
1057 unit->m_prevtrig = trig;
1058 for (int i=0; i<inNumSamples; ++i) {
1059
1060 LOOP_BODY_4(i)
1061
1062 phase += ZXP(ratein);
1063 }
1064 RELEASE_SNDBUF_SHARED(buf);
1065 if(unit->mDone)
1066 DoneAction((int)ZIN0(5), unit);
1067 unit->m_phase = phase;
1068 }
1069
1070 void PlayBuf_next_kk(PlayBuf *unit, int inNumSamples)
1071 {
1072 float rate = ZIN0(1);
1073 float trig = ZIN0(2);
1074 int32 loop = (int32)ZIN0(4);
1075
1076 GET_BUF_SHARED
1077 int numOutputs = unit->mNumOutputs;
1078 if (!checkBuffer(unit, bufData, bufChannels, numOutputs, inNumSamples))
1079 return;
1080
1081 double loopMax = (double)(loop ? bufFrames : bufFrames - 1);
1082 double phase = unit->m_phase;
1083 if (trig > 0.f && unit->m_prevtrig <= 0.f) {
1084 unit->mDone = false;
1085 phase = ZIN0(3);
1086 }
1087 unit->m_prevtrig = trig;
1088 for (int i=0; i<inNumSamples; ++i) {
1089 LOOP_BODY_4(i)
1090
1091 phase += rate;
1092 }
1093 if(unit->mDone)
1094 DoneAction((int)ZIN0(5), unit);
1095 unit->m_phase = phase;
1096 }
1097
1098 void PlayBuf_next_ka(PlayBuf *unit, int inNumSamples)
1099 {
1100 float rate = ZIN0(1);
1101 float *trigin = ZIN(2);
1102 int32 loop = (int32)ZIN0(4);
1103
1104 GET_BUF_SHARED
1105 int numOutputs = unit->mNumOutputs;
1106 if (!checkBuffer(unit, bufData, bufChannels, numOutputs, inNumSamples))
1107 return;
1108
1109 double loopMax = (double)(loop ? bufFrames : bufFrames - 1);
1110 double phase = unit->m_phase;
1111 float prevtrig = unit->m_prevtrig;
1112 for (int i=0; i<inNumSamples; ++i) {
1113 float trig = ZXP(trigin);
1114 if (trig > 0.f && prevtrig <= 0.f) {
1115 unit->mDone = false;
1116 if (INRATE(3) == calc_FullRate) phase = IN(3)[i];
1117 else phase = ZIN0(3);
1118 }
1119 prevtrig = trig;
1120
1121 LOOP_BODY_4(i)
1122
1123 phase += rate;
1124 }
1125 if(unit->mDone)
1126 DoneAction((int)ZIN0(5), unit);
1127 unit->m_phase = phase;
1128 unit->m_prevtrig = prevtrig;
1129 }
1130
1131
1132 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1133
1134 void BufRd_Ctor(BufRd *unit)
1135 {
1136 int interp = (int)ZIN0(3);
1137 switch (interp) {
1138 case 1 : SETCALC(BufRd_next_1); break;
1139 case 2 : SETCALC(BufRd_next_2); break;
1140 default : SETCALC(BufRd_next_4); break;
1141 }
1142
1143 unit->m_fbufnum = -1e9f;
1144
1145 BufRd_next_1(unit, 1);
1146 }
1147
1148 void BufRd_next_4(BufRd *unit, int inNumSamples)
1149 {
1150 float *phasein = ZIN(1);
1151 int32 loop = (int32)ZIN0(2);
1152
1153 GET_BUF_SHARED
1154 uint32 numOutputs = unit->mNumOutputs;
1155 if (!checkBuffer(unit, bufData, bufChannels, numOutputs, inNumSamples))
1156 return;
1157
1158 double loopMax = (double)(loop ? bufFrames : bufFrames - 1);
1159
1160 for (int i=0; i<inNumSamples; ++i) {
1161 double phase = ZXP(phasein);
1162 LOOP_BODY_4(i)
1163 }
1164 }
1165
1166 void BufRd_next_2(BufRd *unit, int inNumSamples)
1167 {
1168 float *phasein = ZIN(1);
1169 int32 loop = (int32)ZIN0(2);
1170
1171 GET_BUF_SHARED
1172 uint32 numOutputs = unit->mNumOutputs;
1173 if (!checkBuffer(unit, bufData, bufChannels, numOutputs, inNumSamples))
1174 return;
1175
1176 double loopMax = (double)(loop ? bufFrames : bufFrames - 1);
1177
1178 for (int i=0; i<inNumSamples; ++i) {
1179 double phase = ZXP(phasein);
1180 LOOP_BODY_2(i)
1181 }
1182 }
1183
1184 void BufRd_next_1(BufRd *unit, int inNumSamples)
1185 {
1186 float *phasein = ZIN(1);
1187 int32 loop = (int32)ZIN0(2);
1188
1189 GET_BUF_SHARED
1190 uint32 numOutputs = unit->mNumOutputs;
1191 if (!checkBuffer(unit, bufData, bufChannels, numOutputs, inNumSamples))
1192 return;
1193
1194 double loopMax = (double)(loop ? bufFrames : bufFrames - 1);
1195
1196 for (int i=0; i<inNumSamples; ++i) {
1197 double phase = ZXP(phasein);
1198 LOOP_BODY_1(i)
1199 }
1200 }
1201
1202 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1203
1204 void BufWr_Ctor(BufWr *unit)
1205 {
1206 SETCALC(BufWr_next);
1207
1208 unit->m_fbufnum = -1e9f;
1209
1210 ClearUnitOutputs(unit, 1);
1211 }
1212
1213 void BufWr_next(BufWr *unit, int inNumSamples)
1214 {
1215 float *phasein = ZIN(1);
1216 int32 loop = (int32)ZIN0(2);
1217
1218 GET_BUF
1219 uint32 numInputChannels = unit->mNumInputs - 3;
1220 if (!checkBuffer(unit, bufData, bufChannels, numInputChannels, inNumSamples))
1221 return;
1222
1223 double loopMax = (double)(bufFrames - (loop ? 0 : 1));
1224
1225 for (int32 k=0; k<inNumSamples; ++k) {
1226 double phase = sc_loop((Unit*)unit, ZXP(phasein), loopMax, loop);
1227 int32 iphase = (int32)phase;
1228 float* table0 = bufData + iphase * bufChannels;
1229 for (uint32 channel=0; channel<numInputChannels; ++channel)
1230 table0[channel] = IN(channel+3)[k];
1231 }
1232 }
1233
1234 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1235
1236 //bufnum=0, offset=0.0, recLevel=1.0, preLevel=0.0, run=1.0, loop=1.0, trigger=1.0
1237
1238 void RecordBuf_Ctor(RecordBuf *unit)
1239 {
1240
1241 uint32 numInputs = unit->mNumInputs - 8;
1242 unit->m_fbufnum = -1e9f;
1243 unit->mIn = 0;
1244 unit->m_writepos = (int32)ZIN0(1) * numInputs;
1245 unit->m_recLevel = ZIN0(2);
1246 unit->m_preLevel = ZIN0(3);
1247
1248 if (INRATE(2) == calc_ScalarRate && INRATE(3) == calc_ScalarRate
1249 && unit->m_recLevel == 1.0 && unit->m_preLevel == 0.0)
1250 {
1251 SETCALC(RecordBuf_next_10);
1252 } else {
1253 SETCALC(RecordBuf_next);
1254 }
1255
1256 ClearUnitOutputs(unit, 1);
1257 }
1258
1259 void RecordBuf_Dtor(RecordBuf *unit)
1260 {
1261 TAKEDOWN_IN
1262 }
1263
1264 void RecordBuf_next(RecordBuf *unit, int inNumSamples)
1265 {
1266 //printf("RecordBuf_next\n");
1267 GET_BUF
1268 CHECK_BUF
1269 SETUP_IN(8)
1270
1271 float recLevel = ZIN0(2);
1272 float preLevel = ZIN0(3);
1273 float run = ZIN0(4);
1274 int32 loop = (int32)ZIN0(5);
1275 float trig = ZIN0(6);
1276 //printf("loop %d run %g\n", loop, run);
1277
1278 int32 writepos = unit->m_writepos;
1279
1280 float recLevel_slope = CALCSLOPE(recLevel, unit->m_recLevel);
1281 float preLevel_slope = CALCSLOPE(preLevel, unit->m_preLevel);
1282
1283 /* reset recLevel and preLevel to use the previous value ... bug fix */
1284 recLevel = unit->m_recLevel;
1285 preLevel = unit->m_preLevel;
1286
1287 if (loop) {
1288 if (trig > 0.f && unit->m_prevtrig <= 0.f) {
1289 unit->mDone = false;
1290 writepos = (int32)ZIN0(1) * bufChannels;
1291 }
1292 if (writepos < 0) writepos = bufSamples - bufChannels;
1293 else if (writepos >= (int32)bufSamples) writepos = 0;
1294 if (run > 0.f) {
1295 if (bufChannels == 1) {
1296 for (int32 k=0; k<inNumSamples; ++k) {
1297 float* table0 = bufData + writepos;
1298 table0[0] = *++(in[0]) * recLevel + table0[0] * preLevel;
1299 writepos += 1;
1300 if (writepos >= (int32)bufSamples) writepos = 0;
1301
1302 recLevel += recLevel_slope;
1303 preLevel += preLevel_slope;
1304 }
1305 } else if (bufChannels == 2 && numInputs == 2) {
1306 for (int32 k=0; k<inNumSamples; ++k) {
1307 float* table0 = bufData + writepos;
1308 table0[0] = *++(in[0]) * recLevel + table0[0] * preLevel;
1309 table0[1] = *++(in[1]) * recLevel + table0[1] * preLevel;
1310 writepos += 2;
1311 if (writepos >= (int32)bufSamples) writepos = 0;
1312
1313 recLevel += recLevel_slope;
1314 preLevel += preLevel_slope;
1315 }
1316 } else {
1317 for (int32 k=0; k<inNumSamples; ++k) {
1318 float* table0 = bufData + writepos;
1319 for (uint32 i=0; i<numInputs; ++i) {
1320 float *samp = table0 + i;
1321 *samp = *++(in[i]) * recLevel + *samp * preLevel;
1322 }
1323 writepos += bufChannels;
1324 if (writepos >= (int32)bufSamples) writepos = 0;
1325
1326 recLevel += recLevel_slope;
1327 preLevel += preLevel_slope;
1328 }
1329 }
1330 } else if (run < 0.f) {
1331 if (bufChannels == 1) {
1332 for (int32 k=0; k<inNumSamples; ++k) {
1333 float* table0 = bufData + writepos;
1334 table0[0] = *++(in[0]) * recLevel + table0[0] * preLevel;
1335 writepos -= 1;
1336 if (writepos < 0) writepos = bufSamples - bufChannels;
1337
1338 recLevel += recLevel_slope;
1339 preLevel += preLevel_slope;
1340 }
1341 } else if (bufChannels == 2 && numInputs == 2) {
1342 for (int32 k=0; k<inNumSamples; ++k) {
1343 float* table0 = bufData + writepos;
1344 table0[0] = *++(in[0]) * recLevel + table0[0] * preLevel;
1345 table0[1] = *++(in[1]) * recLevel + table0[1] * preLevel;
1346 writepos -= 2;
1347 if (writepos < 0) writepos = bufSamples - bufChannels;
1348
1349 recLevel += recLevel_slope;
1350 preLevel += preLevel_slope;
1351 }
1352 } else {
1353 for (int32 k=0; k<inNumSamples; ++k) {
1354 float* table0 = bufData + writepos;
1355 for (uint32 i=0; i<numInputs; ++i) {
1356 float *samp = table0 + i;
1357 *samp = *++(in[i]) * recLevel + *samp * preLevel;
1358 }
1359 writepos -= bufChannels;
1360 if (writepos < 0) writepos = bufSamples - bufChannels;
1361
1362 recLevel += recLevel_slope;
1363 preLevel += preLevel_slope;
1364 }
1365 }
1366 }
1367 } else {
1368 if (trig > 0.f && unit->m_prevtrig <= 0.f) {
1369 unit->mDone = false;
1370 writepos = (int32)ZIN0(1) * bufChannels;
1371 }
1372 if (run > 0.f) {
1373 int nsmps = bufSamples - writepos;
1374 nsmps = sc_clip(nsmps, 0, inNumSamples);
1375 if (bufChannels == 1) {
1376 for (int32 k=0; k<nsmps; ++k) {
1377 float* table0 = bufData + writepos;
1378 table0[0] = *++(in[0]) * recLevel + table0[0] * preLevel;
1379 writepos += 1;
1380
1381 recLevel += recLevel_slope;
1382 preLevel += preLevel_slope;
1383 }
1384 } else if (bufChannels == 2 && numInputs == 2) {
1385 for (int32 k=0; k<nsmps; ++k) {
1386 float* table0 = bufData + writepos;
1387 table0[0] = *++(in[0]) * recLevel + table0[0] * preLevel;
1388 table0[1] = *++(in[1]) * recLevel + table0[1] * preLevel;
1389 writepos += 2;
1390
1391 recLevel += recLevel_slope;
1392 preLevel += preLevel_slope;
1393 }
1394 } else {
1395 for (int32 k=0; k<nsmps; ++k) {
1396 float* table0 = bufData + writepos;
1397 for (uint32 i=0; i<numInputs; ++i) {
1398 float *samp = table0 + i;
1399 *samp = *++(in[i]) * recLevel + *samp * preLevel;
1400 }
1401 writepos += bufChannels;
1402
1403 recLevel += recLevel_slope;
1404 preLevel += preLevel_slope;
1405 }
1406 }
1407 } else if (run < 0.f) {
1408 int nsmps = writepos;
1409 nsmps = sc_clip(nsmps, 0, inNumSamples);
1410 if (bufChannels == 1) {
1411 for (int32 k=0; k<inNumSamples; ++k) {
1412 float* table0 = bufData + writepos;
1413 table0[0] = *++(in[0]) * recLevel + table0[0] * preLevel;
1414 writepos -= bufChannels;
1415
1416 recLevel += recLevel_slope;
1417 preLevel += preLevel_slope;
1418 }
1419 } else if (bufChannels == 2 && numInputs == 2) {
1420 for (int32 k=0; k<inNumSamples; ++k) {
1421 float* table0 = bufData + writepos;
1422 table0[0] = *++(in[0]) * recLevel + table0[0] * preLevel;
1423 table0[1] = *++(in[1]) * recLevel + table0[1] * preLevel;
1424 writepos -= bufChannels;
1425
1426 recLevel += recLevel_slope;
1427 preLevel += preLevel_slope;
1428 }
1429 } else {
1430 for (int32 k=0; k<inNumSamples; ++k) {
1431 float* table0 = bufData + writepos;
1432 for (uint32 i=0; i<numInputs; ++i) {
1433 float *samp = table0 + i;
1434 *samp = *++(in[i]) * recLevel + *samp * preLevel;
1435 }
1436 writepos -= bufChannels;
1437
1438 recLevel += recLevel_slope;
1439 preLevel += preLevel_slope;
1440 }
1441 }
1442 }
1443 if (writepos >= (int32)bufSamples){
1444 unit->mDone = true;
1445 DoneAction(IN0(7), unit);
1446 }
1447 }
1448 unit->m_prevtrig = trig;
1449 unit->m_writepos = writepos;
1450 unit->m_recLevel = recLevel;
1451 unit->m_preLevel = preLevel;
1452 }
1453
1454 void RecordBuf_next_10(RecordBuf *unit, int inNumSamples)
1455 {
1456 // printf("RecordBuf_next_10\n");
1457 GET_BUF
1458 CHECK_BUF
1459 SETUP_IN(8)
1460
1461 float run = ZIN0(4);
1462 int32 loop = (int32)ZIN0(5);
1463 float trig = ZIN0(6);
1464 //printf("loop %d run %g\n", loop, run);
1465
1466 int32 writepos = unit->m_writepos;
1467
1468 if (loop) {
1469 if (trig > 0.f && unit->m_prevtrig <= 0.f) {
1470 unit->mDone = false;
1471 writepos = (int32)ZIN0(1) * bufChannels;
1472 }
1473 if (writepos < 0) writepos = bufSamples - bufChannels;
1474 else if (writepos >= (int32)bufSamples) writepos = 0;
1475 if (run > 0.f) {
1476 if (bufChannels == 1) {
1477 for (int32 k=0; k<inNumSamples; ++k) {
1478 float* table0 = bufData + writepos;
1479 table0[0] = *++(in[0]);
1480 writepos += 1;
1481 if (writepos >= (int32)bufSamples) writepos = 0;
1482 }
1483 } else if (bufChannels == 2) {
1484 for (int32 k=0; k<inNumSamples; ++k) {
1485 float* table0 = bufData + writepos;
1486 table0[0] = *++(in[0]);
1487 table0[1] = *++(in[1]);
1488 writepos += 2;
1489 if (writepos >= (int32)bufSamples) writepos = 0;
1490 }
1491 } else {
1492 for (int32 k=0; k<inNumSamples; ++k) {
1493 float* table0 = bufData + writepos;
1494 for (uint32 i=0; i<bufChannels; ++i) {
1495 float *samp = table0 + i;
1496 *samp = *++(in[i]);
1497 }
1498 writepos += bufChannels;
1499 if (writepos >= (int32)bufSamples) writepos = 0;
1500 }
1501 }
1502 } else if (run < 0.f) {
1503 if (bufChannels == 1) {
1504 for (int32 k=0; k<inNumSamples; ++k) {
1505 float* table0 = bufData + writepos;
1506 table0[0] = *++(in[0]);
1507 writepos -= 1;
1508 if (writepos < 0) writepos = bufSamples - bufChannels;
1509 }
1510 } else if (bufChannels == 2) {
1511 for (int32 k=0; k<inNumSamples; ++k) {
1512 float* table0 = bufData + writepos;
1513 table0[0] = *++(in[0]);
1514 table0[1] = *++(in[1]);
1515 writepos -= 2;
1516 if (writepos < 0) writepos = bufSamples - bufChannels;
1517 }
1518 } else {
1519 for (int32 k=0; k<inNumSamples; ++k) {
1520 float* table0 = bufData + writepos;
1521 for (uint32 i=0; i<bufChannels; ++i) {
1522 float *samp = table0 + i;
1523 *samp = *++(in[i]);
1524 }
1525 writepos -= bufChannels;
1526 if (writepos < 0) writepos = bufSamples - bufChannels;
1527 }
1528 }
1529 }
1530 } else {
1531 if (trig > 0.f && unit->m_prevtrig <= 0.f) {
1532 unit->mDone = false;
1533 writepos = (int32)ZIN0(1) * bufChannels;
1534 }
1535 if (run > 0.f) {
1536 int nsmps = bufSamples - writepos;
1537 nsmps = sc_clip(nsmps, 0, inNumSamples);
1538 if (bufChannels == 1) {
1539 for (int32 k=0; k<nsmps; ++k) {
1540 float* table0 = bufData + writepos;
1541 table0[0] = *++(in[0]);
1542 writepos += 1;
1543 }
1544 } else if (bufChannels == 2) {
1545 for (int32 k=0; k<nsmps; ++k) {
1546 float* table0 = bufData + writepos;
1547 table0[0] = *++(in[0]);
1548 table0[1] = *++(in[1]);
1549 writepos += 2;
1550 if (writepos >= (int32)bufSamples) writepos = (int32)bufSamples - 2; // added by jrhb
1551 }
1552 } else {
1553 for (int32 k=0; k<nsmps; ++k) {
1554 float* table0 = bufData + writepos;
1555 for (uint32 i=0; i<bufChannels; ++i) {
1556 float *samp = table0 + i;
1557 *samp = *++(in[i]);
1558 }
1559 writepos += bufChannels;
1560 if (writepos >= (int32)bufSamples) writepos = (int32)bufSamples - bufChannels; // added by jrhb
1561 }
1562 }
1563 } else if (run < 0.f) {
1564 int nsmps = writepos;
1565 nsmps = sc_clip(nsmps, 0, inNumSamples);
1566 if (bufChannels == 1) {
1567 for (int32 k=0; k<inNumSamples; ++k) {
1568 float* table0 = bufData + writepos;
1569 table0[0] = *++(in[0]);
1570 writepos -= 1;
1571 }
1572 } else if (bufChannels == 2) {
1573 for (int32 k=0; k<inNumSamples; ++k) {
1574 float* table0 = bufData + writepos;
1575 table0[0] = *++(in[0]);
1576 table0[1] = *++(in[1]);
1577 writepos -= 2;
1578 }
1579 } else {
1580 for (int32 k=0; k<inNumSamples; ++k) {
1581 float* table0 = bufData + writepos;
1582 for (uint32 i=0; i<bufChannels; ++i) {
1583 float *samp = table0 + i;
1584 *samp = *++(in[i]);
1585 }
1586 writepos -= bufChannels;
1587 }
1588 }
1589 }
1590 if (writepos >= (int32)bufSamples){
1591 unit->mDone = true;
1592 DoneAction(IN0(7), unit);
1593 }
1594 }
1595 unit->m_prevtrig = trig;
1596 unit->m_writepos = writepos;
1597 }
1598
1599
1600 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1601
1602 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1603
1604
1605
1606 static float insertMedian(float* values, int* ages, int size, float value)
1607 {
1608 int pos=-1;
1609
1610 // keeps a sorted list of the previous n=size values
1611 // the oldest is removed and the newest is inserted.
1612 // values between the oldest and the newest are shifted over by one.
1613
1614 // values and ages are both arrays that are 'size' int.
1615 // the median value is always values[size>>1]
1616
1617 int last = size - 1;
1618 // find oldest bin and age the other bins.
1619 for (int i=0; i<size; ++i) {
1620 if (ages[i] == last) { // is it the oldest bin ?
1621 pos = i;
1622 } else {
1623 ages[i]++; // age the bin
1624 }
1625 }
1626 // move values to fill in place of the oldest and make a space for the newest
1627 // search lower if value is too small for the open space
1628 while (pos != 0 && value < values[pos-1]) {
1629 values[pos] = values[pos-1];
1630 ages[pos] = ages[pos-1];
1631 pos--;
1632 }
1633 // search higher if value is too big for the open space
1634 while (pos != last && value > values[pos+1]) {
1635 values[pos] = values[pos+1];
1636 ages[pos] = ages[pos+1];
1637 pos++;
1638 }
1639 values[pos] = value;
1640 ages[pos] = 0; // this is the newest bin, age = 0
1641 return values[size>>1];
1642 }
1643
1644 static void initMedian(float* values, int* ages, int size, float value)
1645 {
1646 // initialize the arrays with the first value
1647 for (int i=0; i<size; ++i) {
1648 values[i] = value;
1649 ages[i] = i;
1650 }
1651 }
1652
1653
1654
1655
1656 enum {
1657 kPitchIn,
1658 kPitchInitFreq,
1659 kPitchMinFreq,
1660 kPitchMaxFreq,
1661 kPitchExecFreq,
1662 kPitchMaxBins,
1663 kPitchMedian,
1664 kPitchAmpThreshold,
1665 kPitchPeakThreshold,
1666 kPitchDownsamp,
1667 kPitchGetClarity
1668 };
1669
1670 void Pitch_Ctor(Pitch *unit)
1671 {
1672 unit->m_freq = ZIN0(kPitchInitFreq);
1673 unit->m_minfreq = ZIN0(kPitchMinFreq);
1674 unit->m_maxfreq = ZIN0(kPitchMaxFreq);
1675
1676 float execfreq = ZIN0(kPitchExecFreq);
1677 execfreq = sc_clip(execfreq, unit->m_minfreq, unit->m_maxfreq);
1678
1679 int maxbins = (int)ZIN0(kPitchMaxBins);
1680 unit->m_maxlog2bins = LOG2CEIL(maxbins);
1681
1682 unit->m_medianSize = sc_clip((int)ZIN0(0), 0, kMAXMEDIANSIZE); // (int)ZIN0(kPitchMedian);
1683 unit->m_ampthresh = ZIN0(kPitchAmpThreshold);
1684 unit->m_peakthresh = ZIN0(kPitchPeakThreshold);
1685
1686 int downsamp = (int)ZIN0(kPitchDownsamp);
1687
1688 if (INRATE(kPitchIn) == calc_FullRate) {
1689 SETCALC(Pitch_next_a);
1690 unit->m_downsamp = sc_clip(downsamp, 1, unit->mWorld->mFullRate.mBufLength);
1691 unit->m_srate = FULLRATE / (float)unit->m_downsamp;
1692 } else {
1693 SETCALC(Pitch_next_k);
1694 unit->m_downsamp = sc_max(downsamp, 1);
1695 unit->m_srate = FULLRATE / (float) (unit->mWorld->mFullRate.mBufLength*unit->m_downsamp);
1696 }
1697
1698 unit->m_minperiod = (long)(unit->m_srate / unit->m_maxfreq);
1699 unit->m_maxperiod = (long)(unit->m_srate / unit->m_minfreq);
1700
1701 unit->m_execPeriod = (int)(unit->m_srate / execfreq);
1702 unit->m_execPeriod = sc_max(unit->m_execPeriod, unit->mWorld->mFullRate.mBufLength);
1703
1704 unit->m_size = sc_max(unit->m_maxperiod << 1, unit->m_execPeriod);
1705
1706 unit->m_buffer = (float*)RTAlloc(unit->mWorld, unit->m_size * sizeof(float));
1707
1708 unit->m_index = 0;
1709 unit->m_readp = 0;
1710 unit->m_hasfreq = 0.f;
1711
1712 initMedian(unit->m_values, unit->m_ages, unit->m_medianSize, unit->m_freq);
1713
1714 unit->m_getClarity = ZIN0(kPitchGetClarity) > 0.f;
1715
1716 ZOUT0(0) = 0.f;
1717 ZOUT0(1) = 0.f;
1718 }
1719
1720 void Pitch_Dtor(Pitch *unit)
1721 {
1722 RTFree(unit->mWorld, unit->m_buffer);
1723 }
1724
1725 void Pitch_next_a(Pitch *unit, int inNumSamples)
1726 {
1727 bool foundPeak;
1728
1729 float* in = ZIN(kPitchIn);
1730 uint32 size = unit->m_size;
1731 uint32 index = unit->m_index;
1732 int downsamp = unit->m_downsamp;
1733 int readp = unit->m_readp;
1734 int ksamps = unit->mWorld->mFullRate.mBufLength;
1735
1736 float *bufData = unit->m_buffer;
1737
1738 float freq = unit->m_freq;
1739 float hasfreq = unit->m_hasfreq;
1740 //printf("> %d %d readp %d ksamps %d ds %d\n", index, size, readp, ksamps, downsamp);
1741 do {
1742 float z = in[readp];
1743 bufData[index++] = z;
1744 readp += downsamp;
1745
1746 if (index >= size) {
1747 float ampthresh = unit->m_ampthresh;
1748 bool ampok = false;
1749
1750 hasfreq = 0.f; // assume failure
1751
1752 int minperiod = unit->m_minperiod;
1753 int maxperiod = unit->m_maxperiod;
1754 //float maxamp = 0.f;
1755 // check for amp threshold
1756 for (int j = 0; j < maxperiod; ++j) {
1757 if (fabs(bufData[j]) >= ampthresh) {
1758 ampok = true;
1759 break;
1760 }
1761 //if (fabs(bufData[j]) > maxamp) maxamp = fabs(bufData[j]);
1762 }
1763 //printf("ampok %d maxperiod %d maxamp %g\n", ampok, maxperiod, maxamp);
1764
1765 // if amplitude is too small then don't even look for pitch
1766 float ampsum;
1767 if (ampok) {
1768 int maxlog2bins = unit->m_maxlog2bins;
1769 int octave;
1770 // calculate the zero lag value and compute the threshold based on that
1771 float zerolagval = 0.f;
1772 for (int j = 0; j < maxperiod; ++j) {
1773 zerolagval += bufData[j] * bufData[j];
1774 }
1775 float threshold = zerolagval * unit->m_peakthresh;
1776
1777 // skip until drop below threshold
1778 int binstep, peakbinstep = 0;
1779 int i;
1780 for (i = 1; i <= maxperiod; i += binstep) {
1781 // compute sum of one lag
1782 ampsum = 0.f;
1783 for (int j = 0; j < maxperiod; ++j) {
1784 ampsum += bufData[i+j] * bufData[j];
1785 }
1786 if (ampsum < threshold) break;
1787
1788 octave = LOG2CEIL(i);
1789 if (octave <= maxlog2bins) {
1790 binstep = 1;
1791 } else {
1792 binstep = 1L << (octave - maxlog2bins);
1793 }
1794 }
1795 int startperiod = i;
1796 int period = startperiod;
1797 //printf("startperiod %d\n", startperiod);
1798
1799 // find the first peak
1800 float maxsum = threshold;
1801 foundPeak = false;
1802 for (i = startperiod; i <= maxperiod; i += binstep) {
1803 if (i >= minperiod) {
1804 ampsum = 0.f;
1805 for (int j = 0; j < maxperiod; ++j) {
1806 ampsum += bufData[i+j] * bufData[j];
1807 }
1808 if (ampsum > threshold) {
1809 if (ampsum > maxsum) {
1810 foundPeak = true;
1811 maxsum = ampsum;
1812 peakbinstep = binstep;
1813 period = i;
1814 }
1815 } else if (foundPeak) break;
1816 }
1817 octave = LOG2CEIL(i);
1818 if (octave <= maxlog2bins) {
1819 binstep = 1;
1820 } else {
1821 binstep = 1L << (octave - maxlog2bins);
1822 }
1823 }
1824
1825 //printf("found %d thr %g maxs %g per %d bs %d\n", foundPeak, threshold, maxsum, period, peakbinstep);
1826 if (foundPeak) {
1827 float prevampsum, nextampsum;
1828
1829 // find amp sums immediately surrounding max
1830 prevampsum = 0.f;
1831 if (period > 0) {
1832 i = period - 1;
1833 for (int j = 0; j < maxperiod; ++j) {
1834 prevampsum += bufData[i+j] * bufData[j];
1835 }
1836 }
1837
1838 nextampsum = 0.f;
1839 if (period < maxperiod) {
1840 i = period + 1;
1841 for (int j = 0; j < maxperiod; ++j) {
1842 nextampsum += bufData[i+j] * bufData[j];
1843 }
1844 }
1845
1846 //printf("prevnext %g %g %g %d\n", prevampsum, maxsum, nextampsum, period);
1847 // not on a peak yet. This can happen if binstep > 1
1848 while (prevampsum > maxsum && period > 0) {
1849 nextampsum = maxsum;
1850 maxsum = prevampsum;
1851 period--;
1852 i = period - 1;
1853 prevampsum = 0.f;
1854 for (int j = 0; j < maxperiod; ++j) {
1855 prevampsum += bufData[i+j] * bufData[j];
1856 }
1857 //printf("slide left %g %g %g %d\n", prevampsum, maxsum, nextampsum, period);
1858 }
1859 while (nextampsum > maxsum && period < maxperiod) {
1860 prevampsum = maxsum;
1861 maxsum = nextampsum;
1862 period++;
1863 i = period + 1;
1864 nextampsum = 0.f;
1865 for (int j = 0; j < maxperiod; ++j) {
1866 nextampsum += bufData[i+j] * bufData[j];
1867 }
1868 //printf("slide right %g %g %g %d\n", prevampsum, maxsum, nextampsum, period);
1869 }
1870
1871 // make a fractional period
1872 float beta = 0.5f * (nextampsum - prevampsum);
1873 float gamma = 2.f * maxsum - nextampsum - prevampsum;
1874 float fperiod = (float)period + (beta/gamma);
1875
1876 // calculate frequency
1877 float tempfreq = unit->m_srate / fperiod;
1878
1879 //printf("freq %g %g / %g %g %g %d\n", tempfreq, unit->m_srate, fperiod,
1880 // unit->m_minfreq, unit->m_maxfreq,
1881 // tempfreq >= unit->m_minfreq && tempfreq <= unit->m_maxfreq);
1882
1883 if (tempfreq >= unit->m_minfreq && tempfreq <= unit->m_maxfreq) {
1884 freq = tempfreq;
1885
1886 // median filter
1887 if (unit->m_medianSize > 1) {
1888 freq = insertMedian(unit->m_values, unit->m_ages, unit->m_medianSize, freq);
1889 }
1890 if(unit->m_getClarity)
1891 hasfreq = maxsum / zerolagval; // "clarity" measure is normalised size of first peak
1892 else
1893 hasfreq = 1.f;
1894
1895 startperiod = (ksamps+downsamp-1)/downsamp;
1896 }
1897 }
1898 }/* else {
1899 printf("amp too low \n");
1900 }*/
1901
1902 // shift buffer for next fill
1903 int execPeriod = unit->m_execPeriod;
1904 int interval = size - execPeriod;
1905 //printf("interval %d sz %d ep %d\n", interval, size, execPeriod);
1906 for (int i = 0; i < interval; i++) {
1907 bufData[i] = bufData[i + execPeriod];
1908 }
1909 index = interval;
1910 }
1911 } while (readp < ksamps);
1912
1913 ZOUT0(0) = freq;
1914 ZOUT0(1) = hasfreq;
1915 unit->m_readp = readp - ksamps;
1916 unit->m_index = index;
1917 unit->m_freq = freq;
1918 unit->m_hasfreq = hasfreq;
1919 }
1920
1921
1922 // control rate pitch tracking (nescivi 11/2008)
1923 void Pitch_next_k(Pitch *unit, int inNumSamples)
1924 {
1925 bool foundPeak;
1926
1927 float in = ZIN0(kPitchIn); // one sample, current input
1928 uint32 size = unit->m_size;
1929 uint32 index = unit->m_index;
1930 int downsamp = unit->m_downsamp;
1931 int readp = unit->m_readp;
1932 // int ksamps = unit->mWorld->mFullRate.mBufLength;
1933
1934 float *bufData = unit->m_buffer;
1935
1936 float freq = unit->m_freq;
1937 float hasfreq = unit->m_hasfreq;
1938 // printf("> %d %d readp %d downsamp %d exec %d\n", index, size, readp, downsamp, unit->m_execPeriod);
1939 readp++;
1940 if ( readp == downsamp ){
1941 // do {
1942 // float z = in[readp];
1943 float z = in;
1944 bufData[index++] = z;
1945 readp = 0;
1946 // readp += downsamp;
1947
1948 if (index >= size) {
1949 float ampthresh = unit->m_ampthresh;
1950 bool ampok = false;
1951
1952 hasfreq = 0.f; // assume failure
1953
1954 int minperiod = unit->m_minperiod;
1955 int maxperiod = unit->m_maxperiod;
1956 //float maxamp = 0.f;
1957 // check for amp threshold
1958 for (int j = 0; j < maxperiod; ++j) {
1959 if (fabs(bufData[j]) >= ampthresh) {
1960 ampok = true;
1961 break;
1962 }
1963 //if (fabs(bufData[j]) > maxamp) maxamp = fabs(bufData[j]);
1964 }
1965 //printf("ampok %d maxperiod %d maxamp %g\n", ampok, maxperiod, maxamp);
1966
1967 // if amplitude is too small then don't even look for pitch
1968 float ampsum;
1969 if (ampok) {
1970 int maxlog2bins = unit->m_maxlog2bins;
1971 int octave;
1972 // calculate the zero lag value and compute the threshold based on that
1973 float zerolagval = 0.f;
1974 for (int j = 0; j < maxperiod; ++j) {
1975 zerolagval += bufData[j] * bufData[j];
1976 }
1977 float threshold = zerolagval * unit->m_peakthresh;
1978
1979 // skip until drop below threshold
1980 int binstep, peakbinstep = 0;
1981 int i;
1982 for (i = 1; i <= maxperiod; i += binstep) {
1983 // compute sum of one lag
1984 ampsum = 0.f;
1985 for (int j = 0; j < maxperiod; ++j) {
1986 ampsum += bufData[i+j] * bufData[j];
1987 }
1988 if (ampsum < threshold) break;
1989
1990 octave = LOG2CEIL(i);
1991 if (octave <= maxlog2bins) {
1992 binstep = 1;
1993 } else {
1994 binstep = 1L << (octave - maxlog2bins);
1995 }
1996 }
1997 int startperiod = i;
1998 int period = startperiod;
1999 //printf("startperiod %d\n", startperiod);
2000
2001 // find the first peak
2002 float maxsum = threshold;
2003 foundPeak = false;
2004 for (i = startperiod; i <= maxperiod; i += binstep) {
2005 if (i >= minperiod) {
2006 ampsum = 0.f;
2007 for (int j = 0; j < maxperiod; ++j) {
2008 ampsum += bufData[i+j] * bufData[j];
2009 }
2010 if (ampsum > threshold) {
2011 if (ampsum > maxsum) {
2012 foundPeak = true;
2013 maxsum = ampsum;
2014 peakbinstep = binstep;
2015 period = i;
2016 }
2017 } else if (foundPeak) break;
2018 }
2019 octave = LOG2CEIL(i);
2020 if (octave <= maxlog2bins) {
2021 binstep = 1;
2022 } else {
2023 binstep = 1L << (octave - maxlog2bins);
2024 }
2025 }
2026
2027 //printf("found %d thr %g maxs %g per %d bs %d\n", foundPeak, threshold, maxsum, period, peakbinstep);
2028 if (foundPeak) {
2029 float prevampsum, nextampsum;
2030
2031 // find amp sums immediately surrounding max
2032 prevampsum = 0.f;
2033 if (period > 0) {
2034 i = period - 1;
2035 for (int j = 0; j < maxperiod; ++j) {
2036 prevampsum += bufData[i+j] * bufData[j];
2037 }
2038 }
2039
2040 nextampsum = 0.f;
2041 if (period < maxperiod) {
2042 i = period + 1;
2043 for (int j = 0; j < maxperiod; ++j) {
2044 nextampsum += bufData[i+j] * bufData[j];
2045 }
2046 }
2047
2048 //printf("prevnext %g %g %g %d\n", prevampsum, maxsum, nextampsum, period);
2049 // not on a peak yet. This can happen if binstep > 1
2050 while (prevampsum > maxsum && period > 0) {
2051 nextampsum = maxsum;
2052 maxsum = prevampsum;
2053 period--;
2054 i = period - 1;
2055 prevampsum = 0.f;
2056 for (int j = 0; j < maxperiod; ++j) {
2057 prevampsum += bufData[i+j] * bufData[j];
2058 }
2059 //printf("slide left %g %g %g %d\n", prevampsum, maxsum, nextampsum, period);
2060 }
2061 while (nextampsum > maxsum && period < maxperiod) {
2062 prevampsum = maxsum;
2063 maxsum = nextampsum;
2064 period++;
2065 i = period + 1;
2066 nextampsum = 0.f;
2067 for (int j = 0; j < maxperiod; ++j) {
2068 nextampsum += bufData[i+j] * bufData[j];
2069 }
2070 //printf("slide right %g %g %g %d\n", prevampsum, maxsum, nextampsum, period);
2071 }
2072
2073 // make a fractional period
2074 float beta = 0.5 * (nextampsum - prevampsum);
2075 float gamma = 2.0 * maxsum - nextampsum - prevampsum;
2076 float fperiod = (float)period + (beta/gamma);
2077
2078 // calculate frequency
2079 float tempfreq = unit->m_srate / fperiod;
2080
2081 //printf("freq %g %g / %g %g %g %d\n", tempfreq, unit->m_srate, fperiod,
2082 // unit->m_minfreq, unit->m_maxfreq,
2083 // tempfreq >= unit->m_minfreq && tempfreq <= unit->m_maxfreq);
2084
2085 if (tempfreq >= unit->m_minfreq && tempfreq <= unit->m_maxfreq) {
2086 freq = tempfreq;
2087
2088 // median filter
2089 if (unit->m_medianSize > 1) {
2090 freq = insertMedian(unit->m_values, unit->m_ages, unit->m_medianSize, freq);
2091 }
2092 if(unit->m_getClarity)
2093 hasfreq = maxsum / zerolagval; // "clarity" measure is normalised size of first peak
2094 else
2095 hasfreq = 1.f;
2096
2097 // nescivi: not sure about this one?
2098 startperiod = 1; // (ksamps+downsamp-1)/downsamp;
2099 }
2100 }
2101 }/* else {
2102 printf("amp too low \n");
2103 }*/
2104
2105 // shift buffer for next fill
2106 int execPeriod = unit->m_execPeriod;
2107 int interval = size - execPeriod;
2108 //printf("interval %d sz %d ep %d\n", interval, size, execPeriod);
2109 for (int i = 0; i < interval; i++) {
2110 bufData[i] = bufData[i + execPeriod];
2111 }
2112 index = interval;
2113 }
2114 }
2115 //while (readp < ksamps);
2116
2117 ZOUT0(0) = freq;
2118 ZOUT0(1) = hasfreq;
2119 // unit->m_readp = readp - ksamps;
2120 unit->m_readp = readp;
2121 unit->m_index = index;
2122 unit->m_freq = freq;
2123 unit->m_hasfreq = hasfreq;
2124 }
2125
2126 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2127
2128
2129 #if 0
2130 void DelayUnit_AllocDelayLine(DelayUnit *unit)
2131 {
2132 long delaybufsize = (long)ceil(unit->m_maxdelaytime * SAMPLERATE + 1.f);
2133 delaybufsize = delaybufsize + BUFLENGTH;
2134 delaybufsize = NEXTPOWEROFTWO(delaybufsize); // round up to next power of two
2135 unit->m_fdelaylen = unit->m_idelaylen = delaybufsize;
2136
2137 RTFree(unit->mWorld, unit->m_dlybuf);
2138 int size = delaybufsize * sizeof(float);
2139 //Print("->RTAlloc %d\n", size);
2140 unit->m_dlybuf = (float*)RTAlloc(unit->mWorld, size);
2141 //Print("<-RTAlloc %p\n", unit->m_dlybuf);
2142 unit->m_mask = delaybufsize - 1;
2143 }
2144 #endif
2145
2146
2147 template <typename Unit>
2148 static float BufCalcDelay(const Unit * unit, int bufSamples, float delayTime)
2149 {
2150 float minDelay = Unit::minDelaySamples;
2151 return sc_clip(delayTime * (float)SAMPLERATE, minDelay, (float)(PREVIOUSPOWEROFTWO(bufSamples))-1);
2152 }
2153
2154 template <typename Unit>
2155 static void BufDelayUnit_Reset(Unit *unit)
2156 {
2157 //Print("->DelayUnit_Reset\n");
2158 //unit->m_maxdelaytime = ZIN0(1);
2159 unit->m_delaytime = ZIN0(2);
2160 //Print("unit->m_delaytime %g\n", unit->m_delaytime);
2161 //unit->m_dlybuf = 0;
2162 unit->m_fbufnum = -1e9f;
2163
2164 //DelayUnit_AllocDelayLine(unit);
2165 //Print("->GET_BUF\n");
2166 GET_BUF
2167 //Print("<-GET_BUF\n");
2168 unit->m_dsamp = BufCalcDelay(unit, bufSamples, unit->m_delaytime);
2169 unit->m_numoutput = 0;
2170 unit->m_iwrphase = 0;
2171 }
2172
2173 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2174
2175 template <typename Unit>
2176 static void BufFeedbackDelay_Reset(Unit *unit)
2177 {
2178 BufDelayUnit_Reset(unit);
2179
2180 unit->m_decaytime = ZIN0(3);
2181 unit->m_feedbk = sc_CalcFeedback(unit->m_delaytime, unit->m_decaytime);
2182 }
2183
2184 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2185
2186 namespace {
2187
2188 /* helper classes for delay functionality */
2189 template <bool Checked = false>
2190 struct DelayN_helper
2191 {
2192 static const bool checked = false;
2193
2194 static inline void perform(const float *& in, float *& out, float * bufData,
2195 long & iwrphase, long idsamp, long mask)
2196 {
2197 long irdphase = iwrphase - idsamp;
2198 bufData[iwrphase & mask] = ZXP(in);
2199 ZXP(out) = bufData[irdphase & mask];
2200 iwrphase++;
2201 }
2202
2203 /* the frac argument is unneeded. the compiler should make sure, that it won't be computed */
2204 static inline void perform(const float *& in, float *& out, float * bufData,
2205 long & iwrphase, long idsamp, float frac, long mask)
2206 {
2207 perform(in, out, bufData, iwrphase, idsamp, mask);
2208 }
2209 };
2210
2211 template <>
2212 struct DelayN_helper<true>
2213 {
2214 static const bool checked = true;
2215
2216 static inline void perform(const float *& in, float *& out, float * bufData,
2217 long & iwrphase, long idsamp, long mask)
2218 {
2219 long irdphase = iwrphase - idsamp;
2220
2221 bufData[iwrphase & mask] = ZXP(in);
2222 if (irdphase < 0)
2223 ZXP(out) = 0.f;
2224 else
2225 ZXP(out) = bufData[irdphase & mask];
2226
2227 iwrphase++;
2228 }
2229
2230 static inline void perform(const float *& in, float *& out, float * bufData,
2231 long & iwrphase, long idsamp, float frac, long mask)
2232 {
2233 perform(in, out, bufData, iwrphase, idsamp, mask);
2234 }
2235 };
2236
2237 template <bool initializing>
2238 static inline void DelayN_delay_loop(float * out, const float * in, long & iwrphase, float dsamp, long mask,
2239 float * dlybuf, int inNumSamples, int idelaylen)
2240 {
2241 long irdphase = iwrphase - (long)dsamp;
2242 float* dlybuf1 = dlybuf - ZOFF;
2243 float* dlyrd = dlybuf1 + (irdphase & mask);
2244 float* dlywr = dlybuf1 + (iwrphase & mask);
2245 float* dlyN = dlybuf1 + idelaylen;
2246 long remain = inNumSamples;
2247 while (remain) {
2248 long rdspace = dlyN - dlyrd;
2249 long wrspace = dlyN - dlywr;
2250 if (initializing) {
2251 long nsmps = sc_min(rdspace, wrspace);
2252 nsmps = sc_min(remain, nsmps);
2253 remain -= nsmps;
2254 if (irdphase < 0) {
2255 if ((dlywr - dlyrd) > nsmps) {
2256 #ifdef NOVA_SIMD
2257 if ((nsmps & (nova::vec<float>::size - 1)) == 0) {
2258 nova::copyvec_nn_simd(dlywr + ZOFF, in + ZOFF, nsmps);
2259 nova::zerovec_na_simd(out + ZOFF, nsmps);
2260 } else
2261 #endif
2262 {
2263 ZCopy(nsmps, dlywr, in);
2264 ZClear(nsmps, out);
2265 }
2266 out += nsmps;
2267 in += nsmps;
2268 dlyrd += nsmps;
2269 dlywr += nsmps;
2270 } else
2271 LOOP(nsmps,
2272 ZXP(dlywr) = ZXP(in);
2273 ZXP(out) = 0.f;
2274 ZXP(dlyrd);
2275 );
2276 } else {
2277 LOOP(nsmps,
2278 ZXP(dlywr) = ZXP(in);
2279 ZXP(out) = ZXP(dlyrd);
2280 );
2281 }
2282 irdphase += nsmps;
2283 if (dlyrd == dlyN) dlyrd = dlybuf1;
2284 if (dlywr == dlyN) dlywr = dlybuf1;
2285 }
2286 else {
2287 long nsmps = sc_min(rdspace, wrspace);
2288 nsmps = sc_min(remain, nsmps);
2289 remain -= nsmps;
2290
2291 if (std::abs((float)(dlyrd - dlywr)) > nsmps) {
2292 #ifdef NOVA_SIMD
2293 if ((nsmps & 15) == 0) {
2294 nova::copyvec_nn_simd(dlywr + ZOFF, in + ZOFF, nsmps);
2295 nova::copyvec_nn_simd(out + ZOFF, dlyrd + ZOFF, nsmps);
2296 } else
2297 #endif
2298 {
2299 ZCopy(nsmps, dlywr, in);
2300 ZCopy(nsmps, out, dlyrd);
2301 }
2302 out += nsmps;
2303 in += nsmps;
2304 dlyrd += nsmps;
2305 dlywr += nsmps;
2306 } else
2307 LOOP(nsmps,
2308 ZXP(dlywr) = ZXP(in);
2309 ZXP(out) = ZXP(dlyrd);
2310 );
2311 if (dlyrd == dlyN) dlyrd = dlybuf1;
2312 if (dlywr == dlyN) dlywr = dlybuf1;
2313 }
2314 }
2315 iwrphase += inNumSamples;
2316 }
2317
2318
2319 template <bool Checked = false>
2320 struct DelayL_helper
2321 {
2322 static const bool checked = false;
2323
2324 static inline void perform(const float *& in, float *& out, float * bufData,
2325 long & iwrphase, long idsamp, float frac, long mask)
2326 {
2327 bufData[iwrphase & mask] = ZXP(in);
2328 long irdphase = iwrphase - idsamp;
2329 long irdphaseb = irdphase - 1;
2330 float d1 = bufData[irdphase & mask];
2331 float d2 = bufData[irdphaseb & mask];
2332 ZXP(out) = lininterp(frac, d1, d2);
2333 iwrphase++;
2334 }
2335 };
2336
2337 template <>
2338 struct DelayL_helper<true>
2339 {
2340 static const bool checked = true;
2341
2342 static inline void perform(const float *& in, float *& out, float * bufData,
2343 long & iwrphase, long idsamp, float frac, long mask)
2344 {
2345 bufData[iwrphase & mask] = ZXP(in);
2346 long irdphase = iwrphase - idsamp;
2347 long irdphaseb = irdphase - 1;
2348
2349 if (irdphase < 0) {
2350 ZXP(out) = 0.f;
2351 } else if (irdphaseb < 0) {
2352 float d1 = bufData[irdphase & mask];
2353 ZXP(out) = d1 - frac * d1;
2354 } else {
2355 float d1 = bufData[irdphase & mask];
2356 float d2 = bufData[irdphaseb & mask];
2357 ZXP(out) = lininterp(frac, d1, d2);
2358 }
2359 iwrphase++;
2360 }
2361 };
2362
2363 template <bool Checked = false>
2364 struct DelayC_helper
2365 {
2366 static const bool checked = false;
2367
2368 static inline void perform(const float *& in, float *& out, float * bufData,
2369 long & iwrphase, long idsamp, float frac, long mask)
2370 {
2371 bufData[iwrphase & mask] = ZXP(in);
2372 long irdphase1 = iwrphase - idsamp;
2373 long irdphase2 = irdphase1 - 1;
2374 long irdphase3 = irdphase1 - 2;
2375 long irdphase0 = irdphase1 + 1;
2376 float d0 = bufData[irdphase0 & mask];
2377 float d1 = bufData[irdphase1 & mask];
2378 float d2 = bufData[irdphase2 & mask];
2379 float d3 = bufData[irdphase3 & mask];
2380 ZXP(out) = cubicinterp(frac, d0, d1, d2, d3);
2381 iwrphase++;
2382 }
2383 };
2384
2385 template <>
2386 struct DelayC_helper<true>
2387 {
2388 static const bool checked = true;
2389
2390 static inline void perform(const float *& in, float *& out, float * bufData,
2391 long & iwrphase, long idsamp, float frac, long mask)
2392 {
2393 long irdphase1 = iwrphase - idsamp;
2394 long irdphase2 = irdphase1 - 1;
2395 long irdphase3 = irdphase1 - 2;
2396 long irdphase0 = irdphase1 + 1;
2397
2398 bufData[iwrphase & mask] = ZXP(in);
2399 if (irdphase0 < 0) {
2400 ZXP(out) = 0.f;
2401 } else {
2402 float d0, d1, d2, d3;
2403 if (irdphase1 < 0) {
2404 d1 = d2 = d3 = 0.f;
2405 d0 = bufData[irdphase0 & mask];
2406 } else if (irdphase2 < 0) {
2407 d1 = d2 = d3 = 0.f;
2408 d0 = bufData[irdphase0 & mask];
2409 d1 = bufData[irdphase1 & mask];
2410 } else if (irdphase3 < 0) {
2411 d3 = 0.f;
2412 d0 = bufData[irdphase0 & mask];
2413 d1 = bufData[irdphase1 & mask];
2414 d2 = bufData[irdphase2 & mask];
2415 } else {
2416 d0 = bufData[irdphase0 & mask];
2417 d1 = bufData[irdphase1 & mask];
2418 d2 = bufData[irdphase2 & mask];
2419 d3 = bufData[irdphase3 & mask];
2420 }
2421 ZXP(out) = cubicinterp(frac, d0, d1, d2, d3);
2422 }
2423 iwrphase++;
2424 }
2425 };
2426
2427 template <bool Checked = false>
2428 struct CombN_helper
2429 {
2430 static const bool checked = false;
2431
2432 static inline void perform(const float *& in, float *& out, float * bufData,
2433 long & iwrphase, long idsamp, long mask, float feedbk)
2434 {
2435 long irdphase = iwrphase - idsamp;
2436 float value = bufData[irdphase & mask];
2437 bufData[iwrphase & mask] = ZXP(in) + feedbk * value;
2438 ZXP(out) = value;
2439 ++iwrphase;
2440 }
2441
2442 /* the frac argument is unneeded. the compiler should make sure, that it won't be computed */
2443 static inline void perform(const float *& in, float *& out, float * bufData,
2444 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2445 {
2446 perform(in, out, bufData, iwrphase, idsamp, mask, feedbk);
2447 }
2448 };
2449
2450 template <>
2451 struct CombN_helper<true>
2452 {
2453 static const bool checked = true;
2454
2455 static inline void perform(const float *& in, float *& out, float * bufData,
2456 long & iwrphase, long idsamp, long mask, float feedbk)
2457 {
2458 long irdphase = iwrphase - idsamp;
2459
2460 if (irdphase < 0) {
2461 bufData[iwrphase & mask] = ZXP(in);
2462 ZXP(out) = 0.f;
2463 } else {
2464 float value = bufData[irdphase & mask];
2465 bufData[iwrphase & mask] = ZXP(in) + feedbk * value;
2466 ZXP(out) = value;
2467 }
2468
2469 iwrphase++;
2470 }
2471
2472 static inline void perform(const float *& in, float *& out, float * bufData,
2473 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2474 {
2475 perform(in, out, bufData, iwrphase, idsamp, mask, feedbk);
2476 }
2477 };
2478
2479 template <bool Checked = false>
2480 struct CombL_helper
2481 {
2482 static const bool checked = false;
2483
2484 static inline void perform(const float *& in, float *& out, float * bufData,
2485 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2486 {
2487 long irdphase = iwrphase - idsamp;
2488 long irdphaseb = irdphase - 1;
2489 float d1 = bufData[irdphase & mask];
2490 float d2 = bufData[irdphaseb & mask];
2491 float value = lininterp(frac, d1, d2);
2492 bufData[iwrphase & mask] = ZXP(in) + feedbk * value;
2493 ZXP(out) = value;
2494 iwrphase++;
2495 }
2496 };
2497
2498 template <>
2499 struct CombL_helper<true>
2500 {
2501 static const bool checked = true;
2502
2503 static inline void perform(const float *& in, float *& out, float * bufData,
2504 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2505 {
2506 long irdphase = iwrphase - idsamp;
2507 long irdphaseb = irdphase - 1;
2508
2509 float zin = ZXP(in);
2510 if (irdphase < 0) {
2511 bufData[iwrphase & mask] = zin;
2512 ZXP(out) = 0.f;
2513 } else if (irdphaseb < 0) {
2514 float d1 = bufData[irdphase & mask];
2515 float value = d1 - frac * d1;
2516 bufData[iwrphase & mask] = zin + feedbk * value;
2517 ZXP(out) = value;
2518 } else {
2519 float d1 = bufData[irdphase & mask];
2520 float d2 = bufData[irdphaseb & mask];
2521 float value = lininterp(frac, d1, d2);
2522 bufData[iwrphase & mask] = zin + feedbk * value;
2523 ZXP(out) = value;
2524 }
2525 iwrphase++;
2526 }
2527 };
2528
2529 template <bool Checked = false>
2530 struct CombC_helper
2531 {
2532 static const bool checked = false;
2533
2534 static inline void perform(const float *& in, float *& out, float * bufData,
2535 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2536 {
2537 long irdphase1 = iwrphase - idsamp;
2538 long irdphase2 = irdphase1 - 1;
2539 long irdphase3 = irdphase1 - 2;
2540 long irdphase0 = irdphase1 + 1;
2541 float d0 = bufData[irdphase0 & mask];
2542 float d1 = bufData[irdphase1 & mask];
2543 float d2 = bufData[irdphase2 & mask];
2544 float d3 = bufData[irdphase3 & mask];
2545 float value = cubicinterp(frac, d0, d1, d2, d3);
2546 bufData[iwrphase & mask] = ZXP(in) + feedbk * value;
2547 ZXP(out) = value;
2548 iwrphase++;
2549 }
2550 };
2551
2552 template <>
2553 struct CombC_helper<true>
2554 {
2555 static const bool checked = true;
2556
2557 static inline void perform(const float *& in, float *& out, float * bufData,
2558 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2559 {
2560 long irdphase1 = iwrphase - idsamp;
2561 long irdphase2 = irdphase1 - 1;
2562 long irdphase3 = irdphase1 - 2;
2563 long irdphase0 = irdphase1 + 1;
2564
2565 if (irdphase0 < 0) {
2566 bufData[iwrphase & mask] = ZXP(in);
2567 ZXP(out) = 0.f;
2568 } else {
2569 float d0, d1, d2, d3;
2570 if (irdphase1 < 0) {
2571 d1 = d2 = d3 = 0.f;
2572 d0 = bufData[irdphase0 & mask];
2573 } else if (irdphase2 < 0) {
2574 d1 = d2 = d3 = 0.f;
2575 d0 = bufData[irdphase0 & mask];
2576 d1 = bufData[irdphase1 & mask];
2577 } else if (irdphase3 < 0) {
2578 d3 = 0.f;
2579 d0 = bufData[irdphase0 & mask];
2580 d1 = bufData[irdphase1 & mask];
2581 d2 = bufData[irdphase2 & mask];
2582 } else {
2583 d0 = bufData[irdphase0 & mask];
2584 d1 = bufData[irdphase1 & mask];
2585 d2 = bufData[irdphase2 & mask];
2586 d3 = bufData[irdphase3 & mask];
2587 }
2588 float value = cubicinterp(frac, d0, d1, d2, d3);
2589 bufData[iwrphase & mask] = ZXP(in) + feedbk * value;
2590 ZXP(out) = value;
2591 }
2592 iwrphase++;
2593 }
2594 };
2595
2596 template <bool Checked = false>
2597 struct AllpassN_helper
2598 {
2599 static const bool checked = false;
2600
2601 static inline void perform(const float *& in, float *& out, float * bufData,
2602 long & iwrphase, long idsamp, long mask, float feedbk)
2603 {
2604 long irdphase = iwrphase - idsamp;
2605 float value = bufData[irdphase & mask];
2606 float dwr = value * feedbk + ZXP(in);
2607 bufData[iwrphase & mask] = dwr;
2608 ZXP(out) = value - feedbk * dwr;
2609 ++iwrphase;
2610 }
2611
2612 /* the frac argument is unneeded. the compiler should make sure, that it won't be computed */
2613 static inline void perform(const float *& in, float *& out, float * bufData,
2614 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2615 {
2616 perform(in, out, bufData, iwrphase, idsamp, mask, feedbk);
2617 }
2618 };
2619
2620 template <>
2621 struct AllpassN_helper<true>
2622 {
2623 static const bool checked = true;
2624
2625 static inline void perform(const float *& in, float *& out, float * bufData,
2626 long & iwrphase, long idsamp, long mask, float feedbk)
2627 {
2628 long irdphase = iwrphase - idsamp;
2629
2630 if (irdphase < 0) {
2631 float dwr = ZXP(in);
2632 bufData[iwrphase & mask] = dwr;
2633 ZXP(out) = -feedbk * dwr;
2634 } else {
2635 float value = bufData[irdphase & mask];
2636 float dwr = feedbk * value + ZXP(in);
2637 bufData[iwrphase & mask] = dwr;
2638 ZXP(out) = value - feedbk * dwr;
2639 }
2640 ++iwrphase;
2641 }
2642
2643 static inline void perform(const float *& in, float *& out, float * bufData,
2644 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2645 {
2646 perform(in, out, bufData, iwrphase, idsamp, mask, feedbk);
2647 }
2648 };
2649
2650 template <bool Checked = false>
2651 struct AllpassL_helper
2652 {
2653 static const bool checked = false;
2654
2655 static inline void perform(const float *& in, float *& out, float * bufData,
2656 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2657 {
2658 long irdphase = iwrphase - idsamp;
2659 long irdphaseb = irdphase - 1;
2660 float d1 = bufData[irdphase & mask];
2661 float d2 = bufData[irdphaseb & mask];
2662 float value = lininterp(frac, d1, d2);
2663 float dwr = ZXP(in) + feedbk * value;
2664 bufData[iwrphase & mask] = dwr;
2665 ZXP(out) = value - feedbk * dwr;
2666 iwrphase++;
2667 }
2668 };
2669
2670 template <>
2671 struct AllpassL_helper<true>
2672 {
2673 static const bool checked = true;
2674
2675 static inline void perform(const float *& in, float *& out, float * bufData,
2676 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2677 {
2678 long irdphase = iwrphase - idsamp;
2679 long irdphaseb = irdphase - 1;
2680
2681 float zin = ZXP(in);
2682 if (irdphase < 0) {
2683 bufData[iwrphase & mask] = zin;
2684 ZXP(out) = - feedbk * zin;
2685 } else if (irdphaseb < 0) {
2686 float d1 = bufData[irdphase & mask];
2687 float value = d1 - frac * d1;
2688 float dwr = zin + feedbk * value;
2689 bufData[iwrphase & mask] = dwr;
2690 ZXP(out) = value - feedbk * dwr;
2691 } else {
2692 float d1 = bufData[irdphase & mask];
2693 float d2 = bufData[irdphaseb & mask];
2694 float value = lininterp(frac, d1, d2);
2695 float dwr = zin + feedbk * value;
2696 bufData[iwrphase & mask] = dwr;
2697 ZXP(out) = value - feedbk * dwr;
2698 }
2699 iwrphase++;
2700 }
2701 };
2702
2703 template <bool Checked = false>
2704 struct AllpassC_helper
2705 {
2706 static const bool checked = false;
2707
2708 static inline void perform(const float *& in, float *& out, float * bufData,
2709 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2710 {
2711 long irdphase1 = iwrphase - idsamp;
2712 long irdphase2 = irdphase1 - 1;
2713 long irdphase3 = irdphase1 - 2;
2714 long irdphase0 = irdphase1 + 1;
2715 float d0 = bufData[irdphase0 & mask];
2716 float d1 = bufData[irdphase1 & mask];
2717 float d2 = bufData[irdphase2 & mask];
2718 float d3 = bufData[irdphase3 & mask];
2719 float value = cubicinterp(frac, d0, d1, d2, d3);
2720 float dwr = ZXP(in) + feedbk * value;
2721 bufData[iwrphase & mask] = dwr;
2722 ZXP(out) = value - feedbk * dwr;
2723 iwrphase++;
2724 }
2725 };
2726
2727 template <>
2728 struct AllpassC_helper<true>
2729 {
2730 static const bool checked = true;
2731
2732 static inline void perform(const float *& in, float *& out, float * bufData,
2733 long & iwrphase, long idsamp, float frac, long mask, float feedbk)
2734 {
2735 long irdphase1 = iwrphase - idsamp;
2736 long irdphase2 = irdphase1 - 1;
2737 long irdphase3 = irdphase1 - 2;
2738 long irdphase0 = irdphase1 + 1;
2739
2740 if (irdphase0 < 0) {
2741 bufData[iwrphase & mask] = ZXP(in);
2742 ZXP(out) = 0.f;
2743 } else {
2744 float d0, d1, d2, d3;
2745 if (irdphase1 < 0) {
2746 d1 = d2 = d3 = 0.f;
2747 d0 = bufData[irdphase0 & mask];
2748 } else if (irdphase2 < 0) {
2749 d1 = d2 = d3 = 0.f;
2750 d0 = bufData[irdphase0 & mask];
2751 d1 = bufData[irdphase1 & mask];
2752 } else if (irdphase3 < 0) {
2753 d3 = 0.f;
2754 d0 = bufData[irdphase0 & mask];
2755 d1 = bufData[irdphase1 & mask];
2756 d2 = bufData[irdphase2 & mask];
2757 } else {
2758 d0 = bufData[irdphase0 & mask];
2759 d1 = bufData[irdphase1 & mask];
2760 d2 = bufData[irdphase2 & mask];
2761 d3 = bufData[irdphase3 & mask];
2762 }
2763 float value = cubicinterp(frac, d0, d1, d2, d3);
2764 float dwr = ZXP(in) + feedbk * value;
2765 bufData[iwrphase & mask] = dwr;
2766 ZXP(out) = value - feedbk * dwr;
2767 }
2768 iwrphase++;
2769 }
2770 };
2771
2772 }
2773
2774 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2775
2776 /* template function to generate buffer-based delay ugen function, control-rate delay time */
2777 template <typename PerformClass,
2778 typename BufDelayX
2779 >
2780 inline void BufDelayX_perform(BufDelayX *unit, int inNumSamples, UnitCalcFunc resetFunc)
2781 {
2782 float *out = ZOUT(0);
2783 const float *in = ZIN(1);
2784 float delaytime = ZIN0(2);
2785
2786 GET_BUF
2787 CHECK_BUF
2788 long iwrphase = unit->m_iwrphase;
2789 float dsamp = unit->m_dsamp;
2790
2791 if (delaytime == unit->m_delaytime) {
2792 long idsamp = (long)dsamp;
2793 float frac = dsamp - idsamp;
2794 LOOP1(inNumSamples,
2795 PerformClass::perform(in, out, bufData, iwrphase, idsamp, frac, mask);
2796 );
2797 } else {
2798 float next_dsamp = BufCalcDelay(unit, bufSamples, delaytime);
2799 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
2800
2801 LOOP1(inNumSamples,
2802 dsamp += dsamp_slope;
2803 long idsamp = (long)dsamp;
2804 float frac = dsamp - idsamp;
2805 PerformClass::perform(in, out, bufData, iwrphase, idsamp, frac, mask);
2806 );
2807 unit->m_dsamp = dsamp;
2808 unit->m_delaytime = delaytime;
2809 }
2810
2811 unit->m_iwrphase = iwrphase;
2812
2813 if (PerformClass::checked) {
2814 unit->m_numoutput += inNumSamples;
2815 if (unit->m_numoutput >= bufSamples)
2816 unit->mCalcFunc = resetFunc;
2817 }
2818 }
2819
2820
2821 /* template function to generate buffer-based delay ugen function, audio-rate delay time */
2822 template <typename PerformClass,
2823 typename BufDelayX
2824 >
2825 inline void BufDelayX_perform_a(BufDelayX *unit, int inNumSamples, UnitCalcFunc resetFunc)
2826 {
2827 float *out = ZOUT(0);
2828 const float *in = ZIN(1);
2829 float * delaytime = ZIN(2);
2830
2831 GET_BUF
2832 CHECK_BUF
2833 long iwrphase = unit->m_iwrphase;
2834
2835 LOOP1(inNumSamples,
2836 float dsamp = BufCalcDelay(unit, bufSamples, ZXP(delaytime));
2837 long idsamp = (long)dsamp;
2838
2839 float frac = dsamp - idsamp;
2840 PerformClass::perform(in, out, bufData, iwrphase, idsamp, frac, mask);
2841 );
2842
2843 unit->m_iwrphase = iwrphase;
2844
2845 if (PerformClass::checked)
2846 {
2847 unit->m_numoutput += inNumSamples;
2848 if (unit->m_numoutput >= bufSamples)
2849 unit->mCalcFunc = resetFunc;
2850 }
2851 }
2852
2853 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2854
2855 void BufDelayN_Ctor(BufDelayN *unit)
2856 {
2857 if(INRATE(2) == calc_FullRate)
2858 SETCALC(BufDelayN_next_a_z);
2859 else
2860 SETCALC(BufDelayN_next_z);
2861 BufDelayUnit_Reset(unit);
2862 ZOUT0(0) = 0.f;
2863 }
2864
2865 void BufDelayN_next(BufDelayN *unit, int inNumSamples)
2866 {
2867 float *out = ZOUT(0);
2868 const float *in = ZIN(1);
2869 float delaytime = ZIN0(2);
2870
2871 GET_BUF
2872 CHECK_BUF
2873 long iwrphase = unit->m_iwrphase;
2874 float dsamp = unit->m_dsamp;
2875
2876 if (delaytime == unit->m_delaytime) {
2877 DelayN_delay_loop<false>(out, in, iwrphase, dsamp, mask, bufData, inNumSamples, PREVIOUSPOWEROFTWO(bufSamples));
2878 } else {
2879 float next_dsamp = BufCalcDelay(unit, bufSamples, delaytime);
2880 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
2881
2882 LOOP1(inNumSamples,
2883 dsamp += dsamp_slope;
2884 long idsamp = (long)dsamp;
2885 DelayN_helper<false>::perform(in, out, bufData, iwrphase, idsamp, mask);
2886 );
2887 unit->m_dsamp = dsamp;
2888 unit->m_delaytime = delaytime;
2889 }
2890
2891 unit->m_iwrphase = iwrphase;
2892 }
2893
2894
2895 void BufDelayN_next_z(BufDelayN *unit, int inNumSamples)
2896 {
2897 float *out = ZOUT(0);
2898 const float *in = ZIN(1);
2899 float delaytime = ZIN0(2);
2900
2901 GET_BUF
2902 CHECK_BUF
2903 long iwrphase = unit->m_iwrphase;
2904 float dsamp = unit->m_dsamp;
2905
2906 if (delaytime == unit->m_delaytime) {
2907 DelayN_delay_loop<true>(out, in, iwrphase, dsamp, mask, bufData, inNumSamples, PREVIOUSPOWEROFTWO(bufSamples));
2908 } else {
2909 float next_dsamp = BufCalcDelay(unit, bufSamples, delaytime);
2910 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
2911
2912 LOOP1(inNumSamples,
2913 dsamp += dsamp_slope;
2914 long idsamp = (long)dsamp;
2915 DelayN_helper<true>::perform(in, out, bufData, iwrphase, idsamp, mask);
2916 );
2917 unit->m_dsamp = dsamp;
2918 unit->m_delaytime = delaytime;
2919 }
2920
2921 unit->m_iwrphase = iwrphase;
2922
2923 unit->m_numoutput += inNumSamples;
2924 if (unit->m_numoutput >= bufSamples)
2925 SETCALC(BufDelayN_next);
2926 }
2927
2928 template <bool checked>
2929 inline void BufDelayN_perform_a(BufDelayN *unit, int inNumSamples)
2930 {
2931 BufDelayX_perform_a<DelayN_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufDelayN_next_a);
2932 }
2933
2934 void BufDelayN_next_a(BufDelayN *unit, int inNumSamples)
2935 {
2936 BufDelayN_perform_a<false>(unit, inNumSamples);
2937 }
2938
2939 void BufDelayN_next_a_z(BufDelayN *unit, int inNumSamples)
2940 {
2941 BufDelayN_perform_a<true>(unit, inNumSamples);
2942 }
2943
2944 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2945 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2946
2947 void BufDelayL_Ctor(BufDelayL *unit)
2948 {
2949 BufDelayUnit_Reset(unit);
2950 if(INRATE(2) == calc_FullRate)
2951 SETCALC(BufDelayL_next_a_z);
2952 else
2953 SETCALC(BufDelayL_next_z);
2954 ZOUT0(0) = 0.f;
2955 }
2956
2957
2958 template <bool checked>
2959 inline void BufDelayL_perform(BufDelayL *unit, int inNumSamples)
2960 {
2961 BufDelayX_perform<DelayL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufDelayL_next);
2962 }
2963
2964 void BufDelayL_next(BufDelayL *unit, int inNumSamples)
2965 {
2966 BufDelayL_perform<false>(unit, inNumSamples);
2967 }
2968
2969 void BufDelayL_next_z(BufDelayL *unit, int inNumSamples)
2970 {
2971 BufDelayL_perform<true>(unit, inNumSamples);
2972 }
2973
2974 template <bool checked>
2975 inline void BufDelayL_perform_a(BufDelayL *unit, int inNumSamples)
2976 {
2977 BufDelayX_perform_a<DelayL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufDelayL_next_a);
2978 }
2979
2980 void BufDelayL_next_a(BufDelayL *unit, int inNumSamples)
2981 {
2982 BufDelayL_perform_a<false>(unit, inNumSamples);
2983 }
2984
2985 void BufDelayL_next_a_z(BufDelayL *unit, int inNumSamples)
2986 {
2987 BufDelayL_perform_a<true>(unit, inNumSamples);
2988 }
2989
2990 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2991
2992 void BufDelayC_Ctor(BufDelayC *unit)
2993 {
2994 BufDelayUnit_Reset(unit);
2995 if(INRATE(2) == calc_FullRate)
2996 SETCALC(BufDelayC_next_a_z);
2997 else
2998 SETCALC(BufDelayC_next_z);
2999 ZOUT0(0) = 0.f;
3000 }
3001
3002 template <bool checked>
3003 inline void BufDelayC_perform(BufDelayC *unit, int inNumSamples)
3004 {
3005 BufDelayX_perform<DelayC_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufDelayC_next);
3006 }
3007
3008 void BufDelayC_next(BufDelayC *unit, int inNumSamples)
3009 {
3010 BufDelayC_perform<false>(unit, inNumSamples);
3011 }
3012
3013 void BufDelayC_next_z(BufDelayC *unit, int inNumSamples)
3014 {
3015 BufDelayC_perform<true>(unit, inNumSamples);
3016 }
3017
3018 template <bool checked>
3019 inline void BufDelayC_perform_a(BufDelayC *unit, int inNumSamples)
3020 {
3021 BufDelayX_perform_a<DelayC_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufDelayL_next_a);
3022 }
3023
3024 void BufDelayC_next_a(BufDelayC *unit, int inNumSamples)
3025 {
3026 BufDelayC_perform_a<false>(unit, inNumSamples);
3027 }
3028
3029 void BufDelayC_next_a_z(BufDelayC *unit, int inNumSamples)
3030 {
3031 BufDelayC_perform_a<true>(unit, inNumSamples);
3032 }
3033
3034 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3035 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3036
3037 template <typename PerformClass,
3038 typename BufCombX
3039 >
3040 inline void BufFilterX_perform(BufCombX *unit, int inNumSamples, UnitCalcFunc resetFunc)
3041 {
3042 float *out = ZOUT(0);
3043 const float *in = ZIN(1);
3044 float delaytime = ZIN0(2);
3045 float decaytime = ZIN0(3);
3046
3047 GET_BUF
3048 CHECK_BUF
3049 long iwrphase = unit->m_iwrphase;
3050 float dsamp = unit->m_dsamp;
3051 float feedbk = unit->m_feedbk;
3052
3053 if (delaytime == unit->m_delaytime && decaytime == unit->m_decaytime) {
3054 long idsamp = (long)dsamp;
3055 float frac = dsamp - idsamp;
3056 LOOP1(inNumSamples,
3057 PerformClass::perform(in, out, bufData, iwrphase, idsamp, frac, mask, feedbk);
3058 );
3059 } else {
3060 float next_dsamp = BufCalcDelay(unit, bufSamples, delaytime);
3061 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
3062
3063 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
3064 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
3065
3066 LOOP1(inNumSamples,
3067 dsamp += dsamp_slope;
3068 feedbk += feedbk_slope;
3069 long idsamp = (long)dsamp;
3070 float frac = dsamp - idsamp;
3071 PerformClass::perform(in, out, bufData, iwrphase, idsamp, frac, mask, feedbk);
3072 );
3073 unit->m_feedbk = feedbk;
3074 unit->m_dsamp = dsamp;
3075 unit->m_delaytime = delaytime;
3076 unit->m_decaytime = decaytime;
3077 }
3078
3079 unit->m_iwrphase = iwrphase;
3080
3081 if (PerformClass::checked) {
3082 unit->m_numoutput += inNumSamples;
3083 if (unit->m_numoutput >= bufSamples)
3084 unit->mCalcFunc = resetFunc;
3085 }
3086 }
3087
3088 template <typename PerformClass,
3089 typename BufCombX
3090 >
3091 inline void BufFilterX_perform_a(BufCombX *unit, int inNumSamples, UnitCalcFunc resetFunc)
3092 {
3093 float *out = ZOUT(0);
3094 const float *in = ZIN(1);
3095 float * delaytime = ZIN(2);
3096 float decaytime = ZIN0(3);
3097
3098 GET_BUF
3099 CHECK_BUF
3100 long iwrphase = unit->m_iwrphase;
3101
3102 LOOP1(inNumSamples,
3103 float del = ZXP(delaytime);
3104 float dsamp = BufCalcDelay(unit, bufSamples, del);
3105 float feedbk = sc_CalcFeedback(del, decaytime);
3106
3107 long idsamp = (long)dsamp;
3108 float frac = dsamp - idsamp;
3109 PerformClass::perform(in, out, bufData, iwrphase, idsamp, frac, mask, feedbk);
3110 );
3111
3112 unit->m_iwrphase = iwrphase;
3113
3114 if (PerformClass::checked)
3115 {
3116 unit->m_numoutput += inNumSamples;
3117 if (unit->m_numoutput >= bufSamples)
3118 unit->mCalcFunc = resetFunc;
3119 }
3120 }
3121
3122
3123 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3124
3125 void BufCombN_Ctor(BufCombN *unit)
3126 {
3127 BufFeedbackDelay_Reset(unit);
3128 if(INRATE(2) == calc_FullRate)
3129 SETCALC(BufCombN_next_a_z);
3130 else
3131 SETCALC(BufCombN_next_z);
3132 ZOUT0(0) = 0.f;
3133 }
3134
3135 void BufCombN_next(BufCombN *unit, int inNumSamples)
3136 {
3137 float *out = ZOUT(0);
3138 const float *in = ZIN(1);
3139 float delaytime = ZIN0(2);
3140 float decaytime = ZIN0(3);
3141
3142 GET_BUF
3143 CHECK_BUF
3144 long iwrphase = unit->m_iwrphase;
3145 float dsamp = unit->m_dsamp;
3146 float feedbk = unit->m_feedbk;
3147
3148 //postbuf("BufCombN_next %g %g %g %g %d %d %d\n", delaytime, decaytime, feedbk, dsamp, mask, iwrphase, zorg);
3149 if (delaytime == unit->m_delaytime) {
3150 long irdphase = iwrphase - (long)dsamp;
3151 float* dlybuf1 = bufData - ZOFF;
3152 float* dlyrd = dlybuf1 + (irdphase & mask);
3153 float* dlywr = dlybuf1 + (iwrphase & mask);
3154 float* dlyN = dlybuf1 + PREVIOUSPOWEROFTWO(bufSamples);
3155 if (decaytime == unit->m_decaytime) {
3156 long remain = inNumSamples;
3157 while (remain) {
3158 long rdspace = dlyN - dlyrd;
3159 long wrspace = dlyN - dlywr;
3160 long nsmps = sc_min(rdspace, wrspace);
3161 nsmps = sc_min(remain, nsmps);
3162 remain -= nsmps;
3163 LOOP1(nsmps,
3164 float value = ZXP(dlyrd);
3165 ZXP(dlywr) = value * feedbk + ZXP(in);
3166 ZXP(out) = value;
3167 );
3168 if (dlyrd == dlyN) dlyrd = dlybuf1;
3169 if (dlywr == dlyN) dlywr = dlybuf1;
3170 }
3171 } else {
3172 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
3173 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
3174 long remain = inNumSamples;
3175 while (remain) {
3176 long rdspace = dlyN - dlyrd;
3177 long wrspace = dlyN - dlywr;
3178 long nsmps = sc_min(rdspace, wrspace);
3179 nsmps = sc_min(remain, nsmps);
3180 remain -= nsmps;
3181
3182 LOOP1(nsmps,
3183 float value = ZXP(dlyrd);
3184 ZXP(dlywr) = value * feedbk + ZXP(in);
3185 ZXP(out) = value;
3186 feedbk += feedbk_slope;
3187 );
3188 if (dlyrd == dlyN) dlyrd = dlybuf1;
3189 if (dlywr == dlyN) dlywr = dlybuf1;
3190 }
3191 unit->m_feedbk = feedbk;
3192 unit->m_decaytime = decaytime;
3193 }
3194 iwrphase += inNumSamples;
3195 } else {
3196 float next_dsamp = BufCalcDelay(unit, bufSamples, delaytime);
3197 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
3198
3199 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
3200 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
3201 LOOP1(inNumSamples,
3202 dsamp += dsamp_slope;
3203 feedbk += feedbk_slope;
3204 CombN_helper<false>::perform(in, out, bufData, iwrphase, (long)dsamp, mask, feedbk);
3205 );
3206 unit->m_feedbk = feedbk;
3207 unit->m_dsamp = dsamp;
3208 unit->m_delaytime = delaytime;
3209 unit->m_decaytime = decaytime;
3210 }
3211
3212 unit->m_iwrphase = iwrphase;
3213 }
3214
3215 void BufCombN_next_z(BufCombN *unit, int inNumSamples)
3216 {
3217 float *out = ZOUT(0);
3218 const float *in = ZIN(1);
3219 float delaytime = ZIN0(2);
3220 float decaytime = ZIN0(3);
3221
3222 GET_BUF
3223 CHECK_BUF
3224 long iwrphase = unit->m_iwrphase;
3225 float dsamp = unit->m_dsamp;
3226 float feedbk = unit->m_feedbk;
3227
3228 //Print("BufCombN_next_z %g %g %g %g %d %d %d\n", delaytime, decaytime, feedbk, dsamp, mask, iwrphase, zorg);
3229 if (delaytime == unit->m_delaytime) {
3230 long irdphase = iwrphase - (long)dsamp;
3231 float* dlybuf1 = bufData - ZOFF;
3232 float* dlyN = dlybuf1 + PREVIOUSPOWEROFTWO(bufSamples);
3233 if (decaytime == unit->m_decaytime) {
3234 long remain = inNumSamples;
3235 while (remain) {
3236 float* dlywr = dlybuf1 + (iwrphase & mask);
3237 float* dlyrd = dlybuf1 + (irdphase & mask);
3238 long rdspace = dlyN - dlyrd;
3239 long wrspace = dlyN - dlywr;
3240 long nsmps = sc_min(rdspace, wrspace);
3241 nsmps = sc_min(remain, nsmps);
3242 remain -= nsmps;
3243 if (irdphase < 0) {
3244 LOOP1(nsmps,
3245 ZXP(dlywr) = ZXP(in);
3246 ZXP(out) = 0.f;
3247 );
3248 } else {
3249 LOOP1(nsmps,
3250 float value = ZXP(dlyrd);
3251 ZXP(dlywr) = value * feedbk + ZXP(in);
3252 ZXP(out) = value;
3253 );
3254 }
3255 iwrphase += nsmps;
3256 irdphase += nsmps;
3257 }
3258 } else {
3259 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
3260 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
3261 long remain = inNumSamples;
3262 while (remain) {
3263 float* dlyrd = dlybuf1 + (irdphase & mask);
3264 float* dlywr = dlybuf1 + (iwrphase & mask);
3265 long rdspace = dlyN - dlyrd;
3266 long wrspace = dlyN - dlywr;
3267 long nsmps = sc_min(rdspace, wrspace);
3268 nsmps = sc_min(remain, nsmps);
3269 remain -= nsmps;
3270
3271 if (irdphase < 0) {
3272 feedbk += nsmps * feedbk_slope;
3273 dlyrd += nsmps;
3274 LOOP1(nsmps,
3275 ZXP(dlywr) = ZXP(in);
3276 ZXP(out) = 0.f;
3277 );
3278 } else {
3279 LOOP1(nsmps,
3280 float value = ZXP(dlyrd);
3281 ZXP(dlywr) = value * feedbk + ZXP(in);
3282 ZXP(out) = value;
3283 feedbk += feedbk_slope;
3284 );
3285 }
3286 iwrphase += nsmps;
3287 irdphase += nsmps;
3288 }
3289 unit->m_feedbk = feedbk;
3290 unit->m_decaytime = decaytime;
3291 }
3292 } else {
3293 float next_dsamp = BufCalcDelay(unit, bufSamples, delaytime);
3294 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
3295
3296 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
3297 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
3298
3299 LOOP1(inNumSamples,
3300 dsamp += dsamp_slope;
3301 feedbk += feedbk_slope;
3302 CombN_helper<true>::perform(in, out, bufData, iwrphase, (long)dsamp, mask, feedbk);
3303 );
3304 unit->m_feedbk = feedbk;
3305 unit->m_dsamp = dsamp;
3306 unit->m_delaytime = delaytime;
3307 unit->m_decaytime = decaytime;
3308 }
3309
3310 unit->m_iwrphase = iwrphase;
3311
3312 unit->m_numoutput += inNumSamples;
3313 if (unit->m_numoutput >= bufSamples)
3314 SETCALC(BufCombN_next);
3315 }
3316
3317 template <bool checked>
3318 inline void BufCombN_perform_a(BufCombN *unit, int inNumSamples)
3319 {
3320 BufFilterX_perform_a<CombN_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufCombN_next_a);
3321 }
3322
3323 void BufCombN_next_a(BufCombN *unit, int inNumSamples)
3324 {
3325 BufCombN_perform_a<false>(unit, inNumSamples);
3326 }
3327
3328 void BufCombN_next_a_z(BufCombN *unit, int inNumSamples)
3329 {
3330 BufCombN_perform_a<true>(unit, inNumSamples);
3331 }
3332
3333 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3334 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3335
3336 void BufCombL_Ctor(BufCombL *unit)
3337 {
3338 BufFeedbackDelay_Reset(unit);
3339 if(INRATE(2) == calc_FullRate)
3340 SETCALC(BufCombL_next_a_z);
3341 else
3342 SETCALC(BufCombL_next_z);
3343 ZOUT0(0) = 0.f;
3344 }
3345
3346 template <bool checked>
3347 inline void BufCombL_perform(BufCombL *unit, int inNumSamples)
3348 {
3349 BufFilterX_perform<CombL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufCombL_next);
3350 }
3351
3352 void BufCombL_next(BufCombL *unit, int inNumSamples)
3353 {
3354 BufCombL_perform<false>(unit, inNumSamples);
3355 }
3356
3357 void BufCombL_next_z(BufCombL *unit, int inNumSamples)
3358 {
3359 BufCombL_perform<true>(unit, inNumSamples);
3360 }
3361
3362 template <bool checked>
3363 inline void BufCombL_perform_a(BufCombL *unit, int inNumSamples)
3364 {
3365 BufFilterX_perform_a<CombL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufCombL_next_a);
3366 }
3367
3368 void BufCombL_next_a(BufCombL *unit, int inNumSamples)
3369 {
3370 BufCombL_perform_a<false>(unit, inNumSamples);
3371 }
3372
3373 void BufCombL_next_a_z(BufCombL *unit, int inNumSamples)
3374 {
3375 BufCombL_perform_a<true>(unit, inNumSamples);
3376 }
3377
3378
3379 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3380
3381 void BufCombC_Ctor(BufCombC *unit)
3382 {
3383 BufFeedbackDelay_Reset(unit);
3384 if(INRATE(2) == calc_FullRate)
3385 SETCALC(BufCombC_next_a_z);
3386 else
3387 SETCALC(BufCombC_next_z);
3388 ZOUT0(0) = 0.f;
3389 }
3390
3391
3392 template <bool checked>
3393 inline void BufCombC_perform(BufCombC *unit, int inNumSamples)
3394 {
3395 BufFilterX_perform<CombN_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufCombC_next);
3396 }
3397
3398 void BufCombC_next(BufCombC *unit, int inNumSamples)
3399 {
3400 BufCombC_perform<false>(unit, inNumSamples);
3401 }
3402
3403 void BufCombC_next_z(BufCombC *unit, int inNumSamples)
3404 {
3405 BufCombC_perform<true>(unit, inNumSamples);
3406 }
3407
3408 template <bool checked>
3409 inline void BufCombC_perform_a(BufCombC *unit, int inNumSamples)
3410 {
3411 BufFilterX_perform_a<CombC_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufCombC_next_a);
3412 }
3413
3414 void BufCombC_next_a(BufCombC *unit, int inNumSamples)
3415 {
3416 BufCombC_perform_a<false>(unit, inNumSamples);
3417 }
3418
3419 void BufCombC_next_a_z(BufCombC *unit, int inNumSamples)
3420 {
3421 BufCombC_perform_a<true>(unit, inNumSamples);
3422 }
3423
3424
3425 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3426 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3427
3428 void BufAllpassN_Ctor(BufAllpassN *unit)
3429 {
3430 BufFeedbackDelay_Reset(unit);
3431 if(INRATE(2) == calc_FullRate)
3432 SETCALC(BufAllpassN_next_a_z);
3433 else
3434 SETCALC(BufAllpassN_next_z);
3435 ZOUT0(0) = 0.f;
3436 }
3437
3438 void BufAllpassN_next(BufAllpassN *unit, int inNumSamples)
3439 {
3440 float *out = ZOUT(0);
3441 const float *in = ZIN(1);
3442 float delaytime = ZIN0(2);
3443 float decaytime = ZIN0(3);
3444
3445 GET_BUF
3446 CHECK_BUF
3447 long iwrphase = unit->m_iwrphase;
3448 float dsamp = unit->m_dsamp;
3449 float feedbk = unit->m_feedbk;
3450
3451 //postbuf("BufAllpassN_next %g %g %g %g %d %d %d\n", delaytime, decaytime, feedbk, dsamp, mask, iwrphase, zorg);
3452 if (delaytime == unit->m_delaytime) {
3453 long irdphase = iwrphase - (long)dsamp;
3454 float* dlybuf1 = bufData - ZOFF;
3455 float* dlyrd = dlybuf1 + (irdphase & mask);
3456 float* dlywr = dlybuf1 + (iwrphase & mask);
3457 float* dlyN = dlybuf1 + PREVIOUSPOWEROFTWO(bufSamples);
3458 if (decaytime == unit->m_decaytime) {
3459 long remain = inNumSamples;
3460 while (remain) {
3461 long rdspace = dlyN - dlyrd;
3462 long wrspace = dlyN - dlywr;
3463 long nsmps = sc_min(rdspace, wrspace);
3464 nsmps = sc_min(remain, nsmps);
3465 remain -= nsmps;
3466 LOOP1(nsmps,
3467 float value = ZXP(dlyrd);
3468 float dwr = value * feedbk + ZXP(in);
3469 ZXP(dlywr) = dwr;
3470 ZXP(out) = value - feedbk * dwr;
3471 );
3472 if (dlyrd == dlyN) dlyrd = dlybuf1;
3473 if (dlywr == dlyN) dlywr = dlybuf1;
3474 }
3475 } else {
3476 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
3477 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
3478 long remain = inNumSamples;
3479 while (remain) {
3480 long rdspace = dlyN - dlyrd;
3481 long wrspace = dlyN - dlywr;
3482 long nsmps = sc_min(rdspace, wrspace);
3483 nsmps = sc_min(remain, nsmps);
3484 remain -= nsmps;
3485
3486 LOOP1(nsmps,
3487 float value = ZXP(dlyrd);
3488 float dwr = value * feedbk + ZXP(in);
3489 ZXP(dlywr) = dwr;
3490 ZXP(out) = value - feedbk * dwr;
3491 feedbk += feedbk_slope;
3492 );
3493 if (dlyrd == dlyN) dlyrd = dlybuf1;
3494 if (dlywr == dlyN) dlywr = dlybuf1;
3495 }
3496 unit->m_feedbk = feedbk;
3497 unit->m_decaytime = decaytime;
3498 }
3499 iwrphase += inNumSamples;
3500 } else {
3501 float next_dsamp = BufCalcDelay(unit, bufSamples, delaytime);
3502 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
3503
3504 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
3505 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
3506 LOOP1(inNumSamples,
3507 dsamp += dsamp_slope;
3508 feedbk += feedbk_slope;
3509 AllpassN_helper<false>::perform(in, out, bufData, iwrphase, (long)dsamp, mask, feedbk);
3510 );
3511 unit->m_feedbk = feedbk;
3512 unit->m_dsamp = dsamp;
3513 unit->m_delaytime = delaytime;
3514 unit->m_decaytime = decaytime;
3515 }
3516
3517 unit->m_iwrphase = iwrphase;
3518 }
3519
3520
3521 void BufAllpassN_next_z(BufAllpassN *unit, int inNumSamples)
3522 {
3523 float *out = ZOUT(0);
3524 const float *in = ZIN(1);
3525 float delaytime = ZIN0(2);
3526 float decaytime = ZIN0(3);
3527
3528 GET_BUF
3529 CHECK_BUF
3530 long iwrphase = unit->m_iwrphase;
3531 float dsamp = unit->m_dsamp;
3532 float feedbk = unit->m_feedbk;
3533
3534 //postbuf("BufAllpassN_next_z %g %g %g %g %d %d %d\n", delaytime, decaytime, feedbk, dsamp, mask, iwrphase, zorg);
3535 if (delaytime == unit->m_delaytime) {
3536 long irdphase = iwrphase - (long)dsamp;
3537 float* dlybuf1 = bufData - ZOFF;
3538 float* dlyN = dlybuf1 + PREVIOUSPOWEROFTWO(bufSamples);
3539 if (decaytime == unit->m_decaytime) {
3540 long remain = inNumSamples;
3541 while (remain) {
3542 float* dlywr = dlybuf1 + (iwrphase & mask);
3543 float* dlyrd = dlybuf1 + (irdphase & mask);
3544 long rdspace = dlyN - dlyrd;
3545 long wrspace = dlyN - dlywr;
3546 long nsmps = sc_min(rdspace, wrspace);
3547 nsmps = sc_min(remain, nsmps);
3548 remain -= nsmps;
3549 if (irdphase < 0) {
3550 feedbk = -feedbk;
3551 LOOP1(nsmps,
3552 float dwr = ZXP(in);
3553 ZXP(dlywr) = dwr;
3554 ZXP(out) = feedbk * dwr;
3555 );
3556 feedbk = -feedbk;
3557 } else {
3558 LOOP1(nsmps,
3559 float x1 = ZXP(dlyrd);
3560 float dwr = x1 * feedbk + ZXP(in);
3561 ZXP(dlywr) = dwr;
3562 ZXP(out) = x1 - feedbk * dwr;
3563 );
3564 }
3565 iwrphase += nsmps;
3566 irdphase += nsmps;
3567 }
3568 } else {
3569 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
3570 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
3571 long remain = inNumSamples;
3572 while (remain) {
3573 float* dlyrd = dlybuf1 + (irdphase & mask);
3574 float* dlywr = dlybuf1 + (iwrphase & mask);
3575 long rdspace = dlyN - dlyrd;
3576 long wrspace = dlyN - dlywr;
3577 long nsmps = sc_min(rdspace, wrspace);
3578 nsmps = sc_min(remain, nsmps);
3579 remain -= nsmps;
3580
3581 if (irdphase < 0) {
3582 dlyrd += nsmps;
3583 LOOP1(nsmps,
3584 float dwr = ZXP(in);
3585 ZXP(dlywr) = dwr;
3586 ZXP(out) = -feedbk * dwr;
3587 feedbk += feedbk_slope;
3588 );
3589 } else {
3590 LOOP1(nsmps,
3591 float x1 = ZXP(dlyrd);
3592 float dwr = x1 * feedbk + ZXP(in);
3593 ZXP(dlywr) = dwr;
3594 ZXP(out) = x1 - feedbk * dwr;
3595 feedbk += feedbk_slope;
3596 );
3597 }
3598 iwrphase += nsmps;
3599 irdphase += nsmps;
3600 }
3601 unit->m_feedbk = feedbk;
3602 unit->m_decaytime = decaytime;
3603 }
3604 } else {
3605 float next_dsamp = BufCalcDelay(unit, bufSamples, delaytime);
3606 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
3607
3608 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
3609 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
3610
3611 LOOP1(inNumSamples,
3612 dsamp += dsamp_slope;
3613 feedbk += feedbk_slope;
3614 AllpassN_helper<true>::perform(in, out, bufData, iwrphase, (long)dsamp, mask, feedbk);
3615 );
3616 unit->m_feedbk = feedbk;
3617 unit->m_dsamp = dsamp;
3618 unit->m_delaytime = delaytime;
3619 unit->m_decaytime = decaytime;
3620 }
3621
3622 unit->m_iwrphase = iwrphase;
3623
3624 unit->m_numoutput += inNumSamples;
3625 if (unit->m_numoutput >= bufSamples)
3626 SETCALC(BufAllpassN_next);
3627 }
3628
3629 template <bool checked>
3630 inline void BufAllpassN_perform_a(BufAllpassN *unit, int inNumSamples)
3631 {
3632 BufFilterX_perform_a<AllpassN_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufAllpassN_next_a);
3633 }
3634
3635 void BufAllpassN_next_a(BufAllpassN *unit, int inNumSamples)
3636 {
3637 BufAllpassN_perform_a<false>(unit, inNumSamples);
3638 }
3639
3640 void BufAllpassN_next_a_z(BufAllpassN *unit, int inNumSamples)
3641 {
3642 BufAllpassN_perform_a<true>(unit, inNumSamples);
3643 }
3644
3645
3646 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3647 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3648
3649 void BufAllpassL_Ctor(BufAllpassL *unit)
3650 {
3651 BufFeedbackDelay_Reset(unit);
3652 if(INRATE(2) == calc_FullRate)
3653 SETCALC(BufAllpassL_next_a_z);
3654 else
3655 SETCALC(BufAllpassL_next_z);
3656 ZOUT0(0) = 0.f;
3657 }
3658
3659 template <bool checked>
3660 inline void BufAllpassL_perform(BufAllpassL *unit, int inNumSamples)
3661 {
3662 BufFilterX_perform<AllpassL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufAllpassL_next);
3663 }
3664
3665 void BufAllpassL_next(BufAllpassL *unit, int inNumSamples)
3666 {
3667 BufAllpassL_perform<false>(unit, inNumSamples);
3668 }
3669
3670 void BufAllpassL_next_z(BufAllpassL *unit, int inNumSamples)
3671 {
3672 BufAllpassL_perform<true>(unit, inNumSamples);
3673 }
3674
3675 template <bool checked>
3676 inline void BufAllpassL_perform_a(BufAllpassL *unit, int inNumSamples)
3677 {
3678 BufFilterX_perform_a<AllpassL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufAllpassL_next_a);
3679 }
3680
3681 void BufAllpassL_next_a(BufAllpassL *unit, int inNumSamples)
3682 {
3683 BufAllpassL_perform_a<false>(unit, inNumSamples);
3684 }
3685
3686 void BufAllpassL_next_a_z(BufAllpassL *unit, int inNumSamples)
3687 {
3688 BufAllpassL_perform_a<true>(unit, inNumSamples);
3689 }
3690
3691
3692 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3693 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3694
3695 void BufAllpassC_Ctor(BufAllpassC *unit)
3696 {
3697 BufFeedbackDelay_Reset(unit);
3698 if(INRATE(2) == calc_FullRate)
3699 SETCALC(BufAllpassC_next_a_z);
3700 else
3701 SETCALC(BufAllpassC_next_z);
3702 ZOUT0(0) = 0.f;
3703 }
3704
3705 template <bool checked>
3706 inline void BufAllpassC_perform(BufAllpassC *unit, int inNumSamples)
3707 {
3708 BufFilterX_perform<AllpassC_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufAllpassC_next);
3709 }
3710
3711 void BufAllpassC_next(BufAllpassC *unit, int inNumSamples)
3712 {
3713 BufAllpassC_perform<false>(unit, inNumSamples);
3714 }
3715
3716 void BufAllpassC_next_z(BufAllpassC *unit, int inNumSamples)
3717 {
3718 BufAllpassC_perform<true>(unit, inNumSamples);
3719 }
3720
3721 template <bool checked>
3722 inline void BufAllpassC_perform_a(BufAllpassC *unit, int inNumSamples)
3723 {
3724 BufFilterX_perform_a<AllpassC_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)BufAllpassC_next_a);
3725 }
3726
3727 void BufAllpassC_next_a(BufAllpassC *unit, int inNumSamples)
3728 {
3729 BufAllpassC_perform_a<false>(unit, inNumSamples);
3730 }
3731
3732 void BufAllpassC_next_a_z(BufAllpassC *unit, int inNumSamples)
3733 {
3734 BufAllpassC_perform_a<true>(unit, inNumSamples);
3735 }
3736
3737 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3738 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3739 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3740 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3741
3742 static bool DelayUnit_AllocDelayLine(DelayUnit *unit, const char * className)
3743 {
3744 long delaybufsize = (long)ceil(unit->m_maxdelaytime * SAMPLERATE + 1.f);
3745 delaybufsize = delaybufsize + BUFLENGTH;
3746 delaybufsize = NEXTPOWEROFTWO(delaybufsize); // round up to next power of two
3747 unit->m_fdelaylen = unit->m_idelaylen = delaybufsize;
3748
3749 if (unit->m_dlybuf)
3750 RTFree(unit->mWorld, unit->m_dlybuf);
3751 unit->m_dlybuf = (float*)RTAlloc(unit->mWorld, delaybufsize * sizeof(float));
3752
3753 if (unit->m_dlybuf == NULL) {
3754 SETCALC(ft->fClearUnitOutputs);
3755 ClearUnitOutputs(unit, 1);
3756
3757 if(unit->mWorld->mVerbosity > -2)
3758 Print("Failed to allocate memory for %s ugen.\n", className);
3759 }
3760
3761 unit->m_mask = delaybufsize - 1;
3762 return (unit->m_dlybuf != NULL);
3763 }
3764
3765 template <typename Unit>
3766 static float CalcDelay(Unit *unit, float delaytime)
3767 {
3768 float minDelay = Unit::minDelaySamples;
3769 float next_dsamp = delaytime * (float)SAMPLERATE;
3770 return sc_clip(next_dsamp, minDelay, unit->m_fdelaylen);
3771 }
3772
3773 template <typename Unit>
3774 static bool DelayUnit_Reset(Unit *unit, const char * className)
3775 {
3776 unit->m_maxdelaytime = ZIN0(1);
3777 unit->m_delaytime = ZIN0(2);
3778 unit->m_dlybuf = 0;
3779
3780 if (!DelayUnit_AllocDelayLine(unit, className))
3781 return false;
3782
3783 unit->m_dsamp = CalcDelay(unit, unit->m_delaytime);
3784
3785 unit->m_numoutput = 0;
3786 unit->m_iwrphase = 0;
3787 return true;
3788 }
3789
3790
3791 void DelayUnit_Dtor(DelayUnit *unit)
3792 {
3793 RTFree(unit->mWorld, unit->m_dlybuf);
3794 }
3795
3796 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3797
3798 template <typename Unit>
3799 static bool FeedbackDelay_Reset(Unit *unit, const char * className)
3800 {
3801 unit->m_decaytime = ZIN0(3);
3802
3803 bool allocationSucessful = DelayUnit_Reset(unit, className);
3804 if (!allocationSucessful)
3805 return false;
3806
3807 unit->m_feedbk = sc_CalcFeedback(unit->m_delaytime, unit->m_decaytime);
3808 return true;
3809 }
3810
3811 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3812
3813 /* template function to generate delay ugen function, control-rate delay time */
3814 template <typename PerformClass,
3815 typename DelayX
3816 >
3817 inline void DelayX_perform(DelayX *unit, int inNumSamples, UnitCalcFunc resetFunc)
3818 {
3819 float *out = ZOUT(0);
3820 const float *in = ZIN(0);
3821 float delaytime = ZIN0(2);
3822
3823 float *dlybuf = unit->m_dlybuf;
3824 long iwrphase = unit->m_iwrphase;
3825 float dsamp = unit->m_dsamp;
3826 long mask = unit->m_mask;
3827
3828 if (delaytime == unit->m_delaytime) {
3829 long idsamp = (long)dsamp;
3830 float frac = dsamp - idsamp;
3831 LOOP1(inNumSamples,
3832 PerformClass::perform(in, out, dlybuf, iwrphase, idsamp, frac, mask);
3833 );
3834 } else {
3835 float next_dsamp = CalcDelay(unit, delaytime);
3836 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
3837
3838 LOOP1(inNumSamples,
3839 dsamp += dsamp_slope;
3840 long idsamp = (long)dsamp;
3841 float frac = dsamp - idsamp;
3842 PerformClass::perform(in, out, dlybuf, iwrphase, idsamp, frac, mask);
3843 );
3844 unit->m_dsamp = dsamp;
3845 unit->m_delaytime = delaytime;
3846 }
3847
3848 unit->m_iwrphase = iwrphase;
3849
3850 if (PerformClass::checked) {
3851 unit->m_numoutput += inNumSamples;
3852 if (unit->m_numoutput >= unit->m_idelaylen)
3853 unit->mCalcFunc = resetFunc;
3854 }
3855 }
3856
3857 /* template function to generate delay ugen function, audio-rate delay time */
3858 template <typename PerformClass,
3859 typename DelayX
3860 >
3861 inline void DelayX_perform_a(DelayX *unit, int inNumSamples, UnitCalcFunc resetFunc)
3862 {
3863 float *out = ZOUT(0);
3864 const float *in = ZIN(0);
3865 float * delaytime = ZIN(2);
3866
3867 float *dlybuf = unit->m_dlybuf;
3868 long iwrphase = unit->m_iwrphase;
3869 long mask = unit->m_mask;
3870
3871 LOOP1(inNumSamples,
3872 float dsamp = CalcDelay(unit, ZXP(delaytime));
3873 long idsamp = (long)dsamp;
3874
3875 float frac = dsamp - idsamp;
3876 PerformClass::perform(in, out, dlybuf, iwrphase, idsamp, frac, mask);
3877 );
3878
3879 unit->m_iwrphase = iwrphase;
3880
3881 if (PerformClass::checked)
3882 {
3883 unit->m_numoutput += inNumSamples;
3884 if (unit->m_numoutput >= unit->m_idelaylen)
3885 unit->mCalcFunc = resetFunc;
3886 }
3887 }
3888
3889
3890 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3891
3892 void Delay_next_0(DelayUnit *unit, int inNumSamples)
3893 {
3894 float *out = OUT(0);
3895 const float *in = IN(0);
3896
3897 memcpy(out, in, inNumSamples * sizeof(float));
3898 }
3899
3900 void Delay_next_0_nop(DelayUnit *unit, int inNumSamples)
3901 {}
3902
3903 #ifdef NOVA_SIMD
3904 void Delay_next_0_nova(DelayUnit *unit, int inNumSamples)
3905 {
3906 nova::copyvec_simd(OUT(0), IN(0), inNumSamples);
3907 }
3908 #endif
3909
3910 static bool DelayUnit_init_0(DelayUnit *unit)
3911 {
3912 if (INRATE(2) == calc_ScalarRate && ZIN0(2) == 0) {
3913 if (ZIN(0) == ZOUT(0))
3914 SETCALC(Delay_next_0_nop);
3915 #ifdef NOVA_SIMD
3916 else if (!(BUFLENGTH & 15))
3917 SETCALC(Delay_next_0_nova);
3918 #endif
3919 else
3920 SETCALC(Delay_next_0);
3921
3922 ZOUT0(0) = ZIN0(0);
3923 return true;
3924 } else
3925 return false;
3926 }
3927
3928 enum {
3929 initializationComplete,
3930 initializationIncomplete
3931 };
3932
3933 template <typename Delay>
3934 static int Delay_Ctor(Delay *unit, const char *className)
3935 {
3936 bool allocationSucessful = DelayUnit_Reset(unit, className);
3937 if (!allocationSucessful)
3938 return initializationComplete;
3939
3940 // optimize for a constant delay of zero
3941 if (DelayUnit_init_0(unit))
3942 return initializationComplete;
3943 return initializationIncomplete;
3944 }
3945
3946 ////////////////////////////////////////////////////////////////////////////////////////////////////////
3947
3948 void DelayN_Ctor(DelayN *unit)
3949 {
3950 if (Delay_Ctor(unit, "DelayN") == initializationComplete)
3951 return;
3952
3953 if (INRATE(2) == calc_FullRate)
3954 SETCALC(DelayN_next_a_z);
3955 else
3956 SETCALC(DelayN_next_z);
3957 ZOUT0(0) = 0.f;
3958 }
3959
3960 void DelayN_next(DelayN *unit, int inNumSamples)
3961 {
3962 float *out = ZOUT(0);
3963 const float *in = ZIN(0);
3964 float delaytime = ZIN0(2);
3965
3966 float *dlybuf = unit->m_dlybuf;
3967 long iwrphase = unit->m_iwrphase;
3968 float dsamp = unit->m_dsamp;
3969 long mask = unit->m_mask;
3970
3971 //Print("DelayN_next %p %g %g %d %d\n", unit, delaytime, dsamp, mask, iwrphase);
3972 if (delaytime == unit->m_delaytime) {
3973 DelayN_delay_loop<false>(out, in, iwrphase, dsamp, mask, dlybuf, inNumSamples, unit->m_idelaylen);
3974 } else {
3975 float next_dsamp = CalcDelay(unit, delaytime);
3976 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
3977
3978 LOOP1(inNumSamples,
3979 dsamp += dsamp_slope;
3980 DelayN_helper<false>::perform(in, out, dlybuf, iwrphase, (long)dsamp, mask);
3981 );
3982 unit->m_dsamp = dsamp;
3983 unit->m_delaytime = delaytime;
3984 }
3985
3986 unit->m_iwrphase = iwrphase;
3987 }
3988
3989
3990 void DelayN_next_z(DelayN *unit, int inNumSamples)
3991 {
3992 float *out = ZOUT(0);
3993 const float *in = ZIN(0);
3994 float delaytime = ZIN0(2);
3995
3996 float *dlybuf = unit->m_dlybuf;
3997 long iwrphase = unit->m_iwrphase;
3998 float dsamp = unit->m_dsamp;
3999 long mask = unit->m_mask;
4000
4001 if (delaytime == unit->m_delaytime) {
4002 DelayN_delay_loop<true>(out, in, iwrphase, dsamp, mask, dlybuf, inNumSamples, unit->m_idelaylen);
4003 } else {
4004 float next_dsamp = CalcDelay(unit, delaytime);
4005 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
4006
4007 LOOP1(inNumSamples,
4008 dsamp += dsamp_slope;
4009 DelayN_helper<true>::perform(in, out, dlybuf, iwrphase, (long)dsamp, mask);
4010 );
4011 unit->m_dsamp = dsamp;
4012 unit->m_delaytime = delaytime;
4013 }
4014
4015 unit->m_iwrphase = iwrphase;
4016
4017 unit->m_numoutput += inNumSamples;
4018 if (unit->m_numoutput >= unit->m_idelaylen)
4019 SETCALC(DelayN_next);
4020 }
4021
4022 template <bool checked>
4023 inline void DelayN_perform_a(DelayN *unit, int inNumSamples)
4024 {
4025 DelayX_perform_a<DelayN_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)DelayN_next_a);
4026 }
4027
4028 void DelayN_next_a(DelayN *unit, int inNumSamples)
4029 {
4030 DelayN_perform_a<false>(unit, inNumSamples);
4031 }
4032
4033 void DelayN_next_a_z(DelayN *unit, int inNumSamples)
4034 {
4035 DelayN_perform_a<true>(unit, inNumSamples);
4036 }
4037
4038
4039 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4040
4041 void DelayL_Ctor(DelayL *unit)
4042 {
4043 if (Delay_Ctor(unit, "DelayL") == initializationComplete)
4044 return;
4045
4046 if (INRATE(2) == calc_FullRate)
4047 SETCALC(DelayL_next_a_z);
4048 else
4049 SETCALC(DelayL_next_z);
4050 ZOUT0(0) = 0.f;
4051 }
4052
4053 template <bool checked>
4054 inline void DelayL_perform(DelayL *unit, int inNumSamples)
4055 {
4056 DelayX_perform<DelayL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)DelayL_next);
4057 }
4058
4059 void DelayL_next(DelayL *unit, int inNumSamples)
4060 {
4061 DelayL_perform<false>(unit, inNumSamples);
4062 }
4063
4064 void DelayL_next_z(DelayL *unit, int inNumSamples)
4065 {
4066 DelayL_perform<true>(unit, inNumSamples);
4067 }
4068
4069 template <bool checked>
4070 inline void DelayL_perform_a(DelayL *unit, int inNumSamples)
4071 {
4072 DelayX_perform_a<DelayL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)DelayL_next_a);
4073 }
4074
4075 void DelayL_next_a(DelayL *unit, int inNumSamples)
4076 {
4077 DelayL_perform_a<false>(unit, inNumSamples);
4078 }
4079
4080 void DelayL_next_a_z(DelayL *unit, int inNumSamples)
4081 {
4082 DelayL_perform_a<true>(unit, inNumSamples);
4083 }
4084
4085
4086 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4087
4088 void DelayC_Ctor(DelayC *unit)
4089 {
4090 if (Delay_Ctor(unit, "DelayC") == initializationComplete)
4091 return;
4092
4093 if (INRATE(2) == calc_FullRate)
4094 SETCALC(DelayC_next_a_z);
4095 else
4096 SETCALC(DelayC_next_z);
4097 ZOUT0(0) = 0.f;
4098 }
4099
4100 template <bool checked>
4101 inline void DelayC_perform(DelayC *unit, int inNumSamples)
4102 {
4103 DelayX_perform<DelayC_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)DelayC_next);
4104 }
4105
4106 void DelayC_next(DelayC *unit, int inNumSamples)
4107 {
4108 DelayC_perform<false>(unit, inNumSamples);
4109 }
4110
4111 void DelayC_next_z(DelayC *unit, int inNumSamples)
4112 {
4113 DelayC_perform<true>(unit, inNumSamples);
4114 }
4115
4116
4117 template <bool checked>
4118 inline void DelayC_perform_a(DelayC *unit, int inNumSamples)
4119 {
4120 DelayX_perform_a<DelayC_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)DelayC_next_a);
4121 }
4122
4123 void DelayC_next_a(DelayC *unit, int inNumSamples)
4124 {
4125 DelayC_perform_a<false>(unit, inNumSamples);
4126 }
4127
4128 void DelayC_next_a_z(DelayC *unit, int inNumSamples)
4129 {
4130 DelayC_perform_a<true>(unit, inNumSamples);
4131 }
4132
4133 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4134 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4135
4136 template <typename PerformClass,
4137 typename BufCombX
4138 >
4139 inline void FilterX_perform(BufCombX *unit, int inNumSamples, UnitCalcFunc resetFunc)
4140 {
4141 float *out = ZOUT(0);
4142 const float *in = ZIN(0);
4143 float delaytime = ZIN0(2);
4144 float decaytime = ZIN0(3);
4145
4146 float *dlybuf = unit->m_dlybuf;
4147 long iwrphase = unit->m_iwrphase;
4148 float dsamp = unit->m_dsamp;
4149 float feedbk = unit->m_feedbk;
4150 long mask = unit->m_mask;
4151
4152 if (delaytime == unit->m_delaytime && decaytime == unit->m_decaytime) {
4153 long idsamp = (long)dsamp;
4154 float frac = dsamp - idsamp;
4155 LOOP1(inNumSamples,
4156 PerformClass::perform(in, out, dlybuf, iwrphase, idsamp, frac, mask, feedbk);
4157 );
4158 } else {
4159 float next_dsamp = CalcDelay(unit, delaytime);
4160 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
4161
4162 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
4163 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
4164
4165 LOOP1(inNumSamples,
4166 dsamp += dsamp_slope;
4167 feedbk += feedbk_slope;
4168 long idsamp = (long)dsamp;
4169 float frac = dsamp - idsamp;
4170 PerformClass::perform(in, out, dlybuf, iwrphase, idsamp, frac, mask, feedbk);
4171 );
4172 unit->m_feedbk = feedbk;
4173 unit->m_dsamp = dsamp;
4174 unit->m_delaytime = delaytime;
4175 unit->m_decaytime = decaytime;
4176 }
4177
4178 unit->m_iwrphase = iwrphase;
4179
4180 if (PerformClass::checked) {
4181 unit->m_numoutput += inNumSamples;
4182 if (unit->m_numoutput >= unit->m_idelaylen)
4183 unit->mCalcFunc = resetFunc;
4184 }
4185 }
4186
4187 template <typename PerformClass,
4188 typename CombX
4189 >
4190 inline void FilterX_perform_a(CombX *unit, int inNumSamples, UnitCalcFunc resetFunc)
4191 {
4192 float *out = ZOUT(0);
4193 const float *in = ZIN(0);
4194 float * delaytime = ZIN(2);
4195 float decaytime = ZIN0(3);
4196
4197 float *dlybuf = unit->m_dlybuf;
4198 long iwrphase = unit->m_iwrphase;
4199 float dsamp = unit->m_dsamp;
4200 float feedbk = unit->m_feedbk;
4201 long mask = unit->m_mask;
4202
4203 LOOP1(inNumSamples,
4204 float del = ZXP(delaytime);
4205 float dsamp = CalcDelay(unit, del);
4206 float feedbk = sc_CalcFeedback(del, decaytime);
4207
4208 long idsamp = (long)dsamp;
4209 float frac = dsamp - idsamp;
4210 PerformClass::perform(in, out, dlybuf, iwrphase, idsamp, frac, mask, feedbk);
4211 );
4212
4213 unit->m_iwrphase = iwrphase;
4214
4215 if (PerformClass::checked)
4216 {
4217 unit->m_numoutput += inNumSamples;
4218 if (unit->m_numoutput >= unit->m_idelaylen)
4219 unit->mCalcFunc = resetFunc;
4220 }
4221 }
4222
4223 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4224
4225 void CombN_Ctor(CombN *unit)
4226 {
4227 bool allocationSucessful = FeedbackDelay_Reset(unit, "CombN");
4228 if (!allocationSucessful)
4229 return;
4230
4231 if(INRATE(2) == calc_FullRate)
4232 SETCALC(CombN_next_a_z);
4233 else
4234 SETCALC(CombN_next_z);
4235 ZOUT0(0) = 0.f;
4236 }
4237
4238 void CombN_next(CombN *unit, int inNumSamples)
4239 {
4240 float *out = ZOUT(0);
4241 const float *in = ZIN(0);
4242 float delaytime = ZIN0(2);
4243 float decaytime = ZIN0(3);
4244
4245 float *dlybuf = unit->m_dlybuf;
4246 long iwrphase = unit->m_iwrphase;
4247 float dsamp = unit->m_dsamp;
4248 float feedbk = unit->m_feedbk;
4249 long mask = unit->m_mask;
4250
4251 //postbuf("CombN_next %g %g %g %g %d %d %d\n", delaytime, decaytime, feedbk, dsamp, mask, iwrphase, zorg);
4252 if (delaytime == unit->m_delaytime) {
4253 long irdphase = iwrphase - (long)dsamp;
4254 float* dlybuf1 = dlybuf - ZOFF;
4255 float* dlyrd = dlybuf1 + (irdphase & mask);
4256 float* dlywr = dlybuf1 + (iwrphase & mask);
4257 float* dlyN = dlybuf1 + unit->m_idelaylen;
4258 if (decaytime == unit->m_decaytime) {
4259 long remain = inNumSamples;
4260 while (remain) {
4261 long rdspace = dlyN - dlyrd;
4262 long wrspace = dlyN - dlywr;
4263 long nsmps = sc_min(rdspace, wrspace);
4264 nsmps = sc_min(remain, nsmps);
4265 remain -= nsmps;
4266 LOOP(nsmps,
4267 float value = ZXP(dlyrd);
4268 ZXP(dlywr) = value * feedbk + ZXP(in);
4269 ZXP(out) = value;
4270 );
4271 if (dlyrd == dlyN) dlyrd = dlybuf1;
4272 if (dlywr == dlyN) dlywr = dlybuf1;
4273 }
4274 } else {
4275 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
4276 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
4277 long remain = inNumSamples;
4278 while (remain) {
4279 long rdspace = dlyN - dlyrd;
4280 long wrspace = dlyN - dlywr;
4281 long nsmps = sc_min(rdspace, wrspace);
4282 nsmps = sc_min(remain, nsmps);
4283 remain -= nsmps;
4284
4285 LOOP(nsmps,
4286 float value = ZXP(dlyrd);
4287 ZXP(dlywr) = value * feedbk + ZXP(in);
4288 ZXP(out) = value;
4289 feedbk += feedbk_slope;
4290 );
4291 if (dlyrd == dlyN) dlyrd = dlybuf1;
4292 if (dlywr == dlyN) dlywr = dlybuf1;
4293 }
4294 unit->m_feedbk = feedbk;
4295 unit->m_decaytime = decaytime;
4296 }
4297 iwrphase += inNumSamples;
4298 } else {
4299 float next_dsamp = CalcDelay(unit, delaytime);
4300 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
4301
4302 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
4303 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
4304 LOOP1(inNumSamples,
4305 dsamp += dsamp_slope;
4306 feedbk += feedbk_slope;
4307 CombN_helper<false>::perform(in, out, dlybuf, iwrphase, (long)dsamp, mask, feedbk);
4308 );
4309 unit->m_feedbk = feedbk;
4310 unit->m_dsamp = dsamp;
4311 unit->m_delaytime = delaytime;
4312 unit->m_decaytime = decaytime;
4313 }
4314
4315 unit->m_iwrphase = iwrphase;
4316 }
4317
4318
4319 void CombN_next_z(CombN *unit, int inNumSamples)
4320 {
4321 float *out = ZOUT(0);
4322 const float *in = ZIN(0);
4323 float delaytime = ZIN0(2);
4324 float decaytime = ZIN0(3);
4325
4326 float *dlybuf = unit->m_dlybuf;
4327 long iwrphase = unit->m_iwrphase;
4328 float dsamp = unit->m_dsamp;
4329 float feedbk = unit->m_feedbk;
4330 long mask = unit->m_mask;
4331
4332 //postbuf("CombN_next_z %g %g %g %g %d %d %d\n", delaytime, decaytime, feedbk, dsamp, mask, iwrphase, zorg);
4333 if (delaytime == unit->m_delaytime) {
4334 long irdphase = iwrphase - (long)dsamp;
4335 float* dlybuf1 = dlybuf - ZOFF;
4336 float* dlyN = dlybuf1 + unit->m_idelaylen;
4337 if (decaytime == unit->m_decaytime) {
4338 long remain = inNumSamples;
4339 while (remain) {
4340 float* dlywr = dlybuf1 + (iwrphase & mask);
4341 float* dlyrd = dlybuf1 + (irdphase & mask);
4342 long rdspace = dlyN - dlyrd;
4343 long wrspace = dlyN - dlywr;
4344 long nsmps = sc_min(rdspace, wrspace);
4345 nsmps = sc_min(remain, nsmps);
4346 remain -= nsmps;
4347 if (irdphase < 0) {
4348 LOOP(nsmps,
4349 ZXP(dlywr) = ZXP(in);
4350 ZXP(out) = 0.f;
4351 );
4352 } else {
4353 LOOP(nsmps,
4354 float value = ZXP(dlyrd);
4355 ZXP(dlywr) = value * feedbk + ZXP(in);
4356 ZXP(out) = value;
4357 );
4358 }
4359 iwrphase += nsmps;
4360 irdphase += nsmps;
4361 }
4362 } else {
4363 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
4364 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
4365 long remain = inNumSamples;
4366 while (remain) {
4367 float* dlyrd = dlybuf1 + (irdphase & mask);
4368 float* dlywr = dlybuf1 + (iwrphase & mask);
4369 long rdspace = dlyN - dlyrd;
4370 long wrspace = dlyN - dlywr;
4371 long nsmps = sc_min(rdspace, wrspace);
4372 nsmps = sc_min(remain, nsmps);
4373 remain -= nsmps;
4374
4375 if (irdphase < 0) {
4376 feedbk += nsmps * feedbk_slope;
4377 dlyrd += nsmps;
4378 LOOP(nsmps,
4379 ZXP(dlywr) = ZXP(in);
4380 ZXP(out) = 0.f;
4381 );
4382 } else {
4383 LOOP(nsmps,
4384 float value = ZXP(dlyrd);
4385 ZXP(dlywr) = value * feedbk + ZXP(in);
4386 ZXP(out) = value;
4387 feedbk += feedbk_slope;
4388 );
4389 }
4390 iwrphase += nsmps;
4391 irdphase += nsmps;
4392 }
4393 unit->m_feedbk = feedbk;
4394 unit->m_decaytime = decaytime;
4395 }
4396 } else {
4397
4398 float next_dsamp = CalcDelay(unit, delaytime);
4399 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
4400
4401 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
4402 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
4403
4404 LOOP1(inNumSamples,
4405 dsamp += dsamp_slope;
4406 feedbk += feedbk_slope;
4407 CombN_helper<true>::perform(in, out, dlybuf, iwrphase, (long)dsamp, mask, feedbk);
4408 );
4409 unit->m_feedbk = feedbk;
4410 unit->m_dsamp = dsamp;
4411 unit->m_delaytime = delaytime;
4412 unit->m_decaytime = decaytime;
4413 }
4414
4415 unit->m_iwrphase = iwrphase;
4416
4417 unit->m_numoutput += inNumSamples;
4418 if (unit->m_numoutput >= unit->m_idelaylen)
4419 SETCALC(CombN_next);
4420 }
4421
4422 template <bool checked>
4423 inline void CombN_perform_a(CombN *unit, int inNumSamples)
4424 {
4425 FilterX_perform_a<CombN_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)CombN_next_a);
4426 }
4427
4428 void CombN_next_a(CombN *unit, int inNumSamples)
4429 {
4430 CombN_perform_a<false>(unit, inNumSamples);
4431 }
4432
4433 void CombN_next_a_z(CombN *unit, int inNumSamples)
4434 {
4435 CombN_perform_a<true>(unit, inNumSamples);
4436 }
4437
4438
4439 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4440 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4441
4442 void CombL_Ctor(CombL *unit)
4443 {
4444 bool allocationSucessful = FeedbackDelay_Reset(unit, "CombL");
4445 if (!allocationSucessful)
4446 return;
4447
4448 if(INRATE(2) == calc_FullRate)
4449 SETCALC(CombL_next_a_z);
4450 else
4451 SETCALC(CombL_next_z);
4452 ZOUT0(0) = 0.f;
4453 }
4454
4455 template <bool checked>
4456 inline void CombL_perform(CombL *unit, int inNumSamples)
4457 {
4458 FilterX_perform<CombL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)CombL_next);
4459 }
4460
4461 void CombL_next(CombL *unit, int inNumSamples)
4462 {
4463 CombL_perform<false>(unit, inNumSamples);
4464 }
4465
4466 void CombL_next_z(CombL *unit, int inNumSamples)
4467 {
4468 CombL_perform<true>(unit, inNumSamples);
4469 }
4470
4471 template <bool checked>
4472 inline void CombL_perform_a(CombL *unit, int inNumSamples)
4473 {
4474 FilterX_perform_a<CombL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)CombL_next_a);
4475 }
4476
4477 void CombL_next_a(CombL *unit, int inNumSamples)
4478 {
4479 CombL_perform_a<false>(unit, inNumSamples);
4480 }
4481
4482 void CombL_next_a_z(CombL *unit, int inNumSamples)
4483 {
4484 CombL_perform_a<true>(unit, inNumSamples);
4485 }
4486
4487 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4488
4489 void CombC_Ctor(CombC *unit)
4490 {
4491 bool allocationSucessful = FeedbackDelay_Reset(unit, "CombC");
4492 if (!allocationSucessful)
4493 return;
4494
4495 if(INRATE(2) == calc_FullRate)
4496 SETCALC(CombC_next_a_z);
4497 else
4498 SETCALC(CombC_next_z);
4499 ZOUT0(0) = 0.f;
4500 }
4501
4502 template <bool checked>
4503 inline void CombC_perform(CombC *unit, int inNumSamples)
4504 {
4505 FilterX_perform<CombC_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)CombC_next);
4506 }
4507
4508 void CombC_next(CombC *unit, int inNumSamples)
4509 {
4510 CombC_perform<false>(unit, inNumSamples);
4511 }
4512
4513 void CombC_next_z(CombC *unit, int inNumSamples)
4514 {
4515 CombC_perform<true>(unit, inNumSamples);
4516 }
4517
4518 template <bool checked>
4519 inline void CombC_perform_a(CombC *unit, int inNumSamples)
4520 {
4521 FilterX_perform_a<CombC_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)CombC_next_a);
4522 }
4523
4524 void CombC_next_a(CombC *unit, int inNumSamples)
4525 {
4526 CombC_perform_a<false>(unit, inNumSamples);
4527 }
4528
4529 void CombC_next_a_z(CombC *unit, int inNumSamples)
4530 {
4531 CombC_perform_a<true>(unit, inNumSamples);
4532 }
4533
4534
4535 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4536 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4537
4538 void AllpassN_Ctor(AllpassN *unit)
4539 {
4540 bool allocationSucessful = FeedbackDelay_Reset(unit, "AllpassN");
4541 if (!allocationSucessful)
4542 return;
4543
4544 if(INRATE(2) == calc_FullRate)
4545 SETCALC(AllpassN_next_a_z);
4546 else
4547 SETCALC(AllpassN_next_z);
4548 ZOUT0(0) = 0.f;
4549 }
4550
4551 void AllpassN_next(AllpassN *unit, int inNumSamples)
4552 {
4553 float *out = ZOUT(0);
4554 const float *in = ZIN(0);
4555 float delaytime = ZIN0(2);
4556 float decaytime = ZIN0(3);
4557
4558 float *dlybuf = unit->m_dlybuf;
4559 long iwrphase = unit->m_iwrphase;
4560 float dsamp = unit->m_dsamp;
4561 float feedbk = unit->m_feedbk;
4562 long mask = unit->m_mask;
4563
4564 //postbuf("AllpassN_next %g %g %g %g %d %d %d\n", delaytime, decaytime, feedbk, dsamp, mask, iwrphase, zorg);
4565 if (delaytime == unit->m_delaytime) {
4566 long irdphase = iwrphase - (long)dsamp;
4567 float* dlybuf1 = dlybuf - ZOFF;
4568 float* dlyrd = dlybuf1 + (irdphase & mask);
4569 float* dlywr = dlybuf1 + (iwrphase & mask);
4570 float* dlyN = dlybuf1 + unit->m_idelaylen;
4571 if (decaytime == unit->m_decaytime) {
4572 long remain = inNumSamples;
4573 while (remain) {
4574 long rdspace = dlyN - dlyrd;
4575 long wrspace = dlyN - dlywr;
4576 long nsmps = sc_min(rdspace, wrspace);
4577 nsmps = sc_min(remain, nsmps);
4578 remain -= nsmps;
4579 LOOP(nsmps,
4580 float value = ZXP(dlyrd);
4581 float dwr = value * feedbk + ZXP(in);
4582 ZXP(dlywr) = dwr;
4583 ZXP(out) = value - feedbk * dwr;
4584 );
4585 if (dlyrd == dlyN) dlyrd = dlybuf1;
4586 if (dlywr == dlyN) dlywr = dlybuf1;
4587 }
4588 } else {
4589 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
4590 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
4591 long remain = inNumSamples;
4592 while (remain) {
4593 long rdspace = dlyN - dlyrd;
4594 long wrspace = dlyN - dlywr;
4595 long nsmps = sc_min(rdspace, wrspace);
4596 nsmps = sc_min(remain, nsmps);
4597 remain -= nsmps;
4598
4599 LOOP(nsmps,
4600 float value = ZXP(dlyrd);
4601 float dwr = value * feedbk + ZXP(in);
4602 ZXP(dlywr) = dwr;
4603 ZXP(out) = value - feedbk * dwr;
4604 feedbk += feedbk_slope;
4605 );
4606 if (dlyrd == dlyN) dlyrd = dlybuf1;
4607 if (dlywr == dlyN) dlywr = dlybuf1;
4608 }
4609 unit->m_feedbk = feedbk;
4610 unit->m_decaytime = decaytime;
4611 }
4612 iwrphase += inNumSamples;
4613 } else {
4614 float next_dsamp = CalcDelay(unit, delaytime);
4615 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
4616
4617 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
4618 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
4619 LOOP1(inNumSamples,
4620 dsamp += dsamp_slope;
4621 feedbk += feedbk_slope;
4622 AllpassN_helper<false>::perform(in, out, dlybuf, iwrphase, (long)dsamp, mask, feedbk);
4623 );
4624 unit->m_feedbk = feedbk;
4625 unit->m_dsamp = dsamp;
4626 unit->m_delaytime = delaytime;
4627 unit->m_decaytime = decaytime;
4628 }
4629
4630 unit->m_iwrphase = iwrphase;
4631 }
4632
4633
4634 void AllpassN_next_z(AllpassN *unit, int inNumSamples)
4635 {
4636 float *out = ZOUT(0);
4637 const float *in = ZIN(0);
4638 float delaytime = ZIN0(2);
4639 float decaytime = ZIN0(3);
4640
4641 float *dlybuf = unit->m_dlybuf;
4642 long iwrphase = unit->m_iwrphase;
4643 float dsamp = unit->m_dsamp;
4644 float feedbk = unit->m_feedbk;
4645 long mask = unit->m_mask;
4646
4647 //postbuf("AllpassN_next_z %g %g %g %g %d %d %d\n", delaytime, decaytime, feedbk, dsamp, mask, iwrphase, zorg);
4648 if (delaytime == unit->m_delaytime) {
4649 long irdphase = iwrphase - (long)dsamp;
4650 float* dlybuf1 = dlybuf - ZOFF;
4651 float* dlyN = dlybuf1 + unit->m_idelaylen;
4652 if (decaytime == unit->m_decaytime) {
4653 long remain = inNumSamples;
4654 while (remain) {
4655 float* dlywr = dlybuf1 + (iwrphase & mask);
4656 float* dlyrd = dlybuf1 + (irdphase & mask);
4657 long rdspace = dlyN - dlyrd;
4658 long wrspace = dlyN - dlywr;
4659 long nsmps = sc_min(rdspace, wrspace);
4660 nsmps = sc_min(remain, nsmps);
4661 remain -= nsmps;
4662 if (irdphase < 0) {
4663 feedbk = -feedbk;
4664 LOOP(nsmps,
4665 float dwr = ZXP(in);
4666 ZXP(dlywr) = dwr;
4667 ZXP(out) = feedbk * dwr;
4668 );
4669 feedbk = -feedbk;
4670 } else {
4671 LOOP(nsmps,
4672 float x1 = ZXP(dlyrd);
4673 float dwr = x1 * feedbk + ZXP(in);
4674 ZXP(dlywr) = dwr;
4675 ZXP(out) = x1 - feedbk * dwr;
4676 );
4677 }
4678 iwrphase += nsmps;
4679 irdphase += nsmps;
4680 }
4681 } else {
4682 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
4683 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
4684 long remain = inNumSamples;
4685 while (remain) {
4686 float* dlyrd = dlybuf1 + (irdphase & mask);
4687 float* dlywr = dlybuf1 + (iwrphase & mask);
4688 long rdspace = dlyN - dlyrd;
4689 long wrspace = dlyN - dlywr;
4690 long nsmps = sc_min(rdspace, wrspace);
4691 nsmps = sc_min(remain, nsmps);
4692 remain -= nsmps;
4693
4694 if (irdphase < 0) {
4695 dlyrd += nsmps;
4696 LOOP(nsmps,
4697 float dwr = ZXP(in);
4698 ZXP(dlywr) = dwr;
4699 ZXP(out) = -feedbk * dwr;
4700 feedbk += feedbk_slope;
4701 );
4702 } else {
4703 LOOP(nsmps,
4704 float x1 = ZXP(dlyrd);
4705 float dwr = x1 * feedbk + ZXP(in);
4706 ZXP(dlywr) = dwr;
4707 ZXP(out) = x1 - feedbk * dwr;
4708 feedbk += feedbk_slope;
4709 );
4710 }
4711 iwrphase += nsmps;
4712 irdphase += nsmps;
4713 }
4714 unit->m_feedbk = feedbk;
4715 unit->m_decaytime = decaytime;
4716 }
4717 } else {
4718 float next_dsamp = CalcDelay(unit, delaytime);
4719 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
4720
4721 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
4722 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
4723
4724 LOOP1(inNumSamples,
4725 dsamp += dsamp_slope;
4726 feedbk += feedbk_slope;
4727 AllpassN_helper<true>::perform(in, out, dlybuf, iwrphase, (long)dsamp, mask, feedbk);
4728 );
4729 unit->m_feedbk = feedbk;
4730 unit->m_dsamp = dsamp;
4731 unit->m_delaytime = delaytime;
4732 unit->m_decaytime = decaytime;
4733 }
4734
4735 unit->m_iwrphase = iwrphase;
4736
4737 unit->m_numoutput += inNumSamples;
4738 if (unit->m_numoutput >= unit->m_idelaylen)
4739 SETCALC(AllpassN_next);
4740 }
4741
4742 template <bool checked>
4743 inline void AllpassN_perform_a(AllpassN *unit, int inNumSamples)
4744 {
4745 FilterX_perform_a<AllpassN_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)AllpassN_next_a);
4746 }
4747
4748 void AllpassN_next_a(AllpassN *unit, int inNumSamples)
4749 {
4750 AllpassN_perform_a<false>(unit, inNumSamples);
4751 }
4752
4753 void AllpassN_next_a_z(AllpassN *unit, int inNumSamples)
4754 {
4755 AllpassN_perform_a<true>(unit, inNumSamples);
4756 }
4757
4758
4759 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4760 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4761
4762 void AllpassL_Ctor(AllpassL *unit)
4763 {
4764 bool allocationSucessful = FeedbackDelay_Reset(unit, "AllpassL");
4765 if (!allocationSucessful)
4766 return;
4767
4768 if(INRATE(2) == calc_FullRate)
4769 SETCALC(AllpassL_next_a_z);
4770 else
4771 SETCALC(AllpassL_next_z);
4772 ZOUT0(0) = 0.f;
4773 }
4774
4775 template <bool checked>
4776 inline void AllpassL_perform(AllpassL *unit, int inNumSamples)
4777 {
4778 FilterX_perform<AllpassL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)AllpassL_next);
4779 }
4780
4781 void AllpassL_next(AllpassL *unit, int inNumSamples)
4782 {
4783 AllpassL_perform<false>(unit, inNumSamples);
4784 }
4785
4786 void AllpassL_next_z(AllpassL *unit, int inNumSamples)
4787 {
4788 AllpassL_perform<true>(unit, inNumSamples);
4789 }
4790
4791 template <bool checked>
4792 inline void AllpassL_perform_a(AllpassL *unit, int inNumSamples)
4793 {
4794 FilterX_perform_a<AllpassL_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)AllpassL_next_a);
4795 }
4796
4797 void AllpassL_next_a(AllpassL *unit, int inNumSamples)
4798 {
4799 AllpassL_perform_a<false>(unit, inNumSamples);
4800 }
4801
4802 void AllpassL_next_a_z(AllpassL *unit, int inNumSamples)
4803 {
4804 AllpassL_perform_a<true>(unit, inNumSamples);
4805 }
4806
4807 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4808 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4809
4810 void AllpassC_Ctor(AllpassC *unit)
4811 {
4812 bool allocationSucessful = FeedbackDelay_Reset(unit, "AllpassC");
4813 if (!allocationSucessful)
4814 return;
4815
4816 if(INRATE(2) == calc_FullRate)
4817 SETCALC(AllpassC_next_a_z);
4818 else
4819 SETCALC(AllpassC_next_z);
4820 ZOUT0(0) = 0.f;
4821 }
4822
4823 template <bool checked>
4824 inline void AllpassC_perform(AllpassC *unit, int inNumSamples)
4825 {
4826 FilterX_perform<AllpassC_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)AllpassC_next);
4827 }
4828
4829 void AllpassC_next(AllpassC *unit, int inNumSamples)
4830 {
4831 AllpassC_perform<false>(unit, inNumSamples);
4832 }
4833
4834 void AllpassC_next_z(AllpassC *unit, int inNumSamples)
4835 {
4836 AllpassC_perform<true>(unit, inNumSamples);
4837 }
4838
4839 template <bool checked>
4840 inline void AllpassC_perform_a(AllpassC *unit, int inNumSamples)
4841 {
4842 FilterX_perform_a<AllpassC_helper<checked> >(unit, inNumSamples, (UnitCalcFunc)AllpassC_next_a);
4843 }
4844
4845 void AllpassC_next_a(AllpassC *unit, int inNumSamples)
4846 {
4847 AllpassC_perform_a<false>(unit, inNumSamples);
4848 }
4849
4850 void AllpassC_next_a_z(AllpassC *unit, int inNumSamples)
4851 {
4852 AllpassC_perform_a<true>(unit, inNumSamples);
4853 }
4854
4855 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4856
4857
4858 inline double sc_loop1(int32 in, int32 lo, int32 hi)
4859 {
4860 // avoid the divide if possible
4861 if (in >= hi) {
4862 in -= hi;
4863 if (in < hi) return in;
4864 } else if (in < lo) {
4865 in += hi;
4866 if (in >= lo) return in;
4867 } else return in;
4868
4869 int32 range = hi - lo;
4870 return lo + range * (in-lo) / range;
4871 }
4872
4873 #if NOTYET
4874
4875 void SimpleLoopBuf_next_kk(SimpleLoopBuf *unit, int inNumSamples)
4876 {
4877 float trig = ZIN0(1);
4878 double loopstart = (double)ZIN0(2);
4879 double loopend = (double)ZIN0(3);
4880 GET_BUF
4881
4882 int numOutputs = unit->mNumOutputs;
4883 if (!checkBuffer(unit, bufData, bufChannels, numOutputs, inNumSamples))
4884 return;
4885
4886
4887 loopend = sc_max(loopend, bufFrames);
4888 int32 phase = unit->m_phase;
4889 if (trig > 0.f && unit->m_prevtrig <= 0.f) {
4890 unit->mDone = false;
4891 phase = (int32)ZIN0(2);
4892 }
4893 unit->m_prevtrig = trig;
4894 for (int i=0; i<inNumSamples; ++i) {
4895 phase = sc_loop1(phase, loopstart, loopend);
4896 int32 iphase = (int32)phase;
4897 float* table1 = bufData + iphase * bufChannels;
4898 int32 index = 0;
4899 for (uint32 channel=0; channel<bufChannels; ++channel) {
4900 OUT(channel[i]) = table1[index++];
4901 }
4902
4903 phase++;
4904 }
4905 unit->m_phase = phase;
4906 }
4907
4908
4909 void SimpleLoopBuf_Ctor(SimpleLoopBuf *unit)
4910 {
4911 SETCALC(SimpleLoopBuf_next_kk);
4912
4913 unit->m_fbufnum = -1e9f;
4914 unit->m_prevtrig = 0.;
4915 unit->m_phase = ZIN0(2);
4916
4917 ClearUnitOutputs(unit, 1);
4918 }
4919 #endif
4920
4921 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4922
4923
4924 ////////////////////////////////////////////////////////////////////////////////////////////////////////
4925
4926 #define GET_SCOPEBUF \
4927 float fbufnum = ZIN0(0); \
4928 if (fbufnum != unit->m_fbufnum) { \
4929 World *world = unit->mWorld; \
4930 if (!world->mNumSndBufs) { \
4931 ClearUnitOutputs(unit, inNumSamples); \
4932 return; \
4933 } \
4934 uint32 bufnum = (int)fbufnum; \
4935 if (bufnum >= world->mNumSndBufs) bufnum = 0; \
4936 unit->m_fbufnum = fbufnum; \
4937 unit->m_buf = world->mSndBufs + bufnum; \
4938 unit->m_bufupdates = world->mSndBufUpdates + bufnum; \
4939 } \
4940 SndBuf *buf = unit->m_buf; \
4941 LOCK_SNDBUF(buf); \
4942 SndBufUpdates *bufupdates = unit->m_bufupdates; \
4943 float *bufData __attribute__((__unused__)) = buf->data; \
4944 uint32 bufChannels __attribute__((__unused__)) = buf->channels; \
4945 uint32 bufFrames __attribute__((__unused__)) = buf->frames; \
4946
4947 void ScopeOut_next(ScopeOut *unit, int inNumSamples)
4948 {
4949 GET_SCOPEBUF
4950
4951 if (!bufData) {
4952 unit->m_framepos = 0;
4953 return;
4954 }
4955
4956 SETUP_IN(1)
4957
4958 uint32 framepos = unit->m_framepos;
4959 if (framepos >= bufFrames) {
4960 unit->m_framepos = 0;
4961 }
4962
4963 if (bufupdates->reads != bufupdates->writes) {
4964 unit->m_framepos += inNumSamples;
4965 return;
4966 }
4967
4968 bufData += framepos * bufChannels;
4969
4970 int remain = (bufFrames - framepos), wrap = 0;
4971
4972 if(inNumSamples <= remain) {
4973 remain = inNumSamples;
4974 wrap = 0;
4975 }
4976 else
4977 wrap = inNumSamples - remain;
4978
4979 if (bufChannels > 2) {
4980 for (int j=0; j<remain; ++j) {
4981 for (uint32 i=0; i<bufChannels; ++i) {
4982 *bufData++ = *++(in[i]);
4983 }
4984 }
4985
4986 bufData = buf->data;
4987
4988 for (int j=0; j<wrap; ++j) {
4989 for (uint32 i=0; i<bufChannels; ++i) {
4990 *bufData++ = *++(in[i]);
4991 }
4992 }
4993 } else if (bufChannels == 2) {
4994 float *in0 = in[0];
4995 float *in1 = in[1];
4996 for (int j=0; j<remain; ++j) {
4997 *bufData++ = *++in0;
4998 *bufData++ = *++in1;
4999 }
5000
5001 bufData = buf->data;
5002
5003 for (int j=0; j<wrap; ++j) {
5004 *bufData++ = *++in0;
5005 *bufData++ = *++in1;
5006 }
5007 } else {
5008 float *in0 = in[0];
5009 for (int j=0; j<remain; ++j) {
5010 *bufData++ = *++in0;
5011 }
5012
5013 bufData = buf->data;
5014
5015 for (int j=0; j<wrap; ++j) {
5016 *bufData++ = *++in0;
5017 }
5018 }
5019
5020 unit->m_framepos += inNumSamples;
5021 unit->m_framecount += inNumSamples;
5022
5023 if (unit->m_framecount >= bufFrames) {
5024 bufupdates->writes++;
5025 unit->m_framecount = 0;
5026 }
5027 }
5028
5029
5030
5031 void ScopeOut_Ctor(ScopeOut *unit)
5032 {
5033
5034 unit->m_fbufnum = -1e9;
5035 unit->m_framepos = 0;
5036 unit->m_framecount = 0;
5037 unit->mIn = 0;
5038 SETCALC(ScopeOut_next);
5039 }
5040
5041 void ScopeOut_Dtor(ScopeOut *unit)
5042 {
5043 TAKEDOWN_IN
5044 }
5045
5046 ////////////////////////////////////////////////////////////////////////////////////////////////////////
5047
5048 struct ScopeOut2 : public Unit
5049 {
5050 ScopeBufferHnd m_buffer;
5051 float **m_inBuffers;
5052 int m_maxPeriod;
5053 uint32 m_phase;
5054 };
5055
5056
5057 void ScopeOut2_next(ScopeOut2 *unit, int inNumSamples)
5058 {
5059 if( !unit->m_buffer ) return;
5060
5061 const int inputOffset = 3;
5062 int numChannels = unit->mNumInputs - inputOffset;
5063
5064 uint32 period = (uint32)ZIN0(2);
5065 uint32 framepos = unit->m_phase;
5066
5067 period = std::max((uint32)inNumSamples, std::min(unit->m_buffer.maxFrames, period));
5068
5069 if( framepos >= period ) framepos = 0;
5070
5071 int remain = period - framepos, wrap = 0;
5072
5073 if(inNumSamples <= remain)
5074 remain = inNumSamples;
5075 else
5076 wrap = inNumSamples - remain;
5077
5078 for (int i = 0; i != numChannels; ++i) {
5079 float * inBuf = unit->m_buffer.channel_data(i);
5080 const float * in = IN(inputOffset + i);
5081
5082 memcpy(inBuf + framepos, in, remain * sizeof(float));
5083 }
5084
5085 if(framepos + inNumSamples >= period)
5086 (*ft->fPushScopeBuffer)(unit->mWorld, unit->m_buffer, period);
5087
5088 if (wrap) {
5089 for (int i = 0; i != numChannels; ++i) {
5090 float * inBuf = unit->m_buffer.channel_data(i);
5091 const float * in = IN(inputOffset + i);
5092 memcpy(inBuf, in + remain, wrap * sizeof(float));
5093 }
5094 }
5095
5096 framepos += inNumSamples;
5097 if (framepos >= period)
5098 framepos = wrap;
5099
5100 unit->m_phase = framepos;
5101 }
5102
5103 void ScopeOut2_Ctor(ScopeOut2 *unit)
5104 {
5105 uint32 numChannels = unit->mNumInputs - 3;
5106 uint32 scopeNum = (uint32)ZIN0(0);
5107 uint32 maxFrames = (uint32)ZIN0(1);
5108
5109 bool ok = (*ft->fGetScopeBuffer)(unit->mWorld, scopeNum, numChannels, maxFrames, unit->m_buffer);
5110
5111 if( !ok ) {
5112 if( unit->mWorld->mVerbosity > -1 && !unit->mDone)
5113 Print("ScopeOut2: Requested scope buffer unavailable! (index: %d, channels: %d, size: %d)\n",
5114 scopeNum, numChannels, maxFrames);
5115 }
5116 else {
5117 unit->m_phase = 0;
5118 }
5119
5120 SETCALC(ScopeOut2_next);
5121 }
5122
5123 void ScopeOut2_Dtor(ScopeOut2 *unit)
5124 {
5125 if( unit->m_buffer )
5126 (*ft->fReleaseScopeBuffer)(unit->mWorld, unit->m_buffer);
5127 }
5128
5129
5130 ////////////////////////////////////////////////////////////////////////////////////////////////////////
5131
5132 struct PitchShift : public Unit
5133 {
5134 float *dlybuf;
5135 float dsamp1, dsamp1_slope, ramp1, ramp1_slope;
5136 float dsamp2, dsamp2_slope, ramp2, ramp2_slope;
5137 float dsamp3, dsamp3_slope, ramp3, ramp3_slope;
5138 float dsamp4, dsamp4_slope, ramp4, ramp4_slope;
5139 float fdelaylen, slope;
5140 long iwrphase, idelaylen, mask;
5141 long counter, stage, numoutput, framesize;
5142 };
5143
5144 void PitchShift_next(PitchShift *unit, int inNumSamples);
5145 void PitchShift_next(PitchShift *unit, int inNumSamples)
5146 {
5147 float *out, *in, *dlybuf;
5148 float disppchratio, pchratio, pchratio1, value;
5149 float dsamp1, dsamp1_slope, ramp1, ramp1_slope;
5150 float dsamp2, dsamp2_slope, ramp2, ramp2_slope;
5151 float dsamp3, dsamp3_slope, ramp3, ramp3_slope;
5152 float dsamp4, dsamp4_slope, ramp4, ramp4_slope;
5153 float fdelaylen, d1, d2, frac, slope, samp_slope, startpos, winsize, pchdisp, timedisp;
5154 long remain, nsmps, idelaylen, irdphase, irdphaseb, iwrphase, mask, idsamp;
5155 long counter, stage, framesize;
5156
5157 RGET
5158
5159 out = ZOUT(0);
5160 in = ZIN(0);
5161
5162 pchratio = ZIN0(2);
5163 winsize = ZIN0(1);
5164 pchdisp = ZIN0(3);
5165 timedisp = ZIN0(4);
5166 timedisp = sc_clip(timedisp, 0.f, winsize) * SAMPLERATE;
5167
5168 dlybuf = unit->dlybuf;
5169 fdelaylen = unit->fdelaylen;
5170 idelaylen = unit->idelaylen;
5171 iwrphase = unit->iwrphase;
5172
5173 counter = unit->counter;
5174 stage = unit->stage;
5175 mask = unit->mask;
5176 framesize = unit->framesize;
5177
5178 dsamp1 = unit->dsamp1;
5179 dsamp2 = unit->dsamp2;
5180 dsamp3 = unit->dsamp3;
5181 dsamp4 = unit->dsamp4;
5182
5183 dsamp1_slope = unit->dsamp1_slope;
5184 dsamp2_slope = unit->dsamp2_slope;
5185 dsamp3_slope = unit->dsamp3_slope;
5186 dsamp4_slope = unit->dsamp4_slope;
5187
5188 ramp1 = unit->ramp1;
5189 ramp2 = unit->ramp2;
5190 ramp3 = unit->ramp3;
5191 ramp4 = unit->ramp4;
5192
5193 ramp1_slope = unit->ramp1_slope;
5194 ramp2_slope = unit->ramp2_slope;
5195 ramp3_slope = unit->ramp3_slope;
5196 ramp4_slope = unit->ramp4_slope;
5197
5198 slope = unit->slope;
5199
5200 remain = inNumSamples;
5201 while (remain) {
5202 if (counter <= 0) {
5203 counter = framesize >> 2;
5204 unit->stage = stage = (stage + 1) & 3;
5205 disppchratio = pchratio;
5206 if (pchdisp != 0.f) {
5207 disppchratio += (pchdisp * frand2(s1,s2,s3));
5208 }
5209 disppchratio = sc_clip(disppchratio, 0.f, 4.f);
5210 pchratio1 = disppchratio - 1.f;
5211 samp_slope = -pchratio1;
5212 startpos = pchratio1 < 0.f ? 2.f : framesize * pchratio1 + 2.f;
5213 startpos += (timedisp * frand(s1,s2,s3));
5214 switch(stage) {
5215 case 0 :
5216 unit->dsamp1_slope = dsamp1_slope = samp_slope;
5217 dsamp1 = startpos;
5218 ramp1 = 0.0;
5219 unit->ramp1_slope = ramp1_slope = slope;
5220 unit->ramp3_slope = ramp3_slope = -slope;
5221 break;
5222 case 1 :
5223 unit->dsamp2_slope = dsamp2_slope = samp_slope;
5224 dsamp2 = startpos;
5225 ramp2 = 0.0;
5226 unit->ramp2_slope = ramp2_slope = slope;
5227 unit->ramp4_slope = ramp4_slope = -slope;
5228 break;
5229 case 2 :
5230 unit->dsamp3_slope = dsamp3_slope = samp_slope;
5231 dsamp3 = startpos;
5232 ramp3 = 0.0;
5233 unit->ramp3_slope = ramp3_slope = slope;
5234 unit->ramp1_slope = ramp1_slope = -slope;
5235 break;
5236 case 3 :
5237 unit->dsamp4_slope = dsamp4_slope = samp_slope;
5238 dsamp4 = startpos;
5239 ramp4 = 0.0;
5240 unit->ramp2_slope = ramp2_slope = -slope;
5241 unit->ramp4_slope = ramp4_slope = slope;
5242 break;
5243 }
5244 /*Print("%d %d %g %g %g %g %g %g %g %g %g %g %g %g\n",
5245 counter, stage, dsamp1_slope, dsamp2_slope, dsamp3_slope, dsamp4_slope,
5246 dsamp1, dsamp2, dsamp3, dsamp4,
5247 ramp1, ramp2, ramp3, ramp4);*/
5248
5249 }
5250
5251 nsmps = sc_min(remain, counter);
5252 remain -= nsmps;
5253 counter -= nsmps;
5254
5255 LOOP(nsmps,
5256 iwrphase = (iwrphase + 1) & mask;
5257
5258 dsamp1 += dsamp1_slope;
5259 idsamp = (long)dsamp1;
5260 frac = dsamp1 - idsamp;
5261 irdphase = (iwrphase - idsamp) & mask;
5262 irdphaseb = (irdphase - 1) & mask;
5263 d1 = dlybuf[irdphase];
5264 d2 = dlybuf[irdphaseb];
5265 value = (d1 + frac * (d2 - d1)) * ramp1;
5266 ramp1 += ramp1_slope;
5267
5268 dsamp2 += dsamp2_slope;
5269 idsamp = (long)dsamp2;
5270 frac = dsamp2 - idsamp;
5271 irdphase = (iwrphase - idsamp) & mask;
5272 irdphaseb = (irdphase - 1) & mask;
5273 d1 = dlybuf[irdphase];
5274 d2 = dlybuf[irdphaseb];
5275 value += (d1 + frac * (d2 - d1)) * ramp2;
5276 ramp2 += ramp2_slope;
5277
5278 dsamp3 += dsamp3_slope;
5279 idsamp = (long)dsamp3;
5280 frac = dsamp3 - idsamp;
5281 irdphase = (iwrphase - idsamp) & mask;
5282 irdphaseb = (irdphase - 1) & mask;
5283 d1 = dlybuf[irdphase];
5284 d2 = dlybuf[irdphaseb];
5285 value += (d1 + frac * (d2 - d1)) * ramp3;
5286 ramp3 += ramp3_slope;
5287
5288 dsamp4 += dsamp4_slope;
5289 idsamp = (long)dsamp4;
5290 frac = dsamp4 - idsamp;
5291 irdphase = (iwrphase - idsamp) & mask;
5292 irdphaseb = (irdphase - 1) & mask;
5293 d1 = dlybuf[irdphase];
5294 d2 = dlybuf[irdphaseb];
5295 value += (d1 + frac * (d2 - d1)) * ramp4;
5296 ramp4 += ramp4_slope;
5297
5298 dlybuf[iwrphase] = ZXP(in);
5299 ZXP(out) = value *= 0.5;
5300 );
5301 }
5302
5303 unit->counter = counter;
5304
5305 unit->dsamp1 = dsamp1;
5306 unit->dsamp2 = dsamp2;
5307 unit->dsamp3 = dsamp3;
5308 unit->dsamp4 = dsamp4;
5309
5310 unit->ramp1 = ramp1;
5311 unit->ramp2 = ramp2;
5312 unit->ramp3 = ramp3;
5313 unit->ramp4 = ramp4;
5314
5315 unit->iwrphase = iwrphase;
5316
5317 RPUT
5318 }
5319
5320
5321
5322
5323 void PitchShift_next_z(PitchShift *unit, int inNumSamples);
5324 void PitchShift_next_z(PitchShift *unit, int inNumSamples)
5325 {
5326 float *out, *in, *dlybuf;
5327 float disppchratio, pchratio, pchratio1, value;
5328 float dsamp1, dsamp1_slope, ramp1, ramp1_slope;
5329 float dsamp2, dsamp2_slope, ramp2, ramp2_slope;
5330 float dsamp3, dsamp3_slope, ramp3, ramp3_slope;
5331 float dsamp4, dsamp4_slope, ramp4, ramp4_slope;
5332 float fdelaylen, d1, d2, frac, slope, samp_slope, startpos, winsize, pchdisp, timedisp;
5333 long remain, nsmps, idelaylen, irdphase, irdphaseb, iwrphase;
5334 long mask, idsamp;
5335 long counter, stage, framesize, numoutput;
5336
5337 RGET
5338
5339 out = ZOUT(0);
5340 in = ZIN(0);
5341 pchratio = ZIN0(2);
5342 winsize = ZIN0(1);
5343 pchdisp = ZIN0(3);
5344 timedisp = ZIN0(4);
5345 timedisp = sc_clip(timedisp, 0.f, winsize) * SAMPLERATE;
5346
5347 dlybuf = unit->dlybuf;
5348 fdelaylen = unit->fdelaylen;
5349 idelaylen = unit->idelaylen;
5350 iwrphase = unit->iwrphase;
5351 numoutput = unit->numoutput;
5352
5353 counter = unit->counter;
5354 stage = unit->stage;
5355 mask = unit->mask;
5356 framesize = unit->framesize;
5357
5358 dsamp1 = unit->dsamp1;
5359 dsamp2 = unit->dsamp2;
5360 dsamp3 = unit->dsamp3;
5361 dsamp4 = unit->dsamp4;
5362
5363 dsamp1_slope = unit->dsamp1_slope;
5364 dsamp2_slope = unit->dsamp2_slope;
5365 dsamp3_slope = unit->dsamp3_slope;
5366 dsamp4_slope = unit->dsamp4_slope;
5367
5368 ramp1 = unit->ramp1;
5369 ramp2 = unit->ramp2;
5370 ramp3 = unit->ramp3;
5371 ramp4 = unit->ramp4;
5372
5373 ramp1_slope = unit->ramp1_slope;
5374 ramp2_slope = unit->ramp2_slope;
5375 ramp3_slope = unit->ramp3_slope;
5376 ramp4_slope = unit->ramp4_slope;
5377
5378 slope = unit->slope;
5379
5380 remain = inNumSamples;
5381 while (remain) {
5382 if (counter <= 0) {
5383 counter = framesize >> 2;
5384 unit->stage = stage = (stage + 1) & 3;
5385 disppchratio = pchratio;
5386 if (pchdisp != 0.f) {
5387 disppchratio += (pchdisp * frand2(s1,s2,s3));
5388 }
5389 disppchratio = sc_clip(disppchratio, 0.f, 4.f);
5390 pchratio1 = disppchratio - 1.f;
5391 samp_slope = -pchratio1;
5392 startpos = pchratio1 < 0.f ? 2.f : framesize * pchratio1 + 2.f;
5393 startpos += (timedisp * frand(s1,s2,s3));
5394 switch(stage) {
5395 case 0 :
5396 unit->dsamp1_slope = dsamp1_slope = samp_slope;
5397 dsamp1 = startpos;
5398 ramp1 = 0.0;
5399 unit->ramp1_slope = ramp1_slope = slope;
5400 unit->ramp3_slope = ramp3_slope = -slope;
5401 break;
5402 case 1 :
5403 unit->dsamp2_slope = dsamp2_slope = samp_slope;
5404 dsamp2 = startpos;
5405 ramp2 = 0.0;
5406 unit->ramp2_slope = ramp2_slope = slope;
5407 unit->ramp4_slope = ramp4_slope = -slope;
5408 break;
5409 case 2 :
5410 unit->dsamp3_slope = dsamp3_slope = samp_slope;
5411 dsamp3 = startpos;
5412 ramp3 = 0.0;
5413 unit->ramp3_slope = ramp3_slope = slope;
5414 unit->ramp1_slope = ramp1_slope = -slope;
5415 break;
5416 case 3 :
5417 unit->dsamp4_slope = dsamp4_slope = samp_slope;
5418 dsamp4 = startpos;
5419 ramp4 = 0.0;
5420 unit->ramp2_slope = ramp2_slope = -slope;
5421 unit->ramp4_slope = ramp4_slope = slope;
5422 break;
5423 }
5424 /*Print("z %d %d %g %g %g %g %g %g %g %g %g %g %g %g\n",
5425 counter, stage, dsamp1_slope, dsamp2_slope, dsamp3_slope, dsamp4_slope,
5426 dsamp1, dsamp2, dsamp3, dsamp4,
5427 ramp1, ramp2, ramp3, ramp4);*/
5428 }
5429 nsmps = sc_min(remain, counter);
5430 remain -= nsmps;
5431 counter -= nsmps;
5432
5433 while (nsmps--) {
5434 numoutput++;
5435 iwrphase = (iwrphase + 1) & mask;
5436
5437 dsamp1 += dsamp1_slope;
5438 idsamp = (long)dsamp1;
5439 frac = dsamp1 - idsamp;
5440 irdphase = (iwrphase - idsamp) & mask;
5441 irdphaseb = (irdphase - 1) & mask;
5442 if (numoutput < idelaylen) {
5443 if (irdphase > iwrphase) {
5444 value = 0.f;
5445 } else if (irdphaseb > iwrphase) {
5446 d1 = dlybuf[irdphase];
5447 value = (d1 - frac * d1) * ramp1;
5448 } else {
5449 d1 = dlybuf[irdphase];
5450 d2 = dlybuf[irdphaseb];
5451 value = (d1 + frac * (d2 - d1)) * ramp1;
5452 }
5453 } else {
5454 d1 = dlybuf[irdphase];
5455 d2 = dlybuf[irdphaseb];
5456 value = (d1 + frac * (d2 - d1)) * ramp1;
5457 }
5458 ramp1 += ramp1_slope;
5459
5460 dsamp2 += dsamp2_slope;
5461 idsamp = (long)dsamp2;
5462 frac = dsamp2 - idsamp;
5463 irdphase = (iwrphase - idsamp) & mask;
5464 irdphaseb = (irdphase - 1) & mask;
5465 if (numoutput < idelaylen) {
5466 if (irdphase > iwrphase) {
5467 //value += 0.f;
5468 } else if (irdphaseb > iwrphase) {
5469 d1 = dlybuf[irdphase];
5470 value += (d1 - frac * d1) * ramp2;
5471 } else {
5472 d1 = dlybuf[irdphase];
5473 d2 = dlybuf[irdphaseb];
5474 value += (d1 + frac * (d2 - d1)) * ramp2;
5475 }
5476 } else {
5477 d1 = dlybuf[irdphase];
5478 d2 = dlybuf[irdphaseb];
5479 value += (d1 + frac * (d2 - d1)) * ramp2;
5480 }
5481 ramp2 += ramp2_slope;
5482
5483 dsamp3 += dsamp3_slope;
5484 idsamp = (long)dsamp3;
5485 frac = dsamp3 - idsamp;
5486 irdphase = (iwrphase - idsamp) & mask;
5487 irdphaseb = (irdphase - 1) & mask;
5488 if (numoutput < idelaylen) {
5489 if (irdphase > iwrphase) {
5490 //value += 0.f;
5491 } else if (irdphaseb > iwrphase) {
5492 d1 = dlybuf[irdphase];
5493 value += (d1 - frac * d1) * ramp3;
5494 } else {
5495 d1 = dlybuf[irdphase];
5496 d2 = dlybuf[irdphaseb];
5497 value += (d1 + frac * (d2 - d1)) * ramp3;
5498 }
5499 } else {
5500 d1 = dlybuf[irdphase];
5501 d2 = dlybuf[irdphaseb];
5502 value += (d1 + frac * (d2 - d1)) * ramp3;
5503 }
5504 ramp3 += ramp3_slope;
5505
5506 dsamp4 += dsamp4_slope;
5507 idsamp = (long)dsamp4;
5508 frac = dsamp4 - idsamp;
5509 irdphase = (iwrphase - idsamp) & mask;
5510 irdphaseb = (irdphase - 1) & mask;
5511
5512 if (numoutput < idelaylen) {
5513 if (irdphase > iwrphase) {
5514 //value += 0.f;
5515 } else if (irdphaseb > iwrphase) {
5516 d1 = dlybuf[irdphase];
5517 value += (d1 - frac * d1) * ramp4;
5518 } else {
5519 d1 = dlybuf[irdphase];
5520 d2 = dlybuf[irdphaseb];
5521 value += (d1 + frac * (d2 - d1)) * ramp4;
5522 }
5523 } else {
5524 d1 = dlybuf[irdphase];
5525 d2 = dlybuf[irdphaseb];
5526 value += (d1 + frac * (d2 - d1)) * ramp4;
5527 }
5528 ramp4 += ramp4_slope;
5529
5530 dlybuf[iwrphase] = ZXP(in);
5531 ZXP(out) = value *= 0.5;
5532 }
5533 }
5534
5535 unit->counter = counter;
5536 unit->stage = stage;
5537 unit->mask = mask;
5538
5539 unit->dsamp1 = dsamp1;
5540 unit->dsamp2 = dsamp2;
5541 unit->dsamp3 = dsamp3;
5542 unit->dsamp4 = dsamp4;
5543
5544 unit->ramp1 = ramp1;
5545 unit->ramp2 = ramp2;
5546 unit->ramp3 = ramp3;
5547 unit->ramp4 = ramp4;
5548
5549 unit->numoutput = numoutput;
5550 unit->iwrphase = iwrphase;
5551
5552 if (numoutput >= idelaylen) {
5553 SETCALC(PitchShift_next);
5554 }
5555
5556 RPUT
5557 }
5558
5559
5560 void PitchShift_Ctor(PitchShift *unit);
5561 void PitchShift_Ctor(PitchShift *unit)
5562 {
5563 long delaybufsize;
5564 float *out, *in, *dlybuf;
5565 float winsize, pchratio;
5566 float fdelaylen, slope;
5567 long framesize, last;
5568
5569 out = ZOUT(0);
5570 in = ZIN(0);
5571 pchratio = ZIN0(2);
5572 winsize = ZIN0(1);
5573
5574 delaybufsize = (long)ceil(winsize * SAMPLERATE * 3.f + 3.f);
5575 fdelaylen = delaybufsize - 3;
5576
5577 delaybufsize = delaybufsize + BUFLENGTH;
5578 delaybufsize = NEXTPOWEROFTWO(delaybufsize); // round up to next power of two
5579 dlybuf = (float*)RTAlloc(unit->mWorld, delaybufsize * sizeof(float));
5580
5581 SETCALC(PitchShift_next_z);
5582
5583 *dlybuf = ZIN0(0);
5584 ZOUT0(0) = 0.f;
5585
5586 unit->dlybuf = dlybuf;
5587 unit->idelaylen = delaybufsize;
5588 unit->fdelaylen = fdelaylen;
5589 unit->iwrphase = 0;
5590 unit->numoutput = 0;
5591 unit->mask = last = (delaybufsize - 1);
5592
5593 unit->framesize = framesize = ((long)(winsize * SAMPLERATE) + 2) & ~3;
5594 unit->slope = slope = 2.f / framesize;
5595 unit->stage = 3;
5596 unit->counter = framesize >> 2;
5597 unit->ramp1 = 0.5;
5598 unit->ramp2 = 1.0;
5599 unit->ramp3 = 0.5;
5600 unit->ramp4 = 0.0;
5601
5602 unit->ramp1_slope = -slope;
5603 unit->ramp2_slope = -slope;
5604 unit->ramp3_slope = slope;
5605 unit->ramp4_slope = slope;
5606
5607 dlybuf[last ] = 0.f; // put a few zeroes where we start the read heads
5608 dlybuf[last-1] = 0.f;
5609 dlybuf[last-2] = 0.f;
5610
5611 unit->numoutput = 0;
5612
5613 // start all read heads 2 samples behind the write head
5614 unit->dsamp1 = unit->dsamp2 = unit->dsamp3 = unit->dsamp4 = 2.f;
5615 // pch ratio is initially zero for the read heads
5616 unit->dsamp1_slope = unit->dsamp2_slope = unit->dsamp3_slope = unit->dsamp4_slope = 1.f;
5617 }
5618
5619
5620
5621 void PitchShift_Dtor(PitchShift *unit)
5622 {
5623 RTFree(unit->mWorld, unit->dlybuf);
5624 }
5625
5626
5627
5628
5629 typedef struct graintap1 {
5630 float pos, rate, level, slope, curve;
5631 long counter;
5632 struct graintap1 *next;
5633 } GrainTap1;
5634
5635 #define MAXDGRAINS 32
5636
5637 struct GrainTap : public Unit
5638 {
5639 float m_fbufnum;
5640 SndBuf *m_buf;
5641
5642 float fdelaylen;
5643 long bufsize, iwrphase;
5644 long nextTime;
5645 GrainTap1 grains[MAXDGRAINS];
5646 GrainTap1 *firstActive, *firstFree;
5647 };
5648
5649
5650 // coefs: pos, rate, level, slope, curve, counter
5651
5652 void GrainTap_next(GrainTap *unit, int inNumSamples);
5653 void GrainTap_next(GrainTap *unit, int inNumSamples)
5654 {
5655 float *out, *out0;
5656 const float * dlybuf;
5657 float sdur, rdur, rdur2;
5658 float dsamp, dsamp_slope, fdelaylen, d1, d2, frac;
5659 float level, slope, curve;
5660 float maxpitch, pitch, maxtimedisp, timedisp, density;
5661 long remain, nsmps, irdphase, irdphaseb, iwrphase, iwrphase0;
5662 long idsamp, koffset;
5663 long counter;
5664 uint32 bufsize;
5665 GrainTap1 *grain, *prevGrain, *nextGrain;
5666
5667 GET_BUF_SHARED
5668
5669 RGET
5670
5671 out0 = ZOUT(0);
5672
5673 // bufnum, grainDur, pchRatio, pchDisp, timeDisp, overlap
5674 // 0 1 2 3 4 5
5675
5676 density = ZIN0(5);
5677 density = sc_max(0.0001, density);
5678
5679 bufsize = unit->bufsize;
5680 if (bufsize != bufSamples) {
5681 ClearUnitOutputs(unit, inNumSamples);
5682 return;
5683 }
5684
5685 dlybuf = bufData;
5686 fdelaylen = unit->fdelaylen;
5687 iwrphase0 = unit->iwrphase;
5688
5689 // initialize buffer to zero
5690 out = out0;
5691 LOOP1(inNumSamples, ZXP(out) = 0.f;);
5692
5693 // do all current grains
5694 prevGrain = NULL;
5695 grain = unit->firstActive;
5696 while (grain) {
5697
5698 dsamp = grain->pos;
5699 dsamp_slope = grain->rate;
5700 level = grain->level;
5701 slope = grain->slope;
5702 curve = grain->curve;
5703 counter = grain->counter;
5704
5705 nsmps = sc_min(counter, inNumSamples);
5706 iwrphase = iwrphase0;
5707 out = out0;
5708 LOOP(nsmps,
5709 dsamp += dsamp_slope;
5710 idsamp = (long)dsamp;
5711 frac = dsamp - idsamp;
5712 iwrphase = (iwrphase + 1) & mask;
5713 irdphase = (iwrphase - idsamp) & mask;
5714 irdphaseb = (irdphase - 1) & mask;
5715 d1 = dlybuf[irdphase];
5716 d2 = dlybuf[irdphaseb];
5717 ZXP(out) += (d1 + frac * (d2 - d1)) * level;
5718 level += slope;
5719 slope += curve;
5720 );
5721 grain->pos = dsamp;
5722 grain->level = level;
5723 grain->slope = slope;
5724 grain->counter -= nsmps;
5725
5726 nextGrain = grain->next;
5727 if (grain->counter <= 0) {
5728 // unlink from active list
5729 if (prevGrain) prevGrain->next = nextGrain;
5730 else unit->firstActive = nextGrain;
5731
5732 // link onto free list
5733 grain->next = unit->firstFree;
5734 unit->firstFree = grain;
5735 } else {
5736 prevGrain = grain;
5737 }
5738 grain = nextGrain;
5739 }
5740 // start new grains
5741 remain = inNumSamples;
5742 while (unit->nextTime <= remain) {
5743 remain -= unit->nextTime;
5744 sdur = ZIN0(1) * SAMPLERATE;
5745 sdur = sc_max(sdur, 4.f);
5746
5747 grain = unit->firstFree;
5748 if (grain) {
5749 unit->firstFree = grain->next;
5750 grain->next = unit->firstActive;
5751 unit->firstActive = grain;
5752
5753 koffset = inNumSamples - remain;
5754 iwrphase = (iwrphase0 + koffset) & mask;
5755
5756 grain->counter = (long)sdur;
5757
5758 timedisp = ZIN0(4);
5759 timedisp = sc_max(timedisp, 0.f);
5760 timedisp = frand(s1,s2,s3) * timedisp * SAMPLERATE;
5761
5762 pitch = ZIN0(2) + frand2(s1,s2,s3) * ZIN0(3);
5763 if (pitch >= 1.f) {
5764 maxpitch = 1.f + (fdelaylen/sdur);
5765 pitch = sc_min(pitch, maxpitch);
5766
5767 dsamp_slope = 1.f - pitch;
5768 grain->rate = dsamp_slope;
5769
5770 maxtimedisp = fdelaylen + sdur * dsamp_slope;
5771 timedisp = sc_min(timedisp, maxtimedisp);
5772
5773 dsamp = BUFLENGTH + koffset + 2.f + timedisp - sdur * dsamp_slope;
5774 dsamp = sc_min(dsamp, fdelaylen);
5775 } else {
5776 maxpitch = -(1.f + (fdelaylen/sdur));
5777 pitch = sc_max(pitch, maxpitch);
5778
5779 dsamp_slope = 1.f - pitch;
5780 grain->rate = dsamp_slope;
5781
5782 maxtimedisp = fdelaylen - sdur * dsamp_slope;
5783 timedisp = sc_min(timedisp, maxtimedisp);
5784
5785 dsamp = BUFLENGTH + koffset + 2.f + timedisp;
5786 dsamp = sc_min(dsamp, fdelaylen);
5787 }
5788
5789 grain->pos = dsamp;
5790 //postbuf("ds %g %g %g\n", dsamp_slope, dsamp, fdelaylen);
5791
5792 rdur = 1.f / sdur;
5793 rdur2 = rdur * rdur;
5794 grain->level = level = 0.f;
5795 grain->slope = slope = 4.0 * (rdur - rdur2); // ampslope
5796 grain->curve = curve = -8.0 * rdur2; // ampcurve
5797
5798 nsmps = remain;
5799 out = out0 + koffset;
5800 LOOP(nsmps,
5801 dsamp += dsamp_slope;
5802 idsamp = (long)dsamp;
5803 frac = dsamp - idsamp;
5804 iwrphase = (iwrphase + 1) & mask;
5805 irdphase = (iwrphase - idsamp) & mask;
5806 irdphaseb = (irdphase - 1) & mask;
5807 d1 = dlybuf[irdphase];
5808 d2 = dlybuf[irdphaseb];
5809 ZXP(out) += (d1 + frac * (d2 - d1)) * level;
5810 level += slope;
5811 slope += curve;
5812 );
5813 grain->pos = dsamp;
5814 grain->level = level;
5815 grain->slope = slope;
5816 grain->counter -= nsmps;
5817
5818 if (grain->counter <= 0) {
5819 // unlink from active list
5820 unit->firstActive = grain->next;
5821
5822 // link onto free list
5823 grain->next = unit->firstFree;
5824 unit->firstFree = grain;
5825 }
5826 }
5827 unit->nextTime = (long)(sdur / density);
5828 if (unit->nextTime < 1) unit->nextTime = 1;
5829
5830 /*if (grain == NULL) {
5831 postbuf("nextTime %d %g %g %p %p %p\n", unit->nextTime, sdur, density,
5832 grain, unit->firstActive, unit->firstFree);
5833 }*/
5834 }
5835 iwrphase = (iwrphase0 + BUFLENGTH) & mask;
5836 unit->nextTime -= remain;
5837 if (unit->nextTime < 0) unit->nextTime = 0;
5838
5839 unit->iwrphase = iwrphase;
5840
5841 RPUT
5842 }
5843
5844
5845 void GrainTap_Ctor(GrainTap *unit);
5846 void GrainTap_Ctor(GrainTap *unit)
5847 {
5848 float fdelaylen;
5849 float maxdelaytime;
5850
5851 GET_BUF
5852
5853 if (!ISPOWEROFTWO(bufSamples)) {
5854 Print("GrainTap buffer size not a power of two.\n");
5855 SETCALC(*ClearUnitOutputs);
5856 return;
5857 }
5858
5859 fdelaylen = bufSamples - 2 * BUFLENGTH - 3;
5860 maxdelaytime = fdelaylen * SAMPLEDUR;
5861
5862 SETCALC(GrainTap_next);
5863
5864 ZOUT0(0) = 0.f;
5865
5866 unit->bufsize = bufSamples;
5867 unit->fdelaylen = fdelaylen;
5868 unit->iwrphase = 0;
5869 unit->nextTime = 0;
5870 for (int i=0; i<MAXDGRAINS-1; ++i) {
5871 unit->grains[i].next = unit->grains + (i + 1);
5872 }
5873 unit->grains[MAXDGRAINS-1].next = NULL;
5874 unit->firstFree = unit->grains;
5875 unit->firstActive = NULL;
5876 }
5877
5878
5879
5880
5881 ////////////////////////////////////////////////////////////////////////////////////////////////////////
5882
5883
5884 #define GRAIN_BUF \
5885 const SndBuf *buf = bufs + bufnum; \
5886 LOCK_SNDBUF_SHARED(buf); \
5887 const float *bufData __attribute__((__unused__)) = buf->data; \
5888 uint32 bufChannels __attribute__((__unused__)) = buf->channels; \
5889 uint32 bufSamples __attribute__((__unused__)) = buf->samples; \
5890 uint32 bufFrames = buf->frames; \
5891 int guardFrame __attribute__((__unused__)) = bufFrames - 2; \
5892
5893
5894 inline float IN_AT(Unit* unit, int index, int offset)
5895 {
5896 if (INRATE(index) == calc_FullRate) return IN(index)[offset];
5897 if (INRATE(index) == calc_DemandRate) return DEMANDINPUT_A(index, offset + 1);
5898 return ZIN0(index);
5899 }
5900
5901 inline double sc_gloop(double in, double hi)
5902 {
5903 // avoid the divide if possible
5904 if (in >= hi) {
5905 in -= hi;
5906 if (in < hi) return in;
5907 } else if (in < 0.) {
5908 in += hi;
5909 if (in >= 0.) return in;
5910 } else return in;
5911
5912 return in - hi * floor(in/hi);
5913 }
5914
5915 #define GRAIN_LOOP_BODY_4 \
5916 float amp = y1 * y1; \
5917 phase = sc_gloop(phase, loopMax); \
5918 int32 iphase = (int32)phase; \
5919 const float* table1 = bufData + iphase; \
5920 const float* table0 = table1 - 1; \
5921 const float* table2 = table1 + 1; \
5922 const float* table3 = table1 + 2; \
5923 if (iphase == 0) { \
5924 table0 += bufSamples; \
5925 } else if (iphase >= guardFrame) { \
5926 if (iphase == guardFrame) { \
5927 table3 -= bufSamples; \
5928 } else { \
5929 table2 -= bufSamples; \
5930 table3 -= bufSamples; \
5931 } \
5932 } \
5933 float fracphase = phase - (double)iphase; \
5934 float a = table0[0]; \
5935 float b = table1[0]; \
5936 float c = table2[0]; \
5937 float d = table3[0]; \
5938 float outval = amp * cubicinterp(fracphase, a, b, c, d); \
5939 ZXP(out1) += outval * pan1; \
5940 ZXP(out2) += outval * pan2; \
5941 double y0 = b1 * y1 - y2; \
5942 y2 = y1; \
5943 y1 = y0; \
5944
5945
5946 #define GRAIN_LOOP_BODY_2 \
5947 float amp = y1 * y1; \
5948 phase = sc_gloop(phase, loopMax); \
5949 int32 iphase = (int32)phase; \
5950 const float* table1 = bufData + iphase; \
5951 const float* table2 = table1 + 1; \
5952 if (iphase > guardFrame) { \
5953 table2 -= bufSamples; \
5954 } \
5955 float fracphase = phase - (double)iphase; \
5956 float b = table1[0]; \
5957 float c = table2[0]; \
5958 float outval = amp * (b + fracphase * (c - b)); \
5959 ZXP(out1) += outval * pan1; \
5960 ZXP(out2) += outval * pan2; \
5961 double y0 = b1 * y1 - y2; \
5962 y2 = y1; \
5963 y1 = y0; \
5964
5965
5966 #define GRAIN_LOOP_BODY_1 \
5967 float amp = y1 * y1; \
5968 phase = sc_gloop(phase, loopMax); \
5969 int32 iphase = (int32)phase; \
5970 float outval = amp * bufData[iphase]; \
5971 ZXP(out1) += outval * pan1; \
5972 ZXP(out2) += outval * pan2; \
5973 double y0 = b1 * y1 - y2; \
5974 y2 = y1; \
5975 y1 = y0; \
5976
5977
5978 void TGrains_next(TGrains *unit, int inNumSamples)
5979 {
5980 float *trigin = IN(0);
5981 float prevtrig = unit->mPrevTrig;
5982
5983 uint32 numOutputs = unit->mNumOutputs;
5984 ClearUnitOutputs(unit, inNumSamples);
5985 float *out[16];
5986 for (uint32 i=0; i<numOutputs; ++i) out[i] = ZOUT(i);
5987
5988 World *world = unit->mWorld;
5989 SndBuf *bufs = world->mSndBufs;
5990 uint32 numBufs = world->mNumSndBufs;
5991
5992 for (int i=0; i < unit->mNumActive; ) {
5993 Grain *grain = unit->mGrains + i;
5994 uint32 bufnum = grain->bufnum;
5995
5996 GRAIN_BUF
5997
5998 if (bufChannels != 1) {
5999 ++i;
6000 continue;
6001 }
6002
6003 double loopMax = (double)bufFrames;
6004
6005 float pan1 = grain->pan1;
6006 float pan2 = grain->pan2;
6007 double rate = grain->rate;
6008 double phase = grain->phase;
6009 double b1 = grain->b1;
6010 double y1 = grain->y1;
6011 double y2 = grain->y2;
6012
6013 uint32 chan1 = grain->chan;
6014 uint32 chan2 = chan1 + 1;
6015 if (chan2 >= numOutputs) chan2 = 0;
6016
6017 float *out1 = out[chan1];
6018 float *out2 = out[chan2];
6019 //printf("B chan %d %d %p %p", chan1, chan2, out1, out2);
6020
6021 int nsmps = sc_min(grain->counter, inNumSamples);
6022 if (grain->interp >= 4) {
6023 for (int j=0; j<nsmps; ++j) {
6024 GRAIN_LOOP_BODY_4;
6025 phase += rate;
6026 }
6027 } else if (grain->interp >= 2) {
6028 for (int j=0; j<nsmps; ++j) {
6029 GRAIN_LOOP_BODY_2;
6030 phase += rate;
6031 }
6032 } else {
6033 for (int j=0; j<nsmps; ++j) {
6034 GRAIN_LOOP_BODY_1;
6035 phase += rate;
6036 }
6037 }
6038
6039 grain->phase = phase;
6040 grain->y1 = y1;
6041 grain->y2 = y2;
6042
6043 grain->counter -= nsmps;
6044 if (grain->counter <= 0) {
6045 // remove grain
6046 *grain = unit->mGrains[--unit->mNumActive];
6047 } else ++i;
6048 }
6049
6050 int trigSamples = INRATE(0) == calc_FullRate ? inNumSamples : 1;
6051
6052 for (int i=0; i<trigSamples; ++i) {
6053 float trig = trigin[i];
6054
6055 if (trig > 0.f && prevtrig <= 0.f) {
6056 // start a grain
6057 if (unit->mNumActive+1 >= kMaxGrains) break;
6058 uint32 bufnum = (uint32)IN_AT(unit, 1, i);
6059 if (bufnum >= numBufs) continue;
6060 GRAIN_BUF
6061
6062 if (bufChannels != 1) continue;
6063
6064 float bufSampleRate = buf->samplerate;
6065 float bufRateScale = bufSampleRate * SAMPLEDUR;
6066 double loopMax = (double)bufFrames;
6067
6068 Grain *grain = unit->mGrains + unit->mNumActive++;
6069 grain->bufnum = bufnum;
6070
6071 double counter = floor(IN_AT(unit, 4, i) * SAMPLERATE);
6072 counter = sc_max(4., counter);
6073 grain->counter = (int)counter;
6074
6075 double rate = grain->rate = IN_AT(unit, 2, i) * bufRateScale;
6076 double centerPhase = IN_AT(unit, 3, i) * bufSampleRate;
6077 double phase = centerPhase - 0.5 * counter * rate;
6078
6079 float pan = IN_AT(unit, 5, i);
6080 float amp = IN_AT(unit, 6, i);
6081 grain->interp = (int)IN_AT(unit, 7, i);
6082
6083 float panangle;
6084 if (numOutputs > 2) {
6085 pan = sc_wrap(pan * 0.5f, 0.f, 1.f);
6086 float cpan = numOutputs * pan + 0.5;
6087 float ipan = floor(cpan);
6088 float panfrac = cpan - ipan;
6089 panangle = panfrac * pi2_f;
6090 grain->chan = (int)ipan;
6091 if (grain->chan >= (int)numOutputs) grain->chan -= numOutputs;
6092 } else {
6093 grain->chan = 0;
6094 pan = sc_wrap(pan * 0.5f + 0.5f, 0.f, 1.f);
6095 panangle = pan * pi2_f;
6096 }
6097 float pan1 = grain->pan1 = amp * cos(panangle);
6098 float pan2 = grain->pan2 = amp * sin(panangle);
6099 double w = pi / counter;
6100 double b1 = grain->b1 = 2. * cos(w);
6101 double y1 = sin(w);
6102 double y2 = 0.;
6103
6104 uint32 chan1 = grain->chan;
6105 uint32 chan2 = chan1 + 1;
6106 if (chan2 >= numOutputs) chan2 = 0;
6107
6108 float *out1 = out[chan1] + i;
6109 float *out2 = out[chan2] + i;
6110
6111 int nsmps = sc_min(grain->counter, inNumSamples - i);
6112 if (grain->interp >= 4) {
6113 for (int j=0; j<nsmps; ++j) {
6114 GRAIN_LOOP_BODY_4;
6115 phase += rate;
6116 }
6117 } else if (grain->interp >= 2) {
6118 for (int j=0; j<nsmps; ++j) {
6119 GRAIN_LOOP_BODY_2;
6120 phase += rate;
6121 }
6122 } else {
6123 for (int j=0; j<nsmps; ++j) {
6124 GRAIN_LOOP_BODY_1;
6125 phase += rate;
6126 }
6127 }
6128
6129 grain->phase = phase;
6130 grain->y1 = y1;
6131 grain->y2 = y2;
6132
6133 grain->counter -= nsmps;
6134 if (grain->counter <= 0) {
6135 // remove grain
6136 *grain = unit->mGrains[--unit->mNumActive];
6137 }
6138 }
6139 prevtrig = trig;
6140 }
6141
6142 unit->mPrevTrig = prevtrig;
6143 }
6144
6145 void TGrains_Ctor(TGrains *unit)
6146 {
6147 SETCALC(TGrains_next);
6148
6149 unit->mNumActive = 0;
6150 unit->mPrevTrig = 0.;
6151
6152 ClearUnitOutputs(unit, 1);
6153 }
6154
6155
6156 ////////////////////////////////////////////////////////////////////////////////////////////////////////
6157 /*
6158 Pluck - Karplus-Strong
6159 */
6160 void Pluck_Ctor(Pluck *unit)
6161 {
6162 // FeedbackDelay_Reset(unit);
6163 float maxdelaytime = unit->m_maxdelaytime = IN0(2);
6164 float delaytime = unit->m_delaytime = IN0(3);
6165 unit->m_dlybuf = 0;
6166 bool allocationSucessful = DelayUnit_AllocDelayLine(unit, "Pluck");
6167 if (!allocationSucessful)
6168 return;
6169
6170 unit->m_dsamp = CalcDelay(unit, unit->m_delaytime);
6171
6172 unit->m_numoutput = 0;
6173 unit->m_iwrphase = 0;
6174 unit->m_feedbk = sc_CalcFeedback(unit->m_delaytime, unit->m_decaytime);
6175
6176 if (INRATE(1) == calc_FullRate) {
6177 if(INRATE(5) == calc_FullRate){
6178 SETCALC(Pluck_next_aa_z);
6179 } else {
6180 SETCALC(Pluck_next_ak_z); //ak
6181 }
6182 } else {
6183 if(INRATE(5) == calc_FullRate){
6184 SETCALC(Pluck_next_ka_z); //ka
6185 } else {
6186 SETCALC(Pluck_next_kk_z); //kk
6187 }
6188 }
6189 OUT0(0) = unit->m_lastsamp = 0.f;
6190 unit->m_prevtrig = 0.f;
6191 unit->m_inputsamps = 0;
6192 unit->m_coef = IN0(5);
6193 }
6194
6195 void Pluck_next_aa(Pluck *unit, int inNumSamples)
6196 {
6197 float *out = OUT(0);
6198 float *in = IN(0);
6199 float *trig = IN(1);
6200 float delaytime = IN0(3);
6201 float decaytime = IN0(4);
6202 float *coef = IN(5);
6203 float lastsamp = unit->m_lastsamp;
6204 unsigned long inputsamps = unit->m_inputsamps;
6205
6206 float *dlybuf = unit->m_dlybuf;
6207 long iwrphase = unit->m_iwrphase;
6208 float dsamp = unit->m_dsamp;
6209 float feedbk = unit->m_feedbk;
6210 long mask = unit->m_mask;
6211 float thisin, curtrig;
6212 float prevtrig = unit->m_prevtrig;
6213
6214 if (delaytime == unit->m_delaytime && decaytime == unit->m_decaytime) {
6215 long idsamp = (long)dsamp;
6216 float frac = dsamp - idsamp;
6217 for(int i = 0; i < inNumSamples; i++){
6218 curtrig = trig[i];
6219 if ((prevtrig <= 0.f) && (curtrig > 0.f)) {
6220 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
6221 }
6222 prevtrig = curtrig;
6223 long irdphase1 = iwrphase - idsamp;
6224 long irdphase2 = irdphase1 - 1;
6225 long irdphase3 = irdphase1 - 2;
6226 long irdphase0 = irdphase1 + 1;
6227 if (inputsamps > 0) {
6228 thisin = in[i];
6229 --inputsamps;
6230 } else {
6231 thisin = 0.f;
6232 }
6233 float d0 = dlybuf[irdphase0 & mask];
6234 float d1 = dlybuf[irdphase1 & mask];
6235 float d2 = dlybuf[irdphase2 & mask];
6236 float d3 = dlybuf[irdphase3 & mask];
6237 float value = cubicinterp(frac, d0, d1, d2, d3);
6238 float thiscoef = coef[i];
6239 float onepole = ((1. - fabs(thiscoef)) * value) + (thiscoef * lastsamp);
6240 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
6241 out[i] = lastsamp = onepole;
6242 iwrphase++;
6243 };
6244 } else {
6245
6246 float next_dsamp = CalcDelay(unit, delaytime);
6247 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
6248
6249 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
6250 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
6251
6252 for(int i = 0; i < inNumSamples; i++){
6253 curtrig = trig[i];
6254 if ((prevtrig <= 0.f) && (curtrig > 0.f)) {
6255 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
6256 }
6257 prevtrig = curtrig;
6258 dsamp += dsamp_slope;
6259 long idsamp = (long)dsamp;
6260 float frac = dsamp - idsamp;
6261 long irdphase1 = iwrphase - idsamp;
6262 long irdphase2 = irdphase1 - 1;
6263 long irdphase3 = irdphase1 - 2;
6264 long irdphase0 = irdphase1 + 1;
6265 if (inputsamps > 0) {
6266 thisin = in[i];
6267 --inputsamps;
6268 } else {
6269 thisin = 0.f;
6270 }
6271 float d0 = dlybuf[irdphase0 & mask];
6272 float d1 = dlybuf[irdphase1 & mask];
6273 float d2 = dlybuf[irdphase2 & mask];
6274 float d3 = dlybuf[irdphase3 & mask];
6275 float value = cubicinterp(frac, d0, d1, d2, d3);
6276 float thiscoef = coef[i];
6277 float onepole = ((1. - fabs(thiscoef)) * value) + (thiscoef * lastsamp);
6278 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
6279 out[i] = lastsamp = onepole;
6280 feedbk += feedbk_slope;
6281 iwrphase++;
6282 };
6283 unit->m_feedbk = feedbk;
6284 unit->m_dsamp = dsamp;
6285 unit->m_delaytime = delaytime;
6286 unit->m_decaytime = decaytime;
6287 }
6288
6289 unit->m_prevtrig = prevtrig;
6290 unit->m_inputsamps = inputsamps;
6291 unit->m_lastsamp = zapgremlins(lastsamp);
6292 unit->m_iwrphase = iwrphase;
6293
6294 }
6295
6296
6297 void Pluck_next_aa_z(Pluck *unit, int inNumSamples)
6298 {
6299 float *out = OUT(0);
6300 float *in = IN(0);
6301 float *trig = IN(1);
6302 float delaytime = IN0(3);
6303 float decaytime = IN0(4);
6304 float *coef = IN(5);
6305 float lastsamp = unit->m_lastsamp;
6306
6307 float *dlybuf = unit->m_dlybuf;
6308 long iwrphase = unit->m_iwrphase;
6309 float dsamp = unit->m_dsamp;
6310 float feedbk = unit->m_feedbk;
6311 long mask = unit->m_mask;
6312 float d0, d1, d2, d3;
6313 float thisin, curtrig;
6314 unsigned long inputsamps = unit->m_inputsamps;
6315 float prevtrig = unit->m_prevtrig;
6316
6317 if (delaytime == unit->m_delaytime && decaytime == unit->m_decaytime) {
6318 long idsamp = (long)dsamp;
6319 float frac = dsamp - idsamp;
6320 for(int i = 0; i < inNumSamples; i++){
6321 curtrig = trig[i];
6322 if ((prevtrig <= 0.f) && (curtrig > 0.f)) {
6323 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
6324 }
6325 prevtrig = curtrig;
6326 long irdphase1 = iwrphase - idsamp;
6327 long irdphase2 = irdphase1 - 1;
6328 long irdphase3 = irdphase1 - 2;
6329 long irdphase0 = irdphase1 + 1;
6330 if (inputsamps > 0) {
6331 thisin = in[i];
6332 --inputsamps;
6333 } else {
6334 thisin = 0.f;
6335 }
6336 if (irdphase0 < 0) {
6337 dlybuf[iwrphase & mask] = thisin;
6338 out[i] = 0.f;
6339 } else {
6340 if (irdphase1 < 0) {
6341 d1 = d2 = d3 = 0.f;
6342 d0 = dlybuf[irdphase0 & mask];
6343 } else if (irdphase2 < 0) {
6344 d1 = d2 = d3 = 0.f;
6345 d0 = dlybuf[irdphase0 & mask];
6346 d1 = dlybuf[irdphase1 & mask];
6347 } else if (irdphase3 < 0) {
6348 d3 = 0.f;
6349 d0 = dlybuf[irdphase0 & mask];
6350 d1 = dlybuf[irdphase1 & mask];
6351 d2 = dlybuf[irdphase2 & mask];
6352 } else {
6353 d0 = dlybuf[irdphase0 & mask];
6354 d1 = dlybuf[irdphase1 & mask];
6355 d2 = dlybuf[irdphase2 & mask];
6356 d3 = dlybuf[irdphase3 & mask];
6357 }
6358 float value = cubicinterp(frac, d0, d1, d2, d3);
6359 float thiscoef = coef[i];
6360 float onepole = ((1. - fabs(thiscoef)) * value) + (thiscoef * lastsamp);
6361 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
6362 out[i] = lastsamp = onepole;
6363 }
6364 iwrphase++;
6365 };
6366 } else {
6367
6368 float next_dsamp = CalcDelay(unit, delaytime);
6369 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
6370
6371 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
6372 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
6373
6374 for(int i = 0; i < inNumSamples; i++) {
6375 curtrig = trig[i];
6376 if ((prevtrig <= 0.f) && (curtrig > 0.f)) {
6377 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
6378 }
6379 prevtrig = curtrig;
6380 dsamp += dsamp_slope;
6381 long idsamp = (long)dsamp;
6382 float frac = dsamp - idsamp;
6383 long irdphase1 = iwrphase - idsamp;
6384 long irdphase2 = irdphase1 - 1;
6385 long irdphase3 = irdphase1 - 2;
6386 long irdphase0 = irdphase1 + 1;
6387 if (inputsamps > 0) {
6388 thisin = in[i];
6389 --inputsamps;
6390 } else {
6391 thisin = 0.f;
6392 }
6393 if (irdphase0 < 0) {
6394 dlybuf[iwrphase & mask] = thisin;
6395 out[i] = 0.f;
6396 } else {
6397 if (irdphase1 < 0) {
6398 d1 = d2 = d3 = 0.f;
6399 d0 = dlybuf[irdphase0 & mask];
6400 } else if (irdphase2 < 0) {
6401 d1 = d2 = d3 = 0.f;
6402 d0 = dlybuf[irdphase0 & mask];
6403 d1 = dlybuf[irdphase1 & mask];
6404 } else if (irdphase3 < 0) {
6405 d3 = 0.f;
6406 d0 = dlybuf[irdphase0 & mask];
6407 d1 = dlybuf[irdphase1 & mask];
6408 d2 = dlybuf[irdphase2 & mask];
6409 } else {
6410 d0 = dlybuf[irdphase0 & mask];
6411 d1 = dlybuf[irdphase1 & mask];
6412 d2 = dlybuf[irdphase2 & mask];
6413 d3 = dlybuf[irdphase3 & mask];
6414 }
6415 float value = cubicinterp(frac, d0, d1, d2, d3);
6416 float thiscoef = coef[i];
6417 float onepole = ((1. - fabs(thiscoef)) * value) + (thiscoef * lastsamp);
6418 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
6419 out[i] = lastsamp = onepole;
6420 }
6421 feedbk += feedbk_slope;
6422 iwrphase++;
6423 };
6424 unit->m_feedbk = feedbk;
6425 unit->m_dsamp = dsamp;
6426 unit->m_delaytime = delaytime;
6427 unit->m_decaytime = decaytime;
6428 }
6429
6430 unit->m_inputsamps = inputsamps;
6431 unit->m_prevtrig = prevtrig;
6432 unit->m_lastsamp = zapgremlins(lastsamp);
6433 unit->m_iwrphase = iwrphase;
6434
6435 unit->m_numoutput += inNumSamples;
6436 if (unit->m_numoutput >= unit->m_idelaylen) {
6437 SETCALC(Pluck_next_aa);
6438 }
6439 }
6440
6441 void Pluck_next_kk(Pluck *unit, int inNumSamples)
6442 {
6443 float *out = OUT(0);
6444 float *in = IN(0);
6445 float trig = IN0(1);
6446 float delaytime = IN0(3);
6447 float decaytime = IN0(4);
6448 float coef = IN0(5);
6449 float lastsamp = unit->m_lastsamp;
6450 unsigned long inputsamps = unit->m_inputsamps;
6451
6452 float *dlybuf = unit->m_dlybuf;
6453 long iwrphase = unit->m_iwrphase;
6454 float dsamp = unit->m_dsamp;
6455 float feedbk = unit->m_feedbk;
6456 long mask = unit->m_mask;
6457 float thisin;
6458
6459 if ((unit->m_prevtrig <= 0.f) && (trig > 0.f)) {
6460 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
6461 }
6462 unit->m_prevtrig = trig;
6463
6464 if (delaytime == unit->m_delaytime && decaytime == unit->m_decaytime && coef == unit->m_coef) {
6465 long idsamp = (long)dsamp;
6466 float frac = dsamp - idsamp;
6467
6468 for(int i = 0; i < inNumSamples; i++){
6469 long irdphase1 = iwrphase - idsamp;
6470 long irdphase2 = irdphase1 - 1;
6471 long irdphase3 = irdphase1 - 2;
6472 long irdphase0 = irdphase1 + 1;
6473 if (inputsamps > 0) {
6474 thisin = in[i];
6475 --inputsamps;
6476 } else {
6477 thisin = 0.f;
6478 }
6479 float d0 = dlybuf[irdphase0 & mask];
6480 float d1 = dlybuf[irdphase1 & mask];
6481 float d2 = dlybuf[irdphase2 & mask];
6482 float d3 = dlybuf[irdphase3 & mask];
6483 float value = cubicinterp(frac, d0, d1, d2, d3);
6484 float onepole = ((1. - fabs(coef)) * value) + (coef * lastsamp);
6485 dlybuf[iwrphase & mask] = thisin + (feedbk * onepole);
6486 out[i] = lastsamp = onepole; //value;
6487 iwrphase++;
6488 };
6489 } else {
6490
6491 float next_dsamp = CalcDelay(unit, delaytime);
6492 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
6493
6494 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
6495 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
6496
6497 float curcoef = unit->m_coef;
6498 float coef_slope = CALCSLOPE(coef, curcoef);
6499
6500 for(int i = 0; i < inNumSamples; i++){
6501 dsamp += dsamp_slope;
6502 long idsamp = (long)dsamp;
6503 float frac = dsamp - idsamp;
6504 long irdphase1 = iwrphase - idsamp;
6505 long irdphase2 = irdphase1 - 1;
6506 long irdphase3 = irdphase1 - 2;
6507 long irdphase0 = irdphase1 + 1;
6508 if (inputsamps > 0) {
6509 thisin = in[i];
6510 --inputsamps;
6511 } else {
6512 thisin = 0.f;
6513 }
6514 float d0 = dlybuf[irdphase0 & mask];
6515 float d1 = dlybuf[irdphase1 & mask];
6516 float d2 = dlybuf[irdphase2 & mask];
6517 float d3 = dlybuf[irdphase3 & mask];
6518 float value = cubicinterp(frac, d0, d1, d2, d3);
6519 float onepole = ((1. - fabs(curcoef)) * value) + (curcoef * lastsamp);
6520 dlybuf[iwrphase & mask] = thisin + (feedbk * onepole);
6521 out[i] = lastsamp = onepole; //value;
6522 feedbk += feedbk_slope;
6523 curcoef += coef_slope;
6524 iwrphase++;
6525 };
6526 unit->m_feedbk = feedbk;
6527 unit->m_coef = coef;
6528 unit->m_dsamp = dsamp;
6529 unit->m_delaytime = delaytime;
6530 unit->m_decaytime = decaytime;
6531 }
6532
6533 unit->m_inputsamps = inputsamps;
6534 unit->m_lastsamp = zapgremlins(lastsamp);
6535 unit->m_iwrphase = iwrphase;
6536
6537 }
6538
6539
6540 void Pluck_next_kk_z(Pluck *unit, int inNumSamples)
6541 {
6542 float *out = OUT(0);
6543 float *in = IN(0);
6544 float trig = IN0(1);
6545 float delaytime = IN0(3);
6546 float decaytime = IN0(4);
6547 float coef = IN0(5);
6548 float lastsamp = unit->m_lastsamp;
6549
6550 float *dlybuf = unit->m_dlybuf;
6551 long iwrphase = unit->m_iwrphase;
6552 float dsamp = unit->m_dsamp;
6553 float feedbk = unit->m_feedbk;
6554 long mask = unit->m_mask;
6555 float d0, d1, d2, d3;
6556 float thisin;
6557 unsigned long inputsamps = unit->m_inputsamps;
6558
6559 if ((unit->m_prevtrig <= 0.f) && (trig > 0.f)) {
6560 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
6561 }
6562 unit->m_prevtrig = trig;
6563
6564 if (delaytime == unit->m_delaytime && decaytime == unit->m_decaytime && coef == unit->m_coef) {
6565 long idsamp = (long)dsamp;
6566 float frac = dsamp - idsamp;
6567 for(int i = 0; i < inNumSamples; i++){
6568
6569 long irdphase1 = iwrphase - idsamp;
6570 long irdphase2 = irdphase1 - 1;
6571 long irdphase3 = irdphase1 - 2;
6572 long irdphase0 = irdphase1 + 1;
6573 if (inputsamps > 0) {
6574 thisin = in[i];
6575 --inputsamps;
6576 } else {
6577 thisin = 0.f;
6578 }
6579 if (irdphase0 < 0) {
6580 dlybuf[iwrphase & mask] = thisin;
6581 out[i] = 0.f;
6582 } else {
6583 if (irdphase1 < 0) {
6584 d1 = d2 = d3 = 0.f;
6585 d0 = dlybuf[irdphase0 & mask];
6586 } else if (irdphase2 < 0) {
6587 d1 = d2 = d3 = 0.f;
6588 d0 = dlybuf[irdphase0 & mask];
6589 d1 = dlybuf[irdphase1 & mask];
6590 } else if (irdphase3 < 0) {
6591 d3 = 0.f;
6592 d0 = dlybuf[irdphase0 & mask];
6593 d1 = dlybuf[irdphase1 & mask];
6594 d2 = dlybuf[irdphase2 & mask];
6595 } else {
6596 d0 = dlybuf[irdphase0 & mask];
6597 d1 = dlybuf[irdphase1 & mask];
6598 d2 = dlybuf[irdphase2 & mask];
6599 d3 = dlybuf[irdphase3 & mask];
6600 }
6601 float value = cubicinterp(frac, d0, d1, d2, d3);
6602 float onepole = ((1. - fabs(coef)) * value) + (coef * lastsamp);
6603 dlybuf[iwrphase & mask] = thisin + (feedbk * onepole);
6604 out[i] = lastsamp = onepole; //value;
6605 }
6606 iwrphase++;
6607 };
6608 } else {
6609
6610 float next_dsamp = CalcDelay(unit, delaytime);
6611 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
6612
6613 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
6614 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
6615
6616 float curcoef = unit->m_coef;
6617 float coef_slope = CALCSLOPE(coef, curcoef);
6618
6619 for(int i = 0; i < inNumSamples; i++) {
6620 dsamp += dsamp_slope;
6621 long idsamp = (long)dsamp;
6622 float frac = dsamp - idsamp;
6623 long irdphase1 = iwrphase - idsamp;
6624 long irdphase2 = irdphase1 - 1;
6625 long irdphase3 = irdphase1 - 2;
6626 long irdphase0 = irdphase1 + 1;
6627 if (inputsamps > 0) {
6628 thisin = in[i];
6629 --inputsamps;
6630 } else {
6631 thisin = 0.f;
6632 }
6633 if (irdphase0 < 0) {
6634 dlybuf[iwrphase & mask] = thisin;
6635 out[i] = 0.f;
6636 } else {
6637 if (irdphase1 < 0) {
6638 d1 = d2 = d3 = 0.f;
6639 d0 = dlybuf[irdphase0 & mask];
6640 } else if (irdphase2 < 0) {
6641 d1 = d2 = d3 = 0.f;
6642 d0 = dlybuf[irdphase0 & mask];
6643 d1 = dlybuf[irdphase1 & mask];
6644 } else if (irdphase3 < 0) {
6645 d3 = 0.f;
6646 d0 = dlybuf[irdphase0 & mask];
6647 d1 = dlybuf[irdphase1 & mask];
6648 d2 = dlybuf[irdphase2 & mask];
6649 } else {
6650 d0 = dlybuf[irdphase0 & mask];
6651 d1 = dlybuf[irdphase1 & mask];
6652 d2 = dlybuf[irdphase2 & mask];
6653 d3 = dlybuf[irdphase3 & mask];
6654 }
6655 float value = cubicinterp(frac, d0, d1, d2, d3);
6656 float onepole = ((1. - fabs(curcoef)) * value) + (curcoef * lastsamp);
6657 dlybuf[iwrphase & mask] = thisin + (feedbk * onepole);
6658 out[i] = lastsamp = onepole; //value;
6659 }
6660 feedbk += feedbk_slope;
6661 curcoef += coef_slope;
6662 iwrphase++;
6663 };
6664 unit->m_feedbk = feedbk;
6665 unit->m_dsamp = dsamp;
6666 unit->m_delaytime = delaytime;
6667 unit->m_decaytime = decaytime;
6668 unit->m_coef = coef;
6669 }
6670
6671 unit->m_inputsamps = inputsamps;
6672 unit->m_lastsamp = zapgremlins(lastsamp);
6673 unit->m_iwrphase = iwrphase;
6674
6675 unit->m_numoutput += inNumSamples;
6676 if (unit->m_numoutput >= unit->m_idelaylen) {
6677 SETCALC(Pluck_next_kk);
6678 }
6679 }
6680
6681 void Pluck_next_ak(Pluck *unit, int inNumSamples)
6682 {
6683 float *out = OUT(0);
6684 float *in = IN(0);
6685 float *trig = IN(1);
6686 float delaytime = IN0(3);
6687 float decaytime = IN0(4);
6688 float coef = IN0(5);
6689 float lastsamp = unit->m_lastsamp;
6690 unsigned long inputsamps = unit->m_inputsamps;
6691
6692 float *dlybuf = unit->m_dlybuf;
6693 long iwrphase = unit->m_iwrphase;
6694 float dsamp = unit->m_dsamp;
6695 float feedbk = unit->m_feedbk;
6696 long mask = unit->m_mask;
6697 float thisin, curtrig;
6698 float prevtrig = unit->m_prevtrig;
6699
6700 if (delaytime == unit->m_delaytime && decaytime == unit->m_decaytime) {
6701 long idsamp = (long)dsamp;
6702 float frac = dsamp - idsamp;
6703 for(int i = 0; i < inNumSamples; i++){
6704 curtrig = trig[i];
6705 if ((prevtrig <= 0.f) && (curtrig > 0.f)) {
6706 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
6707 }
6708 prevtrig = curtrig;
6709 long irdphase1 = iwrphase - idsamp;
6710 long irdphase2 = irdphase1 - 1;
6711 long irdphase3 = irdphase1 - 2;
6712 long irdphase0 = irdphase1 + 1;
6713 if (inputsamps > 0) {
6714 thisin = in[i];
6715 --inputsamps;
6716 } else {
6717 thisin = 0.f;
6718 }
6719 float d0 = dlybuf[irdphase0 & mask];
6720 float d1 = dlybuf[irdphase1 & mask];
6721 float d2 = dlybuf[irdphase2 & mask];
6722 float d3 = dlybuf[irdphase3 & mask];
6723 float value = cubicinterp(frac, d0, d1, d2, d3);
6724 float onepole = ((1. - fabs(coef)) * value) + (coef * lastsamp);
6725 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
6726 out[i] = lastsamp = onepole;
6727 iwrphase++;
6728 };
6729 } else {
6730
6731 float next_dsamp = CalcDelay(unit, delaytime);
6732 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
6733
6734 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
6735 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
6736
6737 float curcoef = unit->m_coef;
6738 float coef_slope = CALCSLOPE(coef, curcoef);
6739
6740 for(int i = 0; i < inNumSamples; i++){
6741 curtrig = trig[i];
6742 if ((prevtrig <= 0.f) && (curtrig > 0.f)) {
6743 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
6744 }
6745 prevtrig = curtrig;
6746 dsamp += dsamp_slope;
6747 long idsamp = (long)dsamp;
6748 float frac = dsamp - idsamp;
6749 long irdphase1 = iwrphase - idsamp;
6750 long irdphase2 = irdphase1 - 1;
6751 long irdphase3 = irdphase1 - 2;
6752 long irdphase0 = irdphase1 + 1;
6753 if (inputsamps > 0) {
6754 thisin = in[i];
6755 --inputsamps;
6756 } else {
6757 thisin = 0.f;
6758 }
6759 float d0 = dlybuf[irdphase0 & mask];
6760 float d1 = dlybuf[irdphase1 & mask];
6761 float d2 = dlybuf[irdphase2 & mask];
6762 float d3 = dlybuf[irdphase3 & mask];
6763 float value = cubicinterp(frac, d0, d1, d2, d3);
6764 float onepole = ((1. - fabs(curcoef)) * value) + (curcoef * lastsamp);
6765 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
6766 out[i] = lastsamp = onepole;
6767 feedbk += feedbk_slope;
6768 curcoef += coef_slope;
6769 iwrphase++;
6770 };
6771 unit->m_feedbk = feedbk;
6772 unit->m_dsamp = dsamp;
6773 unit->m_delaytime = delaytime;
6774 unit->m_decaytime = decaytime;
6775 unit->m_coef = coef;
6776 }
6777
6778 unit->m_prevtrig = prevtrig;
6779 unit->m_inputsamps = inputsamps;
6780 unit->m_lastsamp = zapgremlins(lastsamp);
6781 unit->m_iwrphase = iwrphase;
6782
6783 }
6784
6785
6786 void Pluck_next_ak_z(Pluck *unit, int inNumSamples)
6787 {
6788 float *out = OUT(0);
6789 float *in = IN(0);
6790 float *trig = IN(1);
6791 float delaytime = IN0(3);
6792 float decaytime = IN0(4);
6793 float coef = IN0(5);
6794 float lastsamp = unit->m_lastsamp;
6795
6796 float *dlybuf = unit->m_dlybuf;
6797 long iwrphase = unit->m_iwrphase;
6798 float dsamp = unit->m_dsamp;
6799 float feedbk = unit->m_feedbk;
6800 long mask = unit->m_mask;
6801 float d0, d1, d2, d3;
6802 float thisin, curtrig;
6803 unsigned long inputsamps = unit->m_inputsamps;
6804 float prevtrig = unit->m_prevtrig;
6805
6806 if (delaytime == unit->m_delaytime && decaytime == unit->m_decaytime && coef == unit->m_coef) {
6807 long idsamp = (long)dsamp;
6808 float frac = dsamp - idsamp;
6809 for(int i = 0; i < inNumSamples; i++){
6810 curtrig = trig[i];
6811 if ((prevtrig <= 0.f) && (curtrig > 0.f)) {
6812 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
6813 }
6814 prevtrig = curtrig;
6815 long irdphase1 = iwrphase - idsamp;
6816 long irdphase2 = irdphase1 - 1;
6817 long irdphase3 = irdphase1 - 2;
6818 long irdphase0 = irdphase1 + 1;
6819 if (inputsamps > 0) {
6820 thisin = in[i];
6821 --inputsamps;
6822 } else {
6823 thisin = 0.f;
6824 }
6825 if (irdphase0 < 0) {
6826 dlybuf[iwrphase & mask] = thisin;
6827 out[i] = 0.f;
6828 } else {
6829 if (irdphase1 < 0) {
6830 d1 = d2 = d3 = 0.f;
6831 d0 = dlybuf[irdphase0 & mask];
6832 } else if (irdphase2 < 0) {
6833 d1 = d2 = d3 = 0.f;
6834 d0 = dlybuf[irdphase0 & mask];
6835 d1 = dlybuf[irdphase1 & mask];
6836 } else if (irdphase3 < 0) {
6837 d3 = 0.f;
6838 d0 = dlybuf[irdphase0 & mask];
6839 d1 = dlybuf[irdphase1 & mask];
6840 d2 = dlybuf[irdphase2 & mask];
6841 } else {
6842 d0 = dlybuf[irdphase0 & mask];
6843 d1 = dlybuf[irdphase1 & mask];
6844 d2 = dlybuf[irdphase2 & mask];
6845 d3 = dlybuf[irdphase3 & mask];
6846 }
6847 float value = cubicinterp(frac, d0, d1, d2, d3);
6848 float onepole = ((1. - fabs(coef)) * value) + (coef * lastsamp);
6849 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
6850 out[i] = lastsamp = onepole;
6851 }
6852 iwrphase++;
6853 };
6854 } else {
6855
6856 float next_dsamp = CalcDelay(unit, delaytime);
6857 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
6858
6859 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
6860 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
6861
6862 float curcoef = unit->m_coef;
6863 float coef_slope = CALCSLOPE(coef, curcoef);
6864
6865 for(int i = 0; i < inNumSamples; i++) {
6866 curtrig = trig[i];
6867 if ((prevtrig <= 0.f) && (curtrig > 0.f)) {
6868 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
6869 }
6870 prevtrig = curtrig;
6871 dsamp += dsamp_slope;
6872 long idsamp = (long)dsamp;
6873 float frac = dsamp - idsamp;
6874 long irdphase1 = iwrphase - idsamp;
6875 long irdphase2 = irdphase1 - 1;
6876 long irdphase3 = irdphase1 - 2;
6877 long irdphase0 = irdphase1 + 1;
6878 if (inputsamps > 0) {
6879 thisin = in[i];
6880 --inputsamps;
6881 } else {
6882 thisin = 0.f;
6883 }
6884 if (irdphase0 < 0) {
6885 dlybuf[iwrphase & mask] = thisin;
6886 out[i] = 0.f;
6887 } else {
6888 if (irdphase1 < 0) {
6889 d1 = d2 = d3 = 0.f;
6890 d0 = dlybuf[irdphase0 & mask];
6891 } else if (irdphase2 < 0) {
6892 d1 = d2 = d3 = 0.f;
6893 d0 = dlybuf[irdphase0 & mask];
6894 d1 = dlybuf[irdphase1 & mask];
6895 } else if (irdphase3 < 0) {
6896 d3 = 0.f;
6897 d0 = dlybuf[irdphase0 & mask];
6898 d1 = dlybuf[irdphase1 & mask];
6899 d2 = dlybuf[irdphase2 & mask];
6900 } else {
6901 d0 = dlybuf[irdphase0 & mask];
6902 d1 = dlybuf[irdphase1 & mask];
6903 d2 = dlybuf[irdphase2 & mask];
6904 d3 = dlybuf[irdphase3 & mask];
6905 }
6906 float value = cubicinterp(frac, d0, d1, d2, d3);
6907 float onepole = ((1. - fabs(curcoef)) * value) + (curcoef * lastsamp);
6908 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
6909 out[i] = lastsamp = onepole;
6910 }
6911 feedbk += feedbk_slope;
6912 curcoef +=coef_slope;
6913 iwrphase++;
6914 };
6915 unit->m_feedbk = feedbk;
6916 unit->m_dsamp = dsamp;
6917 unit->m_delaytime = delaytime;
6918 unit->m_decaytime = decaytime;
6919 unit->m_coef = coef;
6920 }
6921
6922 unit->m_inputsamps = inputsamps;
6923 unit->m_prevtrig = prevtrig;
6924 unit->m_lastsamp = zapgremlins(lastsamp);
6925 unit->m_iwrphase = iwrphase;
6926
6927 unit->m_numoutput += inNumSamples;
6928 if (unit->m_numoutput >= unit->m_idelaylen) {
6929 SETCALC(Pluck_next_ak);
6930 }
6931 }
6932
6933
6934 void Pluck_next_ka(Pluck *unit, int inNumSamples)
6935 {
6936 float *out = OUT(0);
6937 float *in = IN(0);
6938 float trig = IN0(1);
6939 float delaytime = IN0(3);
6940 float decaytime = IN0(4);
6941 float *coef = IN(5);
6942 float lastsamp = unit->m_lastsamp;
6943 unsigned long inputsamps = unit->m_inputsamps;
6944
6945 float *dlybuf = unit->m_dlybuf;
6946 long iwrphase = unit->m_iwrphase;
6947 float dsamp = unit->m_dsamp;
6948 float feedbk = unit->m_feedbk;
6949 long mask = unit->m_mask;
6950 float thisin;
6951
6952 if ((unit->m_prevtrig <= 0.f) && (trig > 0.f)) {
6953 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
6954 }
6955 unit->m_prevtrig = trig;
6956
6957 if (delaytime == unit->m_delaytime && decaytime == unit->m_decaytime) {
6958 long idsamp = (long)dsamp;
6959 float frac = dsamp - idsamp;
6960 for(int i = 0; i < inNumSamples; i++){
6961 long irdphase1 = iwrphase - idsamp;
6962 long irdphase2 = irdphase1 - 1;
6963 long irdphase3 = irdphase1 - 2;
6964 long irdphase0 = irdphase1 + 1;
6965 if (inputsamps > 0) {
6966 thisin = in[i];
6967 --inputsamps;
6968 } else {
6969 thisin = 0.f;
6970 }
6971 float d0 = dlybuf[irdphase0 & mask];
6972 float d1 = dlybuf[irdphase1 & mask];
6973 float d2 = dlybuf[irdphase2 & mask];
6974 float d3 = dlybuf[irdphase3 & mask];
6975 float value = cubicinterp(frac, d0, d1, d2, d3);
6976 float thiscoef = coef[i];
6977 float onepole = ((1. - fabs(thiscoef)) * value) + (thiscoef * lastsamp);
6978 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
6979 out[i] = lastsamp = onepole;
6980 iwrphase++;
6981 };
6982 } else {
6983
6984 float next_dsamp = CalcDelay(unit, delaytime);
6985 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
6986
6987 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
6988 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
6989
6990 for(int i = 0; i < inNumSamples; i++){
6991 dsamp += dsamp_slope;
6992 long idsamp = (long)dsamp;
6993 float frac = dsamp - idsamp;
6994 long irdphase1 = iwrphase - idsamp;
6995 long irdphase2 = irdphase1 - 1;
6996 long irdphase3 = irdphase1 - 2;
6997 long irdphase0 = irdphase1 + 1;
6998 if (inputsamps > 0) {
6999 thisin = in[i];
7000 --inputsamps;
7001 } else {
7002 thisin = 0.f;
7003 }
7004 float d0 = dlybuf[irdphase0 & mask];
7005 float d1 = dlybuf[irdphase1 & mask];
7006 float d2 = dlybuf[irdphase2 & mask];
7007 float d3 = dlybuf[irdphase3 & mask];
7008 float value = cubicinterp(frac, d0, d1, d2, d3);
7009 float thiscoef = coef[i];
7010 float onepole = ((1. - fabs(thiscoef)) * value) + (thiscoef * lastsamp);
7011 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
7012 out[i] = lastsamp = onepole;
7013 feedbk += feedbk_slope;
7014 iwrphase++;
7015 };
7016 unit->m_feedbk = feedbk;
7017 unit->m_dsamp = dsamp;
7018 unit->m_delaytime = delaytime;
7019 unit->m_decaytime = decaytime;
7020 }
7021
7022 unit->m_inputsamps = inputsamps;
7023 unit->m_lastsamp = zapgremlins(lastsamp);
7024 unit->m_iwrphase = iwrphase;
7025
7026 }
7027
7028
7029 void Pluck_next_ka_z(Pluck *unit, int inNumSamples)
7030 {
7031 float *out = OUT(0);
7032 float *in = IN(0);
7033 float trig = IN0(1);
7034 float delaytime = IN0(3);
7035 float decaytime = IN0(4);
7036 float *coef = IN(5);
7037 float lastsamp = unit->m_lastsamp;
7038
7039 float *dlybuf = unit->m_dlybuf;
7040 long iwrphase = unit->m_iwrphase;
7041 float dsamp = unit->m_dsamp;
7042 float feedbk = unit->m_feedbk;
7043 long mask = unit->m_mask;
7044 float d0, d1, d2, d3;
7045 float thisin;
7046 unsigned long inputsamps = unit->m_inputsamps;
7047
7048 if ((unit->m_prevtrig <= 0.f) && (trig > 0.f)) {
7049 inputsamps = (long)(delaytime * unit->mRate->mSampleRate + .5f);
7050 }
7051
7052 unit->m_prevtrig = trig;
7053
7054 if (delaytime == unit->m_delaytime && decaytime == unit->m_decaytime) {
7055 long idsamp = (long)dsamp;
7056 float frac = dsamp - idsamp;
7057 for(int i = 0; i < inNumSamples; i++){
7058 long irdphase1 = iwrphase - idsamp;
7059 long irdphase2 = irdphase1 - 1;
7060 long irdphase3 = irdphase1 - 2;
7061 long irdphase0 = irdphase1 + 1;
7062 if (inputsamps > 0) {
7063 thisin = in[i];
7064 --inputsamps;
7065 } else {
7066 thisin = 0.f;
7067 }
7068 if (irdphase0 < 0) {
7069 dlybuf[iwrphase & mask] = thisin;
7070 out[i] = 0.f;
7071 } else {
7072 if (irdphase1 < 0) {
7073 d1 = d2 = d3 = 0.f;
7074 d0 = dlybuf[irdphase0 & mask];
7075 } else if (irdphase2 < 0) {
7076 d1 = d2 = d3 = 0.f;
7077 d0 = dlybuf[irdphase0 & mask];
7078 d1 = dlybuf[irdphase1 & mask];
7079 } else if (irdphase3 < 0) {
7080 d3 = 0.f;
7081 d0 = dlybuf[irdphase0 & mask];
7082 d1 = dlybuf[irdphase1 & mask];
7083 d2 = dlybuf[irdphase2 & mask];
7084 } else {
7085 d0 = dlybuf[irdphase0 & mask];
7086 d1 = dlybuf[irdphase1 & mask];
7087 d2 = dlybuf[irdphase2 & mask];
7088 d3 = dlybuf[irdphase3 & mask];
7089 }
7090 float value = cubicinterp(frac, d0, d1, d2, d3);
7091 float thiscoef = coef[i];
7092 float onepole = ((1. - fabs(thiscoef)) * value) + (thiscoef * lastsamp);
7093 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
7094 out[i] = lastsamp = onepole;
7095 }
7096 iwrphase++;
7097 };
7098 } else {
7099
7100 float next_dsamp = CalcDelay(unit, delaytime);
7101 float dsamp_slope = CALCSLOPE(next_dsamp, dsamp);
7102
7103 float next_feedbk = sc_CalcFeedback(delaytime, decaytime);
7104 float feedbk_slope = CALCSLOPE(next_feedbk, feedbk);
7105
7106 for(int i = 0; i < inNumSamples; i++) {
7107 dsamp += dsamp_slope;
7108 long idsamp = (long)dsamp;
7109 float frac = dsamp - idsamp;
7110 long irdphase1 = iwrphase - idsamp;
7111 long irdphase2 = irdphase1 - 1;
7112 long irdphase3 = irdphase1 - 2;
7113 long irdphase0 = irdphase1 + 1;
7114 if (inputsamps > 0) {
7115 thisin = in[i];
7116 --inputsamps;
7117 } else {
7118 thisin = 0.f;
7119 }
7120 if (irdphase0 < 0) {
7121 dlybuf[iwrphase & mask] = thisin;
7122 out[i] = 0.f;
7123 } else {
7124 if (irdphase1 < 0) {
7125 d1 = d2 = d3 = 0.f;
7126 d0 = dlybuf[irdphase0 & mask];
7127 } else if (irdphase2 < 0) {
7128 d1 = d2 = d3 = 0.f;
7129 d0 = dlybuf[irdphase0 & mask];
7130 d1 = dlybuf[irdphase1 & mask];
7131 } else if (irdphase3 < 0) {
7132 d3 = 0.f;
7133 d0 = dlybuf[irdphase0 & mask];
7134 d1 = dlybuf[irdphase1 & mask];
7135 d2 = dlybuf[irdphase2 & mask];
7136 } else {
7137 d0 = dlybuf[irdphase0 & mask];
7138 d1 = dlybuf[irdphase1 & mask];
7139 d2 = dlybuf[irdphase2 & mask];
7140 d3 = dlybuf[irdphase3 & mask];
7141 }
7142 float value = cubicinterp(frac, d0, d1, d2, d3);
7143 float thiscoef = coef[i];
7144 float onepole = ((1. - fabs(thiscoef)) * value) + (thiscoef * lastsamp);
7145 dlybuf[iwrphase & mask] = thisin + feedbk * onepole;
7146 out[i] = lastsamp = onepole;
7147 }
7148 feedbk += feedbk_slope;
7149 iwrphase++;
7150 };
7151 unit->m_feedbk = feedbk;
7152 unit->m_dsamp = dsamp;
7153 unit->m_delaytime = delaytime;
7154 unit->m_decaytime = decaytime;
7155 }
7156
7157 unit->m_inputsamps = inputsamps;
7158 unit->m_lastsamp = zapgremlins(lastsamp);
7159 unit->m_iwrphase = iwrphase;
7160
7161 unit->m_numoutput += inNumSamples;
7162 if (unit->m_numoutput >= unit->m_idelaylen) {
7163 SETCALC(Pluck_next_ka);
7164 }
7165 }
7166
7167
7168 ////////////////////////////////////////////////////////////////////////////////////////////////////////
7169
7170
7171 #define DELTAP_BUF \
7172 World *world = unit->mWorld;\
7173 if (bufnum >= world->mNumSndBufs) { \
7174 int localBufNum = bufnum - world->mNumSndBufs; \
7175 Graph *parent = unit->mParent; \
7176 if(localBufNum <= parent->localBufNum) { \
7177 unit->m_buf = parent->mLocalSndBufs + localBufNum; \
7178 } else { \
7179 bufnum = 0; \
7180 unit->m_buf = world->mSndBufs + bufnum; \
7181 } \
7182 } else { \
7183 unit->m_buf = world->mSndBufs + bufnum; \
7184 } \
7185 SndBuf *buf = unit->m_buf; \
7186 float *bufData __attribute__((__unused__)) = buf->data; \
7187 uint32 bufChannels __attribute__((__unused__)) = buf->channels; \
7188 uint32 bufSamples = buf->samples; \
7189 uint32 bufFrames = buf->frames; \
7190 int guardFrame __attribute__((__unused__)) = bufFrames - 2; \
7191 double loopMax = (double)bufSamples;
7192
7193 #define CHECK_DELTAP_BUF \
7194 if ((!bufData) || (bufChannels != 1)) { \
7195 unit->mDone = true; \
7196 ClearUnitOutputs(unit, inNumSamples); \
7197 return; \
7198 }
7199
7200
7201 static void DelTapWr_first(DelTapWr *unit, int inNumSamples)
7202 {
7203 float fbufnum = IN0(0);
7204 uint32 bufnum = (uint32)fbufnum;
7205 float* in = IN(1);
7206 float* out = OUT(0);
7207
7208 uint32 phase = unit->m_phase;
7209
7210 DELTAP_BUF
7211 CHECK_DELTAP_BUF
7212
7213 // zero out the buffer!
7214 #ifdef NOVA_SIMD
7215 if (nova::vec<float>::is_aligned(bufData)) {
7216 uint32 unroll = bufSamples & (~(nova::vec<float>::size - 1));
7217 nova::zerovec_simd(bufData, unroll);
7218
7219 uint32 remain = bufSamples - unroll;
7220 Clear(remain, bufData + unroll);
7221 } else
7222 Clear(bufSamples, bufData);
7223 #else
7224 Clear(bufSamples, bufData);
7225 #endif
7226
7227 out[0] = (float)phase;
7228 bufData[phase] = in[0];
7229 phase++;
7230 if(phase == bufSamples)
7231 phase -= bufSamples;
7232
7233 unit->m_phase = phase;
7234 }
7235
7236 void DelTapWr_Ctor(DelTapWr *unit)
7237 {
7238 if (BUFLENGTH & 15)
7239 SETCALC(DelTapWr_next);
7240 else
7241 SETCALC(DelTapWr_next_simd);
7242 unit->m_phase = 0;
7243 unit->m_fbufnum = -1e9f;
7244 DelTapWr_first(unit, 1);
7245 }
7246
7247 template <bool simd>
7248 static inline void DelTapWr_perform(DelTapWr *unit, int inNumSamples)
7249 {
7250 float fbufnum = IN0(0);
7251 uint32 bufnum = (uint32)fbufnum;
7252 const float* in = ZIN(1);
7253 float* out = ZOUT(0);
7254 uint32 * phase_out = (uint32*)out;
7255
7256 uint32 phase = unit->m_phase;
7257
7258 DELTAP_BUF
7259 CHECK_DELTAP_BUF
7260
7261 LOCK_SNDBUF(buf);
7262 int buf_remain = (int)(bufSamples - phase);
7263 if (inNumSamples < buf_remain)
7264 {
7265 /* fast-path */
7266 #ifdef NOVA_SIMD
7267 if (simd)
7268 nova::copyvec_an_simd(bufData+phase, IN(1), inNumSamples);
7269 else
7270 #endif
7271 Copy(inNumSamples, bufData + phase, IN(1));
7272 LOOP1 (inNumSamples,
7273 ZXP(phase_out) = phase++;
7274 )
7275 } else {
7276 LOOP1 (inNumSamples,
7277 bufData[phase] = ZXP(in);
7278 ZXP(phase_out) = phase++;
7279 if(phase == bufSamples)
7280 phase -= bufSamples;
7281 )
7282 }
7283
7284 unit->m_phase = phase;
7285 }
7286
7287 void DelTapWr_next(DelTapWr *unit, int inNumSamples)
7288 {
7289 DelTapWr_perform<false>(unit, inNumSamples);
7290 }
7291
7292 void DelTapWr_next_simd(DelTapWr *unit, int inNumSamples)
7293 {
7294 DelTapWr_perform<true>(unit, inNumSamples);
7295 }
7296
7297
7298 #define SETUP_TAPDELK \
7299 float delTime = unit->m_delTime; \
7300 float newDelTime = IN0(2) * (float)SAMPLERATE; \
7301 float delTimeInc = CALCSLOPE(newDelTime, delTime); \
7302 float * fPhaseIn = IN(1); \
7303 uint32 * iPhaseIn = (uint32*)fPhaseIn; \
7304 uint32 phaseIn = *iPhaseIn; \
7305 float fbufnum = IN0(0); \
7306 uint32 bufnum = (uint32)fbufnum; \
7307 float* out = ZOUT(0); \
7308
7309 #define SETUP_TAPDELA \
7310 float* delTime = ZIN(2); \
7311 float * fPhaseIn = IN(1); \
7312 uint32 * iPhaseIn = (uint32*)fPhaseIn; \
7313 uint32 phaseIn = *iPhaseIn; \
7314 float fbufnum = IN0(0); \
7315 uint32 bufnum = (uint32)fbufnum; \
7316 float* out = ZOUT(0); \
7317
7318 void DelTapRd_Ctor(DelTapRd *unit)
7319 {
7320 unit->m_fbufnum = -1e9f;
7321 unit->m_delTime = IN0(2) * SAMPLERATE;
7322 int interp = (int)IN0(3);
7323 if (INRATE(2) == calc_FullRate) {
7324 if (interp == 2)
7325 SETCALC(DelTapRd_next2_a);
7326 else if (interp == 4)
7327 SETCALC(DelTapRd_next4_a);
7328 else
7329 SETCALC(DelTapRd_next1_a);
7330 } else {
7331 if (interp == 2)
7332 SETCALC(DelTapRd_next2_k);
7333 else if (interp == 4)
7334 SETCALC(DelTapRd_next4_k);
7335 else
7336 if (BUFLENGTH & 15)
7337 SETCALC(DelTapRd_next1_k);
7338 else {
7339 SETCALC(DelTapRd_next1_k_simd);
7340 DelTapRd_next1_k(unit, 1);
7341 return;
7342 }
7343 }
7344 (unit->mCalcFunc)(unit, 1);
7345 }
7346
7347
7348 void DelTapRd_next1_a(DelTapRd *unit, int inNumSamples)
7349 {
7350 SETUP_TAPDELA
7351 DELTAP_BUF
7352 CHECK_DELTAP_BUF
7353
7354 LOCK_SNDBUF_SHARED(buf);
7355 LOOP1(inNumSamples,
7356 double curDelTimeSamps = ZXP(delTime) * SAMPLERATE;
7357 double phase = phaseIn - curDelTimeSamps;
7358 if(phase < 0.) phase += loopMax;
7359 if(phase >=loopMax) phase -= loopMax;
7360 int32 iphase = (int32)phase;
7361 ZXP(out) = bufData[iphase];
7362 phaseIn += 1.;
7363 )
7364 }
7365
7366 template <bool simd>
7367 inline void DelTapRd_perform1_k(DelTapRd *unit, int inNumSamples)
7368 {
7369 SETUP_TAPDELK
7370 DELTAP_BUF
7371 CHECK_DELTAP_BUF
7372 float * zout = ZOUT(0);
7373
7374 LOCK_SNDBUF_SHARED(buf);
7375 if (delTime == newDelTime)
7376 {
7377 double phase = (double)phaseIn - delTime;
7378 int32 iphase = (int32)phase;
7379 if ( (iphase >= 0) // lower bound
7380 && iphase + inNumSamples < (bufSamples - 1)) //upper bound
7381 {
7382 #ifdef NOVA_SIMD
7383 if (simd)
7384 nova::copyvec_na_simd(OUT(0), bufData + iphase, inNumSamples);
7385 else
7386 #endif
7387 Copy(inNumSamples, OUT(0), bufData + iphase);
7388 }
7389 else
7390 LOOP1(inNumSamples,
7391 if(iphase < 0) iphase += bufSamples;
7392 if(iphase >= bufSamples) iphase -= bufSamples;
7393 ZXP(zout) = bufData[iphase];
7394 ++iphase;
7395 )
7396 } else {
7397 LOOP1(inNumSamples,
7398 double phase = (double)phaseIn - delTime;
7399 if(phase < 0.) phase += loopMax;
7400 if(phase >=loopMax) phase -= loopMax;
7401 int32 iphase = (int32)phase;
7402 ZXP(zout) = bufData[iphase];
7403 delTime += delTimeInc;
7404 ++phaseIn;
7405 )
7406 unit->m_delTime = delTime;
7407 }
7408 }
7409
7410 void DelTapRd_next1_k(DelTapRd *unit, int inNumSamples)
7411 {
7412 DelTapRd_perform1_k<false>(unit, inNumSamples);
7413 }
7414
7415 void DelTapRd_next1_k_simd(DelTapRd *unit, int inNumSamples)
7416 {
7417 DelTapRd_perform1_k<true>(unit, inNumSamples);
7418 }
7419
7420 void DelTapRd_next2_k(DelTapRd *unit, int inNumSamples)
7421 {
7422 SETUP_TAPDELK
7423 DELTAP_BUF
7424 CHECK_DELTAP_BUF
7425
7426 int32 iloopMax = (int32)bufSamples;
7427
7428 LOCK_SNDBUF_SHARED(buf);
7429
7430 if (delTime == newDelTime)
7431 {
7432 double phase = (double)phaseIn - delTime;
7433 double dphase;
7434 float fracphase = std::modf(phase, &dphase);
7435 int32 iphase = (int32)dphase;
7436
7437 if ( (phase >= 0) // lower bound
7438 && phase + inNumSamples < (loopMax - 2)) //upper bound
7439 {
7440 LOOP1(inNumSamples,
7441 int32 iphase1 = iphase + 1;
7442 float b = bufData[iphase];
7443 float c = bufData[iphase1];
7444 ZXP(out) = (b + fracphase * (c - b));
7445 iphase += 1;
7446 );
7447 } else {
7448 LOOP1(inNumSamples,
7449 if(iphase < 0) iphase += iloopMax;
7450 else if(iphase >= bufSamples) phase -= iloopMax;
7451 int32 iphase1 = iphase + 1;
7452 if(iphase1 >= iloopMax) iphase1 -= iloopMax;
7453 float b = bufData[iphase];
7454 float c = bufData[iphase1];
7455 ZXP(out) = (b + fracphase * (c - b));
7456 ++iphase;
7457 );
7458 }
7459 } else {
7460 LOOP1(inNumSamples,
7461 double phase = (double)phaseIn - delTime;
7462 if(phase < 0.) phase += loopMax;
7463 if(phase >= loopMax) phase -= loopMax;
7464 int32 iphase = (int32)phase;
7465 int32 iphase1 = iphase + 1;
7466 if(iphase1 >= iloopMax) iphase1 -= iloopMax;
7467 float fracphase = phase - (double)iphase;
7468 float b = bufData[iphase];
7469 float c = bufData[iphase1];
7470 ZXP(out) = (b + fracphase * (c - b));
7471 delTime += delTimeInc;
7472 ++phaseIn;
7473 );
7474 unit->m_delTime = delTime;
7475 }
7476 }
7477
7478 void DelTapRd_next2_a(DelTapRd *unit, int inNumSamples)
7479 {
7480 SETUP_TAPDELA
7481 DELTAP_BUF
7482 CHECK_DELTAP_BUF
7483
7484 int32 iloopMax = (int32)bufSamples;
7485
7486 LOCK_SNDBUF_SHARED(buf);
7487 LOOP1(inNumSamples,
7488 double curDelTimeSamps = ZXP(delTime) * SAMPLERATE;
7489 double phase = (double)phaseIn - curDelTimeSamps;
7490 if(phase < 0.) phase += loopMax;
7491 if(phase >= loopMax) phase -= loopMax;
7492 int32 iphase = (int32)phase;
7493 int32 iphase1 = iphase + 1;
7494 if(iphase1 >= iloopMax) iphase1 -= iloopMax;
7495 float fracphase = phase - (double)iphase;
7496 float b = bufData[iphase];
7497 float c = bufData[iphase1];
7498 ZXP(out) = (b + fracphase * (c - b));
7499 ++phaseIn;
7500 );
7501 }
7502
7503 void DelTapRd_next4_k(DelTapRd *unit, int inNumSamples)
7504 {
7505 SETUP_TAPDELK
7506 DELTAP_BUF
7507 CHECK_DELTAP_BUF
7508
7509 int32 iloopMax = (int32)loopMax;
7510
7511 LOCK_SNDBUF_SHARED(buf);
7512
7513
7514 if (delTime == newDelTime)
7515 {
7516 double phase = (double)phaseIn - delTime;
7517 double dphase;
7518 float fracphase = std::modf(phase, &dphase);
7519 int32 iphase = (int32)dphase;
7520
7521 if ( (iphase >= 1) // lower bound
7522 && iphase + inNumSamples < (iloopMax - 4)) //upper bound
7523 {
7524 LOOP1(inNumSamples,
7525 int32 iphase0 = iphase - 1;
7526 int32 iphase1 = iphase + 1;
7527 int32 iphase2 = iphase + 2;
7528
7529 float a = bufData[iphase0];
7530 float b = bufData[iphase];
7531 float c = bufData[iphase1];
7532 float d = bufData[iphase2];
7533 ZXP(out) = cubicinterp(fracphase, a, b, c, d);
7534 ++iphase;
7535 );
7536 } else {
7537 LOOP1(inNumSamples,
7538 if(iphase < 0) iphase += iloopMax;
7539 else if(iphase >= iloopMax) iphase -= iloopMax;
7540 int32 iphase0 = iphase - 1;
7541 int32 iphase1 = iphase + 1;
7542 int32 iphase2 = iphase + 2;
7543
7544 if(iphase0 < 0) iphase0 += iloopMax;
7545 if(iphase1 > iloopMax) iphase1 -=iloopMax;
7546 if(iphase2 > iloopMax) iphase2 -=iloopMax;
7547
7548 float a = bufData[iphase0];
7549 float b = bufData[iphase];
7550 float c = bufData[iphase1];
7551 float d = bufData[iphase2];
7552 ZXP(out) = cubicinterp(fracphase, a, b, c, d);
7553 ++iphase;
7554 );
7555 }
7556 } else {
7557 LOOP1(inNumSamples,
7558 double phase = (double)phaseIn - delTime;
7559 double dphase;
7560 float fracphase = std::modf(phase, &dphase);
7561 int32 iphase = (int32)dphase;
7562
7563 if(iphase < 0.) iphase += iloopMax;
7564 if(iphase >= iloopMax) iphase -= iloopMax;
7565 int32 iphase0 = iphase - 1;
7566 int32 iphase1 = iphase + 1;
7567 int32 iphase2 = iphase + 2;
7568
7569 if(iphase0 < 0) iphase0 += iloopMax;
7570 if(iphase1 > iloopMax) iphase1 -=iloopMax;
7571 if(iphase2 > iloopMax) iphase2 -=iloopMax;
7572
7573 float a = bufData[iphase0];
7574 float b = bufData[iphase];
7575 float c = bufData[iphase1];
7576 float d = bufData[iphase2];
7577 ZXP(out) = cubicinterp(fracphase, a, b, c, d);
7578 delTime += delTimeInc;
7579 ++phaseIn;
7580 );
7581 unit->m_delTime = delTime;
7582 }
7583 }
7584
7585 void DelTapRd_next4_a(DelTapRd *unit, int inNumSamples)
7586 {
7587 SETUP_TAPDELA
7588 DELTAP_BUF
7589 CHECK_DELTAP_BUF
7590
7591 int32 iloopMax = (int32)loopMax;
7592
7593 LOCK_SNDBUF_SHARED(buf);
7594 LOOP1(inNumSamples,
7595 double curDelTimeSamps = ZXP(delTime) * SAMPLERATE;
7596 double phase = (double)phaseIn - curDelTimeSamps;
7597 if(phase < 0.) phase += loopMax;
7598 if(phase >= loopMax) phase -= loopMax;
7599 int32 iphase = (int32)phase;
7600 int32 iphase0 = iphase - 1;
7601 int32 iphase1 = iphase + 1;
7602 int32 iphase2 = iphase + 2;
7603
7604 if(iphase0 < 0) iphase0 += iloopMax;
7605 if(iphase1 > iloopMax) iphase1 -=iloopMax;
7606 if(iphase2 > iloopMax) iphase2 -=iloopMax;
7607
7608 float fracphase = phase - (double)iphase;
7609 float a = bufData[iphase0];
7610 float b = bufData[iphase];
7611 float c = bufData[iphase1];
7612 float d = bufData[iphase2];
7613 ZXP(out) = cubicinterp(fracphase, a, b, c, d);
7614 ++phaseIn;
7615 );
7616 }
7617
7618
7619 ////////////////////////////////////////////////////////////////////////////////////////////////////////
7620
7621
7622 ////////////////////////////////////////////////////////////////////////////////////////////////////////
7623
7624 PluginLoad(Delay)
7625 {
7626 ft = inTable;
7627
7628 #define DefineInfoUnit(name) \
7629 (*ft->fDefineUnit)(#name, sizeof(Unit), (UnitCtorFunc)&name##_Ctor, 0, 0);
7630
7631 DefineInfoUnit(ControlRate);
7632 DefineInfoUnit(SampleRate);
7633 DefineInfoUnit(SampleDur);
7634 DefineInfoUnit(ControlDur);
7635 DefineInfoUnit(SubsampleOffset);
7636 DefineInfoUnit(RadiansPerSample);
7637 DefineInfoUnit(NumInputBuses);
7638 DefineInfoUnit(NumOutputBuses);
7639 DefineInfoUnit(NumAudioBuses);
7640 DefineInfoUnit(NumControlBuses);
7641 DefineInfoUnit(NumBuffers);
7642 DefineInfoUnit(NumRunningSynths);
7643
7644 #define DefineBufInfoUnit(name) \
7645 (*ft->fDefineUnit)(#name, sizeof(BufInfoUnit), (UnitCtorFunc)&name##_Ctor, 0, 0);
7646
7647 DefineBufInfoUnit(BufSampleRate);
7648 DefineBufInfoUnit(BufRateScale);
7649 DefineBufInfoUnit(BufSamples);
7650 DefineBufInfoUnit(BufFrames);
7651 DefineBufInfoUnit(BufChannels);
7652 DefineBufInfoUnit(BufDur);
7653
7654 DefineSimpleCantAliasUnit(PlayBuf);
7655 #if NOTYET
7656 DefineSimpleUnit(SimpleLoopBuf);
7657 #endif
7658 DefineDtorUnit(RecordBuf);
7659 DefineSimpleUnit(BufRd);
7660 DefineSimpleUnit(BufWr);
7661 DefineDtorUnit(Pitch);
7662
7663 DefineSimpleUnit(BufDelayN);
7664 DefineSimpleUnit(BufDelayL);
7665 DefineSimpleUnit(BufDelayC);
7666 DefineSimpleUnit(BufCombN);
7667 DefineSimpleUnit(BufCombL);
7668 DefineSimpleUnit(BufCombC);
7669 DefineSimpleUnit(BufAllpassN);
7670 DefineSimpleUnit(BufAllpassL);
7671 DefineSimpleUnit(BufAllpassC);
7672
7673 #define DefineDelayUnit(name) \
7674 (*ft->fDefineUnit)(#name, sizeof(name), (UnitCtorFunc)&name##_Ctor, \
7675 (UnitDtorFunc)&DelayUnit_Dtor, 0);
7676
7677 DefineDelayUnit(DelayN);
7678 DefineDelayUnit(DelayL);
7679 DefineDelayUnit(DelayC);
7680 DefineDelayUnit(CombN);
7681 DefineDelayUnit(CombL);
7682 DefineDelayUnit(CombC);
7683 DefineDelayUnit(AllpassN);
7684 DefineDelayUnit(AllpassL);
7685 DefineDelayUnit(AllpassC);
7686
7687 DefineDtorUnit(PitchShift);
7688 DefineSimpleUnit(GrainTap);
7689 DefineSimpleCantAliasUnit(TGrains);
7690 DefineDtorUnit(ScopeOut);
7691 DefineDtorUnit(ScopeOut2);
7692 DefineDelayUnit(Pluck);
7693
7694 DefineSimpleUnit(DelTapWr);
7695 DefineSimpleUnit(DelTapRd);
7696
7697 DefineDtorUnit(LocalBuf);
7698 DefineSimpleUnit(MaxLocalBufs);
7699 DefineSimpleUnit(SetBuf);
7700 DefineSimpleUnit(ClearBuf);
7701 }
7702
7703 //////////////////////////////////////////////////////////////////////////////////////////////////